refactor: enrich resolved postgres scope (#479)

`postgres.Service` has a `Resolve` method that returns a client.PostgresDetail object.

This makes it instead return a struct that contains the Postgres detail, as well as the Project and Environment it belongs to (if it belongs to one).

GROW-2588

GitOrigin-RevId: a987cf5e39d274e7c24065c3f640b790d1029d95

Author: davidharting

cmd/pgdelete.go

@@ -81,14 +81,15 @@ Postgres ID instead (which works across workspaces).`,
 		confirm := command.GetConfirmFromContext(cmd.Context())
 
 		loadData := func() (*pgDeleteResult, error) {
-			pg, err := deps.PostgresService().Resolve(cmd.Context(), postgres.ResolveInput{
+			resolved, err := deps.PostgresService().Resolve(cmd.Context(), postgres.ResolveInput{
 				IDOrName:            input.IDOrName,
 				ProjectIDOrName:     input.ProjectIDOrName,
 				EnvironmentIDOrName: input.EnvironmentIDOrName,
 			})
 			if err != nil {
 				return nil, err
 			}
+			pg := resolved.Postgres
 			if confirm {
 				if err := deps.PostgresService().Delete(cmd.Context(), pg.Id); err != nil {
 					return nil, err

cmd/pgget.go

@@ -62,14 +62,15 @@ Postgres ID instead (which works across workspaces).`,
 		input = pgtypes.NormalizeGetInput(input)
 
 		loadData := func() (*postgres.GetResult, error) {
-			pg, err := deps.PostgresService().Resolve(cmd.Context(), postgres.ResolveInput{
+			resolved, err := deps.PostgresService().Resolve(cmd.Context(), postgres.ResolveInput{
 				IDOrName:            input.IDOrName,
 				ProjectIDOrName:     input.ProjectIDOrName,
 				EnvironmentIDOrName: input.EnvironmentIDOrName,
 			})
 			if err != nil {
 				return nil, err
 			}
+			pg := resolved.Postgres
 			var conn *client.PostgresConnectionInfo
 			if input.IncludeSensitiveConnectionInfo {
 				conn, err = deps.PostgresService().GetConnectionInfo(cmd.Context(), pg.Id)

cmd/pgresume.go

@@ -57,18 +57,23 @@ Postgres ID instead (which works across workspaces).`,
 		input = pgtypes.NormalizeResumeInput(input)
 
 		loadData := func() (*client.PostgresDetail, error) {
-			pg, err := deps.PostgresService().Resolve(cmd.Context(), postgres.ResolveInput{
+			resolved, err := deps.PostgresService().Resolve(cmd.Context(), postgres.ResolveInput{
 				IDOrName:            input.IDOrName,
 				ProjectIDOrName:     input.ProjectIDOrName,
 				EnvironmentIDOrName: input.EnvironmentIDOrName,
 			})
 			if err != nil {
 				return nil, err
 			}
+			pg := resolved.Postgres
 			if err := deps.PostgresService().ResumePostgres(cmd.Context(), pg.Id); err != nil {
 				return nil, err
 			}
-			return deps.PostgresService().Resolve(cmd.Context(), postgres.ResolveInput{IDOrName: pg.Id})
+			resolved, err = deps.PostgresService().Resolve(cmd.Context(), postgres.ResolveInput{IDOrName: pg.Id})
+			if err != nil {
+				return nil, err
+			}
+			return resolved.Postgres, nil
 		}
 
 		_, err := command.NonInteractive(cmd,

cmd/pgsuspend.go

@@ -69,14 +69,15 @@ Postgres ID instead (which works across workspaces).`,
 		confirm := command.GetConfirmFromContext(cmd.Context())
 
 		loadData := func() (*pgSuspendResult, error) {
-			pg, err := deps.PostgresService().Resolve(cmd.Context(), postgres.ResolveInput{
+			resolved, err := deps.PostgresService().Resolve(cmd.Context(), postgres.ResolveInput{
 				IDOrName:            input.IDOrName,
 				ProjectIDOrName:     input.ProjectIDOrName,
 				EnvironmentIDOrName: input.EnvironmentIDOrName,
 			})
 			if err != nil {
 				return nil, err
 			}
+			pg := resolved.Postgres
 			if !confirm {
 				return &pgSuspendResult{Postgres: pg, Suspended: false}, nil
 			}
@@ -87,7 +88,7 @@ Postgres ID instead (which works across workspaces).`,
 			if err != nil {
 				return nil, err
 			}
-			return &pgSuspendResult{Postgres: post, Suspended: true}, nil
+			return &pgSuspendResult{Postgres: post.Postgres, Suspended: true}, nil
 		}
 
 		_, err := command.NonInteractive(cmd,

pkg/postgres/resolve.go

@@ -26,12 +26,49 @@ type resolveScope struct {
 	env     *client.Environment
 }
 
-func (s *Service) resolve(ctx context.Context, input ResolveInput) (*client.PostgresDetail, error) {
+func (s *Service) resolve(ctx context.Context, input ResolveInput) (*ResolvedPostgres, error) {
 	scope, err := s.resolveScope(ctx, input)
 	if err != nil {
 		return nil, err
 	}
-	return s.resolveInScope(ctx, input.IDOrName, scope)
+	pg, err := s.resolveInScope(ctx, input.IDOrName, scope)
+	if err != nil {
+		return nil, err
+	}
+	resolved := &ResolvedPostgres{
+		Postgres:    pg,
+		Project:     scope.project,
+		Environment: scope.env,
+	}
+	if err := s.enrichResolvedPostgres(ctx, resolved); err != nil {
+		return nil, err
+	}
+	return resolved, nil
+}
+
+// enrichResolvedPostgres fills in related project/environment data when the
+// lookup itself did not already resolve that context.
+func (s *Service) enrichResolvedPostgres(ctx context.Context, resolved *ResolvedPostgres) error {
+	if resolved.Postgres == nil || resolved.Postgres.EnvironmentId == nil {
+		return nil
+	}
+
+	pg := postgresFromPostgresDetail(resolved.Postgres)
+	if resolved.Environment == nil {
+		env, err := s.environmentForPostgres(ctx, pg, nil)
+		if err != nil {
+			return err
+		}
+		resolved.Environment = env
+	}
+	if resolved.Project == nil && resolved.Environment != nil {
+		project, err := s.projectRepo.GetProject(ctx, resolved.Environment.ProjectId)
+		if err != nil {
+			return err
+		}
+		resolved.Project = project
+	}
+	return nil
 }
 
 func (s *Service) resolveScope(ctx context.Context, input ResolveInput) (resolveScope, error) {

pkg/postgres/service.go

@@ -19,6 +19,13 @@ type Service struct {
 	resolver        *resolve.Resolver
 }
 
+// ResolvedPostgres carries a Postgres detail plus its resolved scope.
+type ResolvedPostgres struct {
+	Postgres    *client.PostgresDetail
+	Project     *client.Project
+	Environment *client.Environment
+}
+
 func NewService(repo *Repo, environmentRepo *environment.Repo, projectRepo *project.Repo, resolver *resolve.Resolver) *Service {
 	return &Service{
 		repo:            repo,
@@ -100,7 +107,7 @@ func (s *Service) GetConnectionInfo(ctx context.Context, id string) (*client.Pos
 
 // 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) {
+func (s *Service) Resolve(ctx context.Context, input ResolveInput) (*ResolvedPostgres, error) {
 	return s.resolve(ctx, input)
 }
 
@@ -149,14 +156,15 @@ func (s *Service) Create(ctx context.Context, input pgtypes.CreatePostgresInput)
 // narrowed by project/environment), builds the PATCH body, and applies it via
 // the Render API. Returns both the pre- and post-update server state.
 func (s *Service) Update(ctx context.Context, input pgtypes.UpdatePostgresInput) (*UpdateResult, error) {
-	before, err := s.Resolve(ctx, ResolveInput{
+	resolvedBefore, err := s.Resolve(ctx, ResolveInput{
 		IDOrName:            input.IDOrName,
 		ProjectIDOrName:     input.ProjectIDOrName,
 		EnvironmentIDOrName: input.EnvironmentIDOrName,
 	})
 	if err != nil {
 		return nil, err
 	}
+	before := resolvedBefore.Postgres
 
 	body, err := BuildUpdateRequest(input)
 	if err != nil {

pkg/postgres/service_test.go

@@ -255,8 +255,49 @@ func TestServiceResolve_EnvironmentLookupStaysInActiveWorkspace(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	assert.NotEqual(t, otherWorkspacePG.Id, result.Id)
-	assert.Equal(t, activeWorkspacePG.Id, result.Id)
+	require.NotNil(t, result.Postgres)
+	assert.NotEqual(t, otherWorkspacePG.Id, result.Postgres.Id)
+	assert.Equal(t, activeWorkspacePG.Id, result.Postgres.Id)
+}
+
+func TestServiceResolve_EnrichesProjectAndEnvironmentForIDLookup(t *testing.T) {
+	harness := newHarness(t)
+	env := harness.addProjectAndEnvironment(harness.workspaceID, "Active Project", "production")
+	pg := harness.addPostgresInEnvironment("my-db", env.Id)
+	project := harness.requireProject(env.ProjectId)
+
+	result, err := harness.service.Resolve(context.Background(), postgres.ResolveInput{
+		IDOrName: pg.Id,
+	})
+	require.NoError(t, err)
+
+	require.NotNil(t, result.Postgres)
+	assert.Equal(t, pg.Id, result.Postgres.Id)
+	require.NotNil(t, result.Environment)
+	assert.Equal(t, env.Id, result.Environment.Id)
+	require.NotNil(t, result.Project)
+	assert.Equal(t, project.Id, result.Project.Id)
+}
+
+func TestServiceResolve_PreservesResolvedProjectAndEnvironmentForScopedNameLookup(t *testing.T) {
+	harness := newHarness(t)
+	env := harness.addProjectAndEnvironment(harness.workspaceID, "Active Project", "production")
+	pg := harness.addPostgresInEnvironment("my-db", env.Id)
+	project := harness.requireProject(env.ProjectId)
+
+	result, err := harness.service.Resolve(context.Background(), postgres.ResolveInput{
+		IDOrName:            "my-db",
+		ProjectIDOrName:     pointers.From(project.Name),
+		EnvironmentIDOrName: pointers.From(env.Name),
+	})
+	require.NoError(t, err)
+
+	require.NotNil(t, result.Postgres)
+	assert.Equal(t, pg.Id, result.Postgres.Id)
+	require.NotNil(t, result.Environment)
+	assert.Equal(t, env.Id, result.Environment.Id)
+	require.NotNil(t, result.Project)
+	assert.Equal(t, project.Id, result.Project.Id)
 }
 
 func TestServiceResolve_IDLookup_NonNotFoundError_Surfaces(t *testing.T) {