Show workspace, project, and env in KeyValue and Postgres text detail output (#502)

Updates the output for kv and pg commands to always show the workspace. If the datastore is in an environment, also displays the Project and Environment.

GROW-2601

GitOrigin-RevId: 3c9c94c6f14e6061d7587b298dbb317291d125bc

Author: davidharting

cmd/kvget_test.go

@@ -35,6 +35,23 @@ func TestKVGet_ByID_TextOutput(t *testing.T) {
 	assert.False(t, server.HasRequest("GET", "/connection-info"), "no connection info request without flag")
 }
 
+func TestKVGet_TextOutput_IncludesWorkspaceProjectAndEnvironment(t *testing.T) {
+	server := renderapi.NewServer(t)
+	project := server.CreateProject(
+		renderapi.ProjectAttrs{Name: "My Project", OwnerId: kvTestWorkspaceID},
+		renderapi.EnvAttrs{Name: "production"},
+	)
+	env := project.Env("production")
+	kv := seedKVInEnv(server, "project-cache", env.Id)
+
+	result, err := executeKVGet(t, server, kv.Id, "--output", "text")
+	require.NoError(t, err)
+
+	assert.Contains(t, result.Stdout, "Workspace: Test Workspace ("+kvTestWorkspaceID+")")
+	assert.Contains(t, result.Stdout, "Project: My Project ("+project.Project.Id+")")
+	assert.Contains(t, result.Stdout, "Environment: production ("+env.Id+")")
+}
+
 func TestKVGet_ByName_TextOutput(t *testing.T) {
 	server := renderapi.NewServer(t)
 	kv := seedKV(server, "by-name-cache")

cmd/pgget_test.go

@@ -48,6 +48,23 @@ func TestPGGet_ByID(t *testing.T) {
 	assert.False(t, harness.server.HasRequest("GET", "/connection-info"), "no connection info request without flag")
 }
 
+func TestPGGet_TextOutput_IncludesWorkspaceProjectAndEnvironment(t *testing.T) {
+	harness := newPGGetHarness(t)
+	project := harness.server.CreateProject(
+		renderapi.ProjectAttrs{Name: "My Project", OwnerId: pgActiveWorkspaceID},
+		renderapi.EnvAttrs{Name: "production"},
+	)
+	env := project.Env("production")
+	pg := seedPGInEnv(harness.server, "project-db", env.Id)
+
+	result, err := harness.execute(pg.Id, "--output", "text")
+	require.NoError(t, err)
+
+	assert.Contains(t, result.Stdout, "Workspace: Test Workspace ("+pgActiveWorkspaceID+")")
+	assert.Contains(t, result.Stdout, "Project: My Project ("+project.Project.Id+")")
+	assert.Contains(t, result.Stdout, "Environment: production ("+env.Id+")")
+}
+
 func TestPGGet_ByName(t *testing.T) {
 	harness := newPGGetHarness(t)
 	pg := seedPG(harness.server, "by-name-db")

internal/fakes/renderapi/server.go

@@ -301,6 +301,37 @@ func (s *Server) ownerByID(id string) (client.Owner, bool) {
 	return client.Owner{}, false
 }
 
+// hydrateOwner returns the registered Owner for resources that store only an
+// owner ID. Real API detail responses include the expanded owner object; the
+// fake keeps fixtures lightweight by letting tests seed resource.Owner.Id and
+// server.Owners separately. Callers should assign the result to a response
+// copy, not the stored fixture, so GET handlers do not mutate seeded state.
+func (s *Server) hydrateOwner(owner client.Owner) client.Owner {
+	if owner.Id == "" {
+		return owner
+	}
+	hydrated, ok := s.ownerByID(owner.Id)
+	if !ok {
+		return owner
+	}
+	if hydrated.Type == "" {
+		hydrated.Type = owner.Type
+	}
+	return hydrated
+}
+
+func (s *Server) keyValueDetailResponse(kv *client.KeyValueDetail) client.KeyValueDetail {
+	detail := *kv
+	detail.Owner = s.hydrateOwner(detail.Owner)
+	return detail
+}
+
+func (s *Server) postgresDetailResponse(pg *client.PostgresDetail) client.PostgresDetail {
+	detail := *pg
+	detail.Owner = s.hydrateOwner(detail.Owner)
+	return detail
+}
+
 // URL returns the base URL of the fake server.
 func (s *Server) URL() string {
 	return s.server.URL
@@ -614,7 +645,7 @@ func NewServer(t *testing.T) *Server {
 		}
 		s.KV.Instances = append(s.KV.Instances, kv)
 
-		writeJSON(w, http.StatusCreated, kv)
+		writeJSON(w, http.StatusCreated, s.keyValueDetailResponse(kv))
 	})
 
 	// GET /key-value/{id} — retrieve a KV instance
@@ -627,7 +658,7 @@ func NewServer(t *testing.T) *Server {
 		}
 		for _, kv := range s.KV.Instances {
 			if kv.Id == id {
-				writeJSON(w, http.StatusOK, kv)
+				writeJSON(w, http.StatusOK, s.keyValueDetailResponse(kv))
 				return
 			}
 		}
@@ -683,7 +714,7 @@ func NewServer(t *testing.T) *Server {
 			kv.IpAllowList = *body.IpAllowList
 		}
 		kv.UpdatedAt = time.Now()
-		writeJSON(w, http.StatusOK, kv)
+		writeJSON(w, http.StatusOK, s.keyValueDetailResponse(kv))
 	})
 
 	// POST /key-value/{id}/suspend — suspend a KV instance
