Add Postgres list and get support (#446)

Implement service, text formatter, and test helpers to support Postgres list and get commands.

PR 1 of 3 for https://linear.app/render-com/issue/GROW-2119/pg-listget

GitOrigin-RevId: eb17629a8028a0e9174d2ac0d88e4f5bcf6709cd

Author: davidharting

internal/fakes/renderapi/server.go

@@ -807,6 +807,24 @@ func NewServer(t *testing.T) *Server {
 		w.WriteHeader(http.StatusNotFound)
 	})
 
+	// GET /postgres/{id}/connection-info — retrieve connection strings for a Postgres instance
+	mux.HandleFunc("GET /postgres/{id}/connection-info", func(w http.ResponseWriter, r *http.Request) {
+		record(r)
+		id := r.PathValue("id")
+		for _, pg := range s.Postgres.Instances {
+			if pg.Id == id {
+				writeJSON(w, http.StatusOK, &client.PostgresConnectionInfo{
+					PsqlCommand:              "PGPASSWORD=fake-password psql fake-internal",
+					InternalConnectionString: "postgres://fake-internal",
+					ExternalConnectionString: "postgres://fake-external",
+					Password:                 "fake-password",
+				})
+				return
+			}
+		}
+		w.WriteHeader(http.StatusNotFound)
+	})
+
 	// DELETE /postgres/{id} — delete a Postgres instance
 	mux.HandleFunc("DELETE /postgres/{id}", func(w http.ResponseWriter, r *http.Request) {
 		record(r)

pkg/postgres/get.go

@@ -0,0 +1,10 @@
+package postgres
+
+import "github.com/render-oss/cli/pkg/client"
+
+// GetResult is the shape returned to callers (and serialized to JSON/YAML)
+// describing a fetched Postgres database together with its connection info.
+type GetResult struct {
+	Postgres       *client.PostgresDetail         `json:"postgres"`
+	ConnectionInfo *client.PostgresConnectionInfo `json:"connectionInfo"`
+}

pkg/postgres/list.go

@@ -0,0 +1,12 @@
+package postgres
+
+// ListInput describes optional active-workspace filters for listing Postgres
+// databases.
+type ListInput struct {
+	ProjectIDOrName     *string
+	EnvironmentIDOrName *string
+}
+
+func (i ListInput) HasFilter() bool {
+	return i.ProjectIDOrName != nil || i.EnvironmentIDOrName != nil
+}

pkg/postgres/service.go

@@ -27,6 +27,9 @@ func NewService(repo *Repo, environmentRepo *environment.Repo, projectRepo *proj
 	}
 }
 
+// ListPostgres lists Postgres databases using already-resolved API params.
+// Prefer List for command-facing project/environment selectors that still need
+// active-workspace scope resolution.
 func (s *Service) ListPostgres(ctx context.Context, params *client.ListPostgresParams) ([]*Model, error) {
 	postgres, err := s.repo.ListPostgres(ctx, params)
 	if err != nil {
@@ -38,7 +41,7 @@ func (s *Service) ListPostgres(ctx context.Context, params *client.ListPostgresP
 		return nil, err
 	}
 
-	var postgresModels []*Model
+	postgresModels := []*Model{}
 
 	for _, pg := range postgres {
 		model, err := s.hydratePostgresModel(ctx, pg, projects)
@@ -53,6 +56,25 @@ func (s *Service) ListPostgres(ctx context.Context, params *client.ListPostgresP
 	return postgresModels, nil
 }
 
+// List resolves active-workspace project/environment selectors into API params
+// before listing Postgres databases.
+func (s *Service) List(ctx context.Context, input ListInput) ([]*Model, error) {
+	params := &client.ListPostgresParams{}
+
+	if input.HasFilter() {
+		envIDs, err := s.listEnvIDs(ctx, input)
+		if err != nil {
+			return nil, err
+		}
+		if len(envIDs) == 0 {
+			return []*Model{}, nil
+		}
+		params.EnvironmentId = &envIDs
+	}
+
+	return s.ListPostgres(ctx, params)
+}
+
 func (s *Service) GetPostgres(ctx context.Context, id string) (*Model, error) {
 	postgres, err := s.repo.GetPostgres(ctx, id)
 	if err != nil {
@@ -71,6 +93,10 @@ func (s *Service) RestartPostgresDatabase(ctx context.Context, id string) error
 	return s.repo.RestartPostgresDatabase(ctx, id)
 }
 
+func (s *Service) GetConnectionInfo(ctx context.Context, id string) (*client.PostgresConnectionInfo, error) {
+	return s.repo.GetPostgresConnectionInfo(ctx, id)
+}
+
 // Resolve resolves a Postgres database by ID or name within an optional
 // active-workspace project/environment scope.
 func (s *Service) Resolve(ctx context.Context, input ResolveInput) (*client.PostgresDetail, error) {
@@ -124,6 +150,26 @@ func (s *Service) hydratePostgresModel(ctx context.Context, postgres *client.Pos
 	return model, nil
 }
 
+// listEnvIDs translates active-workspace project/environment selectors into
+// environment IDs to filter on. A valid project with no environments returns
+// an empty ID list, which callers should treat as an empty resource list rather
+// than an invalid selector.
+func (s *Service) listEnvIDs(ctx context.Context, input ListInput) ([]string, error) {
+	scope, err := s.resolver.ResolveScopeInActiveWorkspace(ctx, resolve.ActiveWorkspaceScopeInput{
+		ProjectIDOrName:     input.ProjectIDOrName,
+		EnvironmentIDOrName: input.EnvironmentIDOrName,
+	})
+	if err != nil {
+		return nil, err
+	}
+	if scope.Environment != nil {
+		return []string{scope.Environment.Id}, nil
+	}
+	// A successful filtered scope without a single environment is a project
+	// filter; use that project's environments as the candidate set.
+	return scope.Project.EnvironmentIds, nil
+}
+
 func (s *Service) environmentForPostgres(ctx context.Context, pg *client.Postgres, envs []*client.Environment) (*client.Environment, error) {
 	if pg.EnvironmentId == nil {
 		return nil, nil

pkg/postgres/service_test.go

@@ -181,6 +181,62 @@ func TestServiceDelete_DeletesByID(t *testing.T) {
 	assert.Empty(t, harness.server.Postgres.Instances)
 }
 
+func TestServiceList_FilterByProject(t *testing.T) {
+	harness := newHarness(t)
+
+	projAProdEnv := harness.addProjectAndEnvironment(harness.workspaceID, "Project A", "production")
+	projBProdEnv := harness.addProjectAndEnvironment(harness.workspaceID, "Project B", "production")
+	projAPostgres := harness.addPostgresInEnvironment("project-a-db", projAProdEnv.Id)
+	projBPostgres := harness.addPostgresInEnvironment("project-b-db", projBProdEnv.Id)
+
+	result, err := harness.service.List(context.Background(), postgres.ListInput{
+		ProjectIDOrName: pointers.From("Project A"),
+	})
+	require.NoError(t, err)
+
+	require.Len(t, result, 1)
+	assert.Equal(t, projAPostgres.Id, result[0].ID())
+	assert.NotEqual(t, projBPostgres.Id, result[0].ID())
+}
+
+func TestServiceList_ProjectWithNoEnvironmentsReturnsEmptyList(t *testing.T) {
+	harness := newHarness(t)
+	project := renderapi.NewProject(renderapi.ProjectAttrs{
+		Name:    "Empty Project",
+		OwnerId: harness.workspaceID,
+	})
+	harness.server.Projects.Add(project)
+
+	result, err := harness.service.List(context.Background(), postgres.ListInput{
+		ProjectIDOrName: pointers.From("Empty Project"),
+	})
+	require.NoError(t, err)
+
+	assert.Empty(t, result)
+	assert.NotNil(t, result)
+	assert.False(t, harness.server.HasRequest("GET", "/postgres"))
+}
+
+func TestServiceList_EnvironmentLookupStaysInActiveWorkspace(t *testing.T) {
+	harness := newHarness(t)
+	otherWorkspaceID := testids.WorkspaceID("other")
+	harness.server.Owners.Add(renderapi.NewOwner(client.Owner{Id: otherWorkspaceID, Name: "Other Workspace"}))
+
+	activeProduction := harness.addProjectAndEnvironment(harness.workspaceID, "Active Project", "production")
+	otherProduction := harness.addProjectAndEnvironment(otherWorkspaceID, "Other Project", "production")
+	activeWorkspacePG := harness.addPostgresInEnvironment("active-db", activeProduction.Id)
+	otherWorkspacePG := harness.addPostgresInWorkspaceEnvironment("other-db", otherWorkspaceID, otherProduction.Id)
+
+	result, err := harness.service.List(context.Background(), postgres.ListInput{
+		EnvironmentIDOrName: pointers.From("production"),
+	})
+	require.NoError(t, err)
+
+	require.Len(t, result, 1)
+	assert.NotEqual(t, otherWorkspacePG.Id, result[0].ID())
+	assert.Equal(t, activeWorkspacePG.Id, result[0].ID())
+}
+
 // Given 2 environments in different workspaces each named "production" each with a database named "my-pg",
 // Ensure that we resolve the Postgres instance relative to the active workspace
 func TestServiceResolve_EnvironmentLookupStaysInActiveWorkspace(t *testing.T) {

pkg/text/postgres.go

@@ -4,9 +4,32 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/jedib0t/go-pretty/table"
+
 	"github.com/render-oss/cli/pkg/client"
+	"github.com/render-oss/cli/pkg/postgres"
 )
 
+func PostgresTable(v []*postgres.Model) string {
+	t := newTable()
+	t.AppendHeader(table.Row{"Name", "Project", "Environment", "Plan", "Region", "Status", "ID"})
+	if len(v) == 0 {
+		t.SetCaption("No Postgres databases found.")
+	}
+	for _, m := range v {
+		t.AppendRow(table.Row{
+			m.Name(),
+			m.ProjectName(),
+			m.EnvironmentName(),
+			string(m.Postgres.Plan),
+			string(m.Postgres.Region),
+			string(m.Postgres.Status),
+			m.ID(),
+		})
+	}
+	return FormatString(t.Render())
+}
+
 // PostgresDetail formats a Postgres instance detail for text output.
 // Does NOT include an action prefix (e.g., "Created") — callers should prepend
 // their own action prefix in the formatText closure passed to command.NonInteractive.
@@ -37,6 +60,21 @@ func PostgresDetail(pg *client.PostgresDetail) string {
 	return strings.Join(lines, "\n")
 }
 
+func PostgresGetDetail(pg *client.PostgresDetail, conn *client.PostgresConnectionInfo) string {
+	detail := PostgresDetail(pg)
+	if conn == nil {
+		return detail
+	}
+	return strings.Join([]string{
+		detail,
+		"",
+		fmt.Sprintf("PSQL:     %s", conn.PsqlCommand),
+		fmt.Sprintf("Internal: %s", conn.InternalConnectionString),
+		fmt.Sprintf("External: %s", conn.ExternalConnectionString),
+		fmt.Sprintf("Password: %s", conn.Password),
+	}, "\n")
+}
+
 // readReplicasBlock renders the read-replica list as a header line followed by
 // "  - <name> (<id>)" entries. Returns an empty string when no replicas exist
 // — callers should skip the block entirely in that case.

pkg/text/postgres_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/render-oss/cli/pkg/client"
 	pgclient "github.com/render-oss/cli/pkg/client/postgres"
 	"github.com/render-oss/cli/pkg/pointers"
+	"github.com/render-oss/cli/pkg/postgres"
 	"github.com/render-oss/cli/pkg/text"
 )
 
@@ -111,3 +112,48 @@ func TestPostgresDetail_IPAllowList(t *testing.T) {
 		assert.Contains(t, out, "203.0.113.5/32")
 	})
 }
+
+func TestPostgresTable(t *testing.T) {
+	out := text.PostgresTable([]*postgres.Model{{
+		Postgres: &client.Postgres{
+			Id:     "dpg-table",
+			Name:   "table-pg",
+			Plan:   pgclient.Basic256mb,
+			Region: client.Oregon,
+			Status: client.DatabaseStatusAvailable,
+		},
+		Project:     &client.Project{Name: "Project A"},
+		Environment: &client.Environment{Name: "production"},
+	}})
+
+	assert.Contains(t, out, "table-pg")
+	assert.Contains(t, out, "Project A")
+	assert.Contains(t, out, "production")
+	assert.Contains(t, out, "basic_256mb")
+	assert.Contains(t, out, "dpg-table")
+}
+
+func TestPostgresTable_EmptyState(t *testing.T) {
+	out := text.PostgresTable([]*postgres.Model{})
+
+	assert.Contains(t, out, "NAME")
+	assert.Contains(t, out, "No Postgres databases found.")
+}
+
+func TestPostgresGetDetail_ConnectionInfo(t *testing.T) {
+	pg := basicPostgres()
+	conn := &client.PostgresConnectionInfo{
+		PsqlCommand:              "PGPASSWORD=secret psql postgres://internal",
+		InternalConnectionString: "postgres://internal",
+		ExternalConnectionString: "postgres://external",
+		Password:                 "secret",
+	}
+
+	out := text.PostgresGetDetail(pg, conn)
+
+	assert.Contains(t, out, "Name: my-pg")
+	assert.Contains(t, out, "PSQL:")
+	assert.Contains(t, out, "Internal: postgres://internal")
+	assert.Contains(t, out, "External: postgres://external")
+	assert.Contains(t, out, "Password: secret")
+}