feat: support listable and searchable adapter in dynamic adapters (#1923)

# Support Searchable and Listable adapters

We should support searchable and listable adapters that provides both
methods at the same time.

## Metadata
- URL:
[https://linear.app/overmind/issue/ENG-598/support-searchable-and-listable-adapters](https://linear.app/overmind/issue/ENG-598/support-searchable-and-listable-adapters)
- Identifier: ENG-598
- Status: In Review
- Priority: No priority
- Assignee: [email protected]
- Labels: Feature
- Project: [GCP
Support](https://linear.app/overmind/project/gcp-support-871ebbdcd5f9).
- Created: 2025-06-13T11:06:01.895Z
- Updated: 2025-06-18T17:05:03.642Z

## Pull requests

- [#1878 Support Searchable and Listable
adapters](https://github.com/overmindtech/workspace/issues/1878)
- [feat: support listable and searchable adapter in dynamic
adapters](https://github.com/overmindtech/workspace/pull/1923)

## Comments

- GitHub integration:

This comment thread is synced to a corresponding [GitHub
issue](https://github.com/overmindtech/workspace/issues/1878). All
replies are displayed in both locations.

GitOrigin-RevId: e2f324b98a1771338bfe36140663137971b27510

Author: tphoney

sources/gcp/dynamic/adapter-searchable-listable.go

@@ -0,0 +1,117 @@
+package dynamic
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/overmindtech/cli/discovery"
+	"github.com/overmindtech/cli/sdp-go"
+	gcpshared "github.com/overmindtech/cli/sources/gcp/shared"
+)
+
+type SearchableListableDiscoveryAdapter interface {
+	discovery.SearchableAdapter
+	discovery.ListableAdapter
+}
+
+// SearchableListableAdapter implements discovery.SearchableAdapter for GCP dynamic adapters.
+type SearchableListableAdapter struct {
+	searchEndpointFunc gcpshared.EndpointFunc
+	ListableAdapter
+}
+
+// NewSearchableListableAdapter creates a new GCP dynamic adapter.
+func NewSearchableListableAdapter(searchURLFunc gcpshared.EndpointFunc, listEndpoint string, config *AdapterConfig) SearchableListableDiscoveryAdapter {
+	return SearchableListableAdapter{
+		searchEndpointFunc: searchURLFunc,
+		ListableAdapter: ListableAdapter{
+			listEndpoint: listEndpoint,
+			Adapter: Adapter{
+				projectID:  config.ProjectID,
+				scope:      config.Scope,
+				httpCli:    config.HTTPClient,
+				getURLFunc: config.GetURLFunc,
+				httpHeaders: http.Header{
+					"Authorization": []string{"Bearer " + config.Token},
+				},
+				sdpAssetType:        config.SDPAssetType,
+				sdpAdapterCategory:  config.SDPAdapterCategory,
+				terraformMappings:   config.TerraformMappings,
+				linker:              config.Linker,
+				potentialLinks:      potentialLinksFromBlasts(config.SDPAssetType, gcpshared.BlastPropagations),
+				uniqueAttributeKeys: config.UniqueAttributeKeys,
+			},
+		},
+	}
+}
+
+func (g SearchableListableAdapter) Metadata() *sdp.AdapterMetadata {
+	return &sdp.AdapterMetadata{
+		Type:            g.sdpAssetType.String(),
+		Category:        g.sdpAdapterCategory,
+		DescriptiveName: g.sdpAssetType.Readable(),
+		SupportedQueryMethods: &sdp.AdapterSupportedQueryMethods{
+			Get:               true,
+			GetDescription:    getDescription(g.sdpAssetType, g.scope, g.uniqueAttributeKeys),
+			Search:            true,
+			SearchDescription: searchDescription(g.sdpAssetType, g.scope, g.uniqueAttributeKeys),
+			List:              true,
+			ListDescription:   listDescription(g.sdpAssetType, g.scope),
+		},
+		TerraformMappings: g.terraformMappings,
+		PotentialLinks:    g.potentialLinks,
+	}
+}
+
+func (g SearchableListableAdapter) Search(ctx context.Context, scope, query string, ignoreCache bool) ([]*sdp.Item, error) {
+	if scope != g.scope {
+		return nil, &sdp.QueryError{
+			ErrorType:   sdp.QueryError_NOSCOPE,
+			ErrorString: fmt.Sprintf("requested scope %v does not match any adapter scope %v", scope, g.Scopes()),
+		}
+	}
+	searchEndpoint := g.searchEndpointFunc(query)
+	if searchEndpoint == "" {
+		return nil, &sdp.QueryError{
+			ErrorType:   sdp.QueryError_OTHER,
+			ErrorString: fmt.Sprintf("no search endpoint found for query \"%s\". %s", query, g.Metadata().GetSupportedQueryMethods().GetSearchDescription()),
+		}
+	}
+
+	var items []*sdp.Item
+	itemsSelector := g.uniqueAttributeKeys[len(g.uniqueAttributeKeys)-1] // Use the last key as the item selector
+
+	if strings.HasPrefix(query, "projects/") {
+		// This is a single item query for terraform search method mappings.
+		// See: https://linear.app/overmind/issue/ENG-580/handle-terraform-mappings-in-search-method
+		resp, err := externalCallSingle(ctx, g.httpCli, g.httpHeaders, searchEndpoint)
+		if err != nil {
+			return nil, err
+		}
+
+		item, err := externalToSDP(ctx, g.projectID, g.scope, g.uniqueAttributeKeys, resp, g.sdpAssetType, g.linker)
+		if err != nil {
+			return nil, err
+		}
+
+		return append(items, item), nil
+	}
+
+	multiResp, err := externalCallMulti(ctx, itemsSelector, g.httpCli, g.httpHeaders, searchEndpoint)
+	if err != nil {
+		return nil, fmt.Errorf("failed to retrieve items for %s: %w", searchEndpoint, err)
+	}
+
+	for _, resp := range multiResp {
+		item, err := externalToSDP(ctx, g.projectID, g.scope, g.uniqueAttributeKeys, resp, g.sdpAssetType, g.linker)
+		if err != nil {
+			return nil, err
+		}
+
+		items = append(items, item)
+	}
+
+	return items, nil
+}

sources/gcp/dynamic/adapters.go

@@ -10,6 +10,15 @@ import (
 	"github.com/overmindtech/cli/sources/shared"
 )
 
+type typeOfAdapter string
+
+const (
+	Standard           typeOfAdapter = "standard"
+	Listable           typeOfAdapter = "listable"
+	Searchable         typeOfAdapter = "searchable"
+	SearchableListable typeOfAdapter = "searchableListable"
+)
+
 var adaptersByScope = map[gcpshared.Scope]map[shared.ItemType]gcpshared.AdapterMeta{}
 
 func init() {
@@ -52,29 +61,12 @@ func Adapters(projectID string, token string, regions []string, zones []string,
 			UniqueAttributeKeys: meta.UniqueAttributeKeys,
 		}
 
-		if meta.ListEndpointFunc != nil {
-			listEndpoint, err := meta.ListEndpointFunc(projectID)
-			if err != nil {
-				return nil, err
-			}
-
-			adapters = append(adapters, NewListableAdapter(listEndpoint, cfg))
-
-			continue
-		}
-
-		if meta.SearchEndpointFunc != nil {
-			searchEndpointFunc, err := meta.SearchEndpointFunc(projectID)
-			if err != nil {
-				return nil, err
-			}
-
-			adapters = append(adapters, NewSearchableAdapter(searchEndpointFunc, cfg))
-
-			continue
+		adapter, err := makeAdapter(meta, cfg, projectID)
+		if err != nil {
+			return nil, fmt.Errorf("failed to add adapter for %s: %w", sdpItemType, err)
 		}
 
-		adapters = append(adapters, NewAdapter(cfg))
+		adapters = append(adapters, adapter)
 	}
 
 	// Regional adapters
@@ -105,28 +97,12 @@ func Adapters(projectID string, token string, regions []string, zones []string,
 				UniqueAttributeKeys: meta.UniqueAttributeKeys,
 			}
 
-			if meta.ListEndpointFunc != nil {
-				listEndpoint, err := meta.ListEndpointFunc(projectID, region)
-				if err != nil {
-					return nil, err
-				}
-				adapters = append(adapters, NewListableAdapter(listEndpoint, cfg))
-
-				continue
-			}
-
-			if meta.SearchEndpointFunc != nil {
-				searchEndpointFunc, err := meta.SearchEndpointFunc(projectID, region)
-				if err != nil {
-					return nil, err
-				}
-
-				adapters = append(adapters, NewSearchableAdapter(searchEndpointFunc, cfg))
-
-				continue
+			adapter, err := makeAdapter(meta, cfg, projectID, region)
+			if err != nil {
+				return nil, fmt.Errorf("failed to add adapter for %s in region %s: %w", sdpItemType, region, err)
 			}
 
-			adapters = append(adapters, NewAdapter(cfg))
+			adapters = append(adapters, adapter)
 		}
 	}
 
@@ -158,30 +134,65 @@ func Adapters(projectID string, token string, regions []string, zones []string,
 				UniqueAttributeKeys: meta.UniqueAttributeKeys,
 			}
 
-			if meta.ListEndpointFunc != nil {
-				listEndpoint, err := meta.ListEndpointFunc(projectID, zone)
-				if err != nil {
-					return nil, err
-				}
-				adapters = append(adapters, NewListableAdapter(listEndpoint, cfg))
-
-				continue
+			adapter, err := makeAdapter(meta, cfg, projectID, zone)
+			if err != nil {
+				return nil, fmt.Errorf("failed to add adapter for %s in zone %s: %w", sdpItemType, zone, err)
 			}
 
-			if meta.SearchEndpointFunc != nil {
-				searchEndpointFunc, err := meta.SearchEndpointFunc(projectID, zone)
-				if err != nil {
-					return nil, err
-				}
+			adapters = append(adapters, adapter)
+		}
+	}
 
-				adapters = append(adapters, NewSearchableAdapter(searchEndpointFunc, cfg))
+	return adapters, nil
+}
 
-				continue
-			}
+func adapterType(meta gcpshared.AdapterMeta) typeOfAdapter {
+	if meta.ListEndpointFunc != nil && meta.SearchEndpointFunc == nil {
+		return Listable
+	}
 
-			adapters = append(adapters, NewAdapter(cfg))
-		}
+	if meta.SearchEndpointFunc != nil && meta.ListEndpointFunc == nil {
+		return Searchable
 	}
 
-	return adapters, nil
+	if meta.ListEndpointFunc != nil && meta.SearchEndpointFunc != nil {
+		return SearchableListable
+	}
+
+	return Standard
+}
+
+func makeAdapter(meta gcpshared.AdapterMeta, cfg *AdapterConfig, opts ...string) (discovery.Adapter, error) {
+	switch adapterType(meta) {
+	case SearchableListable:
+		searchEndpointFunc, err := meta.SearchEndpointFunc(opts...)
+		if err != nil {
+			return nil, err
+		}
+
+		listEndpoint, err := meta.ListEndpointFunc(opts...)
+		if err != nil {
+			return nil, err
+		}
+
+		return NewSearchableListableAdapter(searchEndpointFunc, listEndpoint, cfg), nil
+	case Searchable:
+		searchEndpointFunc, err := meta.SearchEndpointFunc(opts...)
+		if err != nil {
+			return nil, err
+		}
+
+		return NewSearchableAdapter(searchEndpointFunc, cfg), nil
+	case Listable:
+		listEndpoint, err := meta.ListEndpointFunc(opts...)
+		if err != nil {
+			return nil, err
+		}
+
+		return NewListableAdapter(listEndpoint, cfg), nil
+	case Standard:
+		return NewAdapter(cfg), nil
+	default:
+		return nil, fmt.Errorf("unknown adapter type %s", adapterType(meta))
+	}
 }