@@ -833,7 +864,7 @@ func NewServer(t *testing.T) *Server {
 		}
 
 		s.Postgres.Instances = append(s.Postgres.Instances, pg)
-		writeJSON(w, http.StatusCreated, pg)
+		writeJSON(w, http.StatusCreated, s.postgresDetailResponse(pg))
 	})
 
 	// GET /postgres/{id} — retrieve a Postgres instance
@@ -846,7 +877,7 @@ func NewServer(t *testing.T) *Server {
 		}
 		for _, pg := range s.Postgres.Instances {
 			if pg.Id == id {
-				writeJSON(w, http.StatusOK, pg)
+				writeJSON(w, http.StatusOK, s.postgresDetailResponse(pg))
 				return
 			}
 		}
@@ -970,7 +1001,7 @@ func NewServer(t *testing.T) *Server {
 			pg.IpAllowList = *body.IpAllowList
 		}
 		pg.UpdatedAt = time.Now()
-		writeJSON(w, http.StatusOK, pg)
+		writeJSON(w, http.StatusOK, s.postgresDetailResponse(pg))
 	})
 
 	registerServiceRoutes(mux, s, record)

pkg/keyvalue/output.go

@@ -18,6 +18,7 @@ type KeyValueOut struct {
 	Version         string                           `json:"version,omitempty"`
 	OwnerID         string                           `json:"ownerId"`
 	OwnerType       client.OwnerType                 `json:"ownerType,omitempty"`
+	WorkspaceName   string                           `json:"-"`
 	ProjectID       *string                          `json:"projectId"`
 	ProjectName     string                           `json:"-"`
 	EnvironmentID   *string                          `json:"environmentId"`
@@ -83,17 +84,18 @@ func NewKeyValueOut(resolved *ResolvedKeyValue) KeyValueOut {
 
 	kv := resolved.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,
+		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,
+		WorkspaceName: kv.Owner.Name,
+		IPAllowList:   kv.IpAllowList,
 	}
 	if out.IPAllowList == nil {
 		out.IPAllowList = []client.CidrBlockAndDescription{}
@@ -130,17 +132,18 @@ func NewKeyValueOutFromModel(model *Model) 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,
+		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,
+		WorkspaceName: kv.Owner.Name,
+		IPAllowList:   kv.IpAllowList,
 	}
 	if out.IPAllowList == nil {
 		out.IPAllowList = []client.CidrBlockAndDescription{}

pkg/text/keyvalue.go

@@ -7,6 +7,8 @@ import (
 	"github.com/jedib0t/go-pretty/table"
 
 	"github.com/render-oss/cli/pkg/keyvalue"
+	"github.com/render-oss/cli/pkg/pointers"
+	rstrings "github.com/render-oss/cli/pkg/strings"
 )
 
 func KeyValueTable(v []keyvalue.KeyValueOut) string {
@@ -30,10 +32,21 @@ func KeyValueDetail(kv *keyvalue.KeyValueOut) string {
 	lines := []string{
 		fmt.Sprintf("Name: %s", kv.Name),
 		fmt.Sprintf("ID: %s", kv.ID),
+	}
+	if line := workspaceLine(kv.WorkspaceName, kv.OwnerID); line != "" {
+		lines = append(lines, line)
+	}
+	if label := rstrings.ResourceLabel(kv.ProjectName, pointers.StringValue(kv.ProjectID)); label != "" {
+		lines = append(lines, fmt.Sprintf("Project: %s", label))
+	}
+	if label := rstrings.ResourceLabel(kv.EnvironmentName, pointers.StringValue(kv.EnvironmentID)); label != "" {
+		lines = append(lines, fmt.Sprintf("Environment: %s", label))
+	}
+	lines = append(lines,
 		fmt.Sprintf("Plan: %s", string(kv.Plan)),
 		fmt.Sprintf("Region: %s", string(kv.Region)),
 		fmt.Sprintf("Status: %s", string(kv.Status)),
-	}
+	)
 	if kv.MaxmemoryPolicy != nil {
 		lines = append(lines, fmt.Sprintf("Memory policy: %s", *kv.MaxmemoryPolicy))
 	}

pkg/text/keyvalue_test.go

@@ -0,0 +1,62 @@
+package text_test
+
+import (
+	"testing"
+
+	"github.com/render-oss/cli/internal/testassert"
+	"github.com/render-oss/cli/pkg/client"
+	"github.com/render-oss/cli/pkg/keyvalue"
+	"github.com/render-oss/cli/pkg/pointers"
+	"github.com/render-oss/cli/pkg/text"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestKeyValueDetail_OmitsProjectAndEnvironmentWhenUnset(t *testing.T) {
+	kv := keyvalue.KeyValueOut{
+		ID:            "red-abc123",
+		Name:          "my-cache",
+		OwnerID:       "tea-workspace",
+		WorkspaceName: "My Workspace",
+		Region:        client.Oregon,
+		Status:        client.DatabaseStatusAvailable,
+	}
+
+	out := text.KeyValueDetail(&kv)
+
+	assert.NotContains(t, out, "Project:")
+	assert.NotContains(t, out, "Environment:")
+}
+
+func TestKeyValueDetail_HappyPath(t *testing.T) {
+	projectID := "prj-project"
+	envID := "evm-production"
+	memoryPolicy := "allkeys-lru"
+	kv := keyvalue.KeyValueOut{
+		ID:              "red-abc123",
+		Name:            "my-cache",
+		OwnerID:         "tea-workspace",
+		WorkspaceName:   "My Workspace",
+		ProjectID:       pointers.From(projectID),
+		ProjectName:     "My Project",
+		EnvironmentID:   pointers.From(envID),
+		EnvironmentName: "production",
+		Plan:            client.KeyValuePlanStarter,
+		Region:          client.Oregon,
+		Status:          client.DatabaseStatusAvailable,
+		MaxmemoryPolicy: pointers.From(memoryPolicy),
+	}
+
+	out := text.KeyValueDetail(&kv)
+
+	testassert.ContainsInOrder(t, out,
+		"Name: my-cache",
+		"ID: red-abc123",
+		"Workspace: My Workspace (tea-workspace)",
+		"Project: My Project (prj-project)",
+		"Environment: production (evm-production)",
+		"Plan: starter",
+		"Region: oregon",
+		"Status: available",
+		"Memory policy: allkeys-lru",
+	)
+}

pkg/text/owner.go

@@ -0,0 +1,15 @@
+package text
+
+import (
+	"fmt"
+
+	rstrings "github.com/render-oss/cli/pkg/strings"
+)
+
+func workspaceLine(name, id string) string {
+	label := rstrings.ResourceLabel(name, id)
+	if label == "" {
+		return ""
+	}
+	return fmt.Sprintf("Workspace: %s", label)
+}

pkg/text/postgres.go

@@ -7,7 +7,9 @@ import (
 	"github.com/jedib0t/go-pretty/table"
 
 	"github.com/render-oss/cli/pkg/client"
+	"github.com/render-oss/cli/pkg/pointers"
 	"github.com/render-oss/cli/pkg/postgres"
+	rstrings "github.com/render-oss/cli/pkg/strings"
 )
 
 func PostgresTable(v []postgres.PostgresListItemOut) string {
@@ -37,21 +39,29 @@ func PostgresDetail(pg *postgres.PostgresOut) string {
 	lines := []string{
 		fmt.Sprintf("Name: %s", pg.Name),
 		fmt.Sprintf("ID: %s", pg.Id),
+	}
+	if line := workspaceLine(pg.Owner.Name, pg.Owner.Id); line != "" {
+		lines = append(lines, line)
+	}
+	if label := rstrings.ResourceLabel(pg.ProjectName, pointers.StringValue(pg.ProjectID)); label != "" {
+		lines = append(lines, fmt.Sprintf("Project: %s", label))
+	}
+	if label := rstrings.ResourceLabel(pg.EnvironmentName, pointers.StringValue(pg.EnvironmentId)); label != "" {
+		lines = append(lines, fmt.Sprintf("Environment: %s", label))
+	}
+	lines = append(lines,
 		fmt.Sprintf("Plan: %s", string(pg.Plan)),
 		fmt.Sprintf("Version: %s", string(pg.Version)),
 		fmt.Sprintf("Region: %s", string(pg.Region)),
 		fmt.Sprintf("Status: %s", string(pg.Status)),
 		fmt.Sprintf("Database: %s", pg.DatabaseName),
 		fmt.Sprintf("User: %s", pg.DatabaseUser),
-	}
+	)
 	if pg.DiskSizeGB != nil {
 		lines = append(lines, fmt.Sprintf("Disk size: %d GB", *pg.DiskSizeGB))
 	}
 	lines = append(lines, fmt.Sprintf("Disk autoscaling: %s", boolLabel(pg.DiskAutoscalingEnabled)))
 	lines = append(lines, fmt.Sprintf("High availability: %s", boolLabel(pg.HighAvailabilityEnabled)))
-	if pg.EnvironmentId != nil {
-		lines = append(lines, fmt.Sprintf("Environment ID: %s", *pg.EnvironmentId))
-	}
 	lines = append(lines, fmt.Sprintf("Dashboard: %s", pg.DashboardUrl))
 	if block := readReplicasBlock(pg.ReadReplicas); block != "" {
 		lines = append(lines, block)