Add Key Value output contract for list (#477)

render ea kv list -o json returns `{ "data": [...] }`

instead of just `[...]`

Part of GROW-2587

GitOrigin-RevId: f84cb8636feae176df06db07d8277173cd523d27

Author: davidharting

cmd/kvlist.go

@@ -1,6 +1,8 @@
 package cmd
 
 import (
+	"context"
+
 	"github.com/spf13/cobra"
 
 	"github.com/render-oss/cli/pkg/client"
@@ -12,7 +14,7 @@ import (
 	kvtypes "github.com/render-oss/cli/pkg/types/keyvalue"
 )
 
-func newKVListCmd(_ *dependencies.Dependencies) *cobra.Command {
+func newKVListCmd(deps *dependencies.Dependencies) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:          "list",
 		Short:        "List Key Value store instances",
@@ -53,23 +55,31 @@ resolved within that project.`,
 		}
 		input = kvtypes.NormalizeListInput(input)
 
-		_, err := command.NonInteractive(cmd, func() ([]*keyvalue.Model, error) {
+		_, err := command.NonInteractive(cmd, func() (*keyvalue.KeyValueListOut, error) {
 			params := &client.ListKeyValueParams{}
 
-			envIDs, ok, err := resolveListEnvIDs(cmd, input)
+			envIDs, ok, err := resolveListEnvIDs(cmd.Context(), deps, input)
 			if err != nil {
 				return nil, err
 			}
 			if ok {
 				if len(envIDs) == 0 {
-					return nil, nil
+					out := keyvalue.NewKeyValueListOut(nil)
+					return &out, nil
 				}
 				envParam := client.EnvironmentIdParam(envIDs)
 				params.EnvironmentId = &envParam
 			}
 
-			return keyvalue.List(cmd.Context(), params)
-		}, text.KeyValueTable)
+			models, err := deps.KeyValueService().ListKeyValue(cmd.Context(), params)
+			if err != nil {
+				return nil, err
+			}
+			out := keyvalue.NewKeyValueListOut(models)
+			return &out, nil
+		}, func(out *keyvalue.KeyValueListOut) string {
+			return text.KeyValueTable(out.Data)
+		})
 		return err
 	}
 
@@ -79,16 +89,12 @@ resolved within that project.`,
 // resolveListEnvIDs translates --project/--environment selectors into the
 // environment IDs to filter on. The second return value is true when the
 // caller should apply an environment filter; false means list workspace-wide.
-func resolveListEnvIDs(cmd *cobra.Command, input kvtypes.KeyValueListInput) ([]string, bool, error) {
+func resolveListEnvIDs(ctx context.Context, deps *dependencies.Dependencies, input kvtypes.KeyValueListInput) ([]string, bool, error) {
 	if input.ProjectIDOrName == nil && input.EnvironmentIDOrName == nil {
 		return nil, false, nil
 	}
 
-	c, err := client.NewDefaultClient()
-	if err != nil {
-		return nil, false, err
-	}
-	scope, err := resolve.NewFromClient(c).ResolveScopeInActiveWorkspace(cmd.Context(), resolve.ActiveWorkspaceScopeInput{
+	scope, err := deps.Resolver().ResolveScopeInActiveWorkspace(ctx, resolve.ActiveWorkspaceScopeInput{
 		ProjectIDOrName:     input.ProjectIDOrName,
 		EnvironmentIDOrName: input.EnvironmentIDOrName,
 	})

cmd/kvlist_test.go

@@ -78,21 +78,30 @@ func TestKVList_FilterByEnvironmentName(t *testing.T) {
 
 func TestKVList_JSONOutput(t *testing.T) {
 	server := renderapi.NewServer(t)
-	kv := seedKV(server, "json-cache")
+	proj := server.CreateProject(
+		renderapi.ProjectAttrs{Name: "My Project", OwnerId: kvTestWorkspaceID},
+		renderapi.EnvAttrs{Name: "production"},
+	)
+	first := seedKVInEnv(server, "json-cache-one", proj.Env("production").Id)
+	second := seedKVInEnv(server, "json-cache-two", proj.Env("production").Id)
 
 	result, err := executeKVList(t, server, "--output", "json")
 	require.NoError(t, err)
 
-	var body []struct {
-		KeyValue struct {
-			ID   string `json:"id"`
-			Name string `json:"name"`
-		} `json:"keyValue"`
-	}
+	var body map[string]any
 	require.NoError(t, json.Unmarshal([]byte(result.Stdout), &body))
-	require.Len(t, body, 1)
-	assert.Equal(t, kv.Id, body[0].KeyValue.ID)
-	assert.Equal(t, "json-cache", body[0].KeyValue.Name)
+	data := requireSubSlice(t, body, "data")
+	require.Len(t, data, 2)
+	require.IsType(t, map[string]any{}, data[0])
+	require.IsType(t, map[string]any{}, data[1])
+	firstItem := data[0].(map[string]any)
+	secondItem := data[1].(map[string]any)
+
+	assert.Equal(t, first.Id, firstItem["id"])
+	assert.Equal(t, "json-cache-one", firstItem["name"])
+	assert.Equal(t, second.Id, secondItem["id"])
+	assert.Equal(t, "json-cache-two", secondItem["name"])
+	assert.NotContains(t, firstItem, "keyValue")
 }
 
 func TestKVList_DefaultOutput_TreatedAsText(t *testing.T) {

cmd/testhelpers_test.go

@@ -30,3 +30,12 @@ func requireSubMap(t *testing.T, body map[string]any, key string) map[string]any
 	require.IsType(t, map[string]any{}, body[key], "expected %q to contain a map", key)
 	return body[key].(map[string]any)
 }
+
+// requireSubSlice returns the nested slice stored at key, failing the test if
+// the key is absent or the value is not a []any.
+func requireSubSlice(t *testing.T, body map[string]any, key string) []any {
+	t.Helper()
+	require.Contains(t, body, key, "expected %q", key)
+	require.IsType(t, []any{}, body[key], "expected %q to contain a slice", key)
+	return body[key].([]any)
+}

internal/fakes/renderapi/server.go

@@ -491,6 +491,8 @@ func NewServer(t *testing.T) *Server {
 		name := r.URL.Query().Get("name")
 		envIDs := queryListValues(r, "environmentId")
 		result := make([]client.KeyValueWithCursor, 0, len(s.KV.Instances))
+		// Preserve insertion order so list tests can make deterministic
+		// assertions about multiple resources.
 		for i, kv := range s.KV.Instances {
 			if name != "" && kv.Name != name {
 				continue
@@ -503,9 +505,18 @@ func NewServer(t *testing.T) *Server {
 			result = append(result, client.KeyValueWithCursor{
 				Cursor: client.Cursor(fmt.Sprintf("c%d", i)),
 				KeyValue: client.KeyValue{
+					CreatedAt:     kv.CreatedAt,
+					EnvironmentId: kv.EnvironmentId,
 					Id:            kv.Id,
+					IpAllowList:   kv.IpAllowList,
 					Name:          kv.Name,
-					EnvironmentId: kv.EnvironmentId,
+					Options:       kv.Options,
+					Owner:         kv.Owner,
+					Plan:          kv.Plan,
+					Region:        kv.Region,
+					Status:        kv.Status,
+					UpdatedAt:     kv.UpdatedAt,
+					Version:       kv.Version,
 				},
 			})
 		}

pkg/keyvalue/list.go

@@ -33,6 +33,10 @@ type KeyValueGetOut struct {
 
 type KeyValueCreateOut = KeyValueGetOut
 
+type KeyValueListOut struct {
+	Data []KeyValueOut `json:"data"`
+}
+
 type DeleteOut struct {
 	Data KeyValueOut   `json:"data"`
 	Meta DeleteOutMeta `json:"meta"`
@@ -110,3 +114,50 @@ func NewKeyValueOut(resolved *ResolvedKeyValue) KeyValueOut {
 	}
 	return out
 }
+
+func NewKeyValueListOut(models []*Model) KeyValueListOut {
+	data := make([]KeyValueOut, 0, len(models))
+	for _, model := range models {
+		data = append(data, NewKeyValueOutFromModel(model))
+	}
+	return KeyValueListOut{Data: data}
+}
+
+func NewKeyValueOutFromModel(model *Model) KeyValueOut {
+	if model == nil || model.KeyValue == nil {
+		return KeyValueOut{}
+	}
+
+	kv := model.KeyValue
+	out := KeyValueOut{
+		ID:          kv.Id,
+		Name:        kv.Name,
+		Plan:        kv.Plan,
+		Region:      kv.Region,
+		Status:      kv.Status,
+		CreatedAt:   kv.CreatedAt,
+		UpdatedAt:   kv.UpdatedAt,
+		Version:     kv.Version,
+		OwnerID:     kv.Owner.Id,
+		OwnerType:   kv.Owner.Type,
+		IPAllowList: kv.IpAllowList,
+	}
+	if out.IPAllowList == nil {
+		out.IPAllowList = []client.CidrBlockAndDescription{}
+	}
+	if kv.Options.MaxmemoryPolicy != nil {
+		out.MaxmemoryPolicy = kv.Options.MaxmemoryPolicy
+	}
+	if kv.EnvironmentId != nil {
+		out.EnvironmentID = kv.EnvironmentId
+	}
+	if model.Environment != nil {
+		out.EnvironmentID = &model.Environment.Id
+		out.EnvironmentName = model.Environment.Name
+	}
+	if model.Project != nil {
+		out.ProjectID = &model.Project.Id
+		out.ProjectName = model.Project.Name
+	}
+	return out
+}

pkg/keyvalue/output.go

@@ -10,18 +10,18 @@ import (
 	"github.com/render-oss/cli/pkg/keyvalue"
 )
 
-func KeyValueTable(v []*keyvalue.Model) string {
+func KeyValueTable(v []keyvalue.KeyValueOut) string {
 	t := newTable()
 	t.AppendHeader(table.Row{"Name", "Project", "Environment", "Plan", "Region", "Status", "ID"})
-	for _, m := range v {
+	for _, kv := range v {
 		t.AppendRow(table.Row{
-			m.Name(),
-			m.ProjectName(),
-			m.EnvironmentName(),
-			string(m.KeyValue.Plan),
-			string(m.KeyValue.Region),
-			string(m.KeyValue.Status),
-			m.ID(),
+			kv.Name,
+			kv.ProjectName,
+			kv.EnvironmentName,
+			string(kv.Plan),
+			string(kv.Region),
+			string(kv.Status),
+			kv.ID,
 		})
 	}
 	return FormatString(t.Render())