Add Postgres resolve and delete service methods (#444)

- Implements `PostgresService.Resolve` and `PostgresService.Delete`
- `render ea pg delete` command will use these to identify and delete a Postgres!
- Fixes a bug with `IsValidPostgresID`
  - Postgres IDs can have suffixes, to indicate what instance they are in a cluster of replicas or HA.

PR 2 of 3 for https://linear.app/render-com/issue/GROW-2121/pg-delete

GitOrigin-RevId: 895587bc823fa0f6b20266f686124e1b97292b0f

Author: davidharting

pkg/postgres/repo.go

@@ -2,11 +2,18 @@ package postgres
 
 import (
 	"context"
+	"errors"
+	"net/http"
 
 	"github.com/render-oss/cli/pkg/client"
 	"github.com/render-oss/cli/pkg/config"
 )
 
+// ErrPostgresNotFound is returned by Repo.GetPostgres when the API responds
+// with a 404, so callers can distinguish "this ID doesn't exist" from other
+// failure modes without parsing error messages.
+var ErrPostgresNotFound = errors.New("postgres not found")
+
 type Repo struct {
 	client *client.ClientWithResponses
 }
@@ -56,6 +63,10 @@ func (r *Repo) GetPostgres(ctx context.Context, id string) (*client.PostgresDeta
 		return nil, err
 	}
 
+	if resp.StatusCode() == http.StatusNotFound {
+		return nil, ErrPostgresNotFound
+	}
+
 	if err := client.ErrorFromResponse(resp); err != nil {
 		return nil, err
 	}
@@ -101,3 +112,12 @@ func (r *Repo) CreatePostgres(ctx context.Context, data client.CreatePostgresJSO
 
 	return resp.JSON201, nil
 }
+
+func (r *Repo) DeletePostgres(ctx context.Context, id string) error {
+	resp, err := r.client.DeletePostgresWithResponse(ctx, id)
+	if err != nil {
+		return err
+	}
+
+	return client.ErrorFromResponse(resp)
+}

pkg/postgres/resolve.go

@@ -0,0 +1,185 @@
+package postgres
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/render-oss/cli/pkg/client"
+	"github.com/render-oss/cli/pkg/config"
+	"github.com/render-oss/cli/pkg/resolve"
+	rstrings "github.com/render-oss/cli/pkg/strings"
+	"github.com/render-oss/cli/pkg/tui"
+	"github.com/render-oss/cli/pkg/validate"
+)
+
+// ResolveInput describes a Postgres lookup by ID or name within optional
+// active-workspace project/environment scope.
+type ResolveInput struct {
+	IDOrName            string
+	ProjectIDOrName     *string
+	EnvironmentIDOrName *string
+}
+
+type resolveScope struct {
+	project *client.Project
+	env     *client.Environment
+}
+
+func (s *Service) resolve(ctx context.Context, input ResolveInput) (*client.PostgresDetail, error) {
+	scope, err := s.resolveScope(ctx, input)
+	if err != nil {
+		return nil, err
+	}
+	return s.resolveInScope(ctx, input.IDOrName, scope)
+}
+
+func (s *Service) resolveScope(ctx context.Context, input ResolveInput) (resolveScope, error) {
+	if input.ProjectIDOrName == nil && input.EnvironmentIDOrName == nil {
+		return resolveScope{}, nil
+	}
+
+	resolved, err := s.resolver.ResolveScopeInActiveWorkspace(ctx, resolve.ActiveWorkspaceScopeInput{
+		ProjectIDOrName:     input.ProjectIDOrName,
+		EnvironmentIDOrName: input.EnvironmentIDOrName,
+	})
+	if err != nil {
+		return resolveScope{}, err
+	}
+	return resolveScope{project: resolved.Project, env: resolved.Environment}, nil
+}
+
+func (s *Service) resolveInScope(ctx context.Context, idOrName string, scope resolveScope) (*client.PostgresDetail, error) {
+	inputLooksLikeID := validate.IsPostgresID(idOrName)
+	if inputLooksLikeID {
+		detail, err := s.repo.GetPostgres(ctx, idOrName)
+		if err != nil && !errors.Is(err, ErrPostgresNotFound) {
+			return nil, err
+		}
+		if err == nil {
+			if err := scope.checkMatch(detail); err != nil {
+				return nil, err
+			}
+			return detail, nil
+		}
+	}
+
+	params := &client.ListPostgresParams{
+		Name: &client.NameParam{idOrName},
+	}
+	environmentIDs, isScoped := scope.environmentIDs()
+	if isScoped && len(environmentIDs) == 0 {
+		return nil, scope.notFoundError(idOrName, inputLooksLikeID)
+	}
+	if isScoped {
+		envParam := client.EnvironmentIdParam(environmentIDs)
+		params.EnvironmentId = &envParam
+	}
+
+	matches, err := s.repo.ListPostgres(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+	if len(matches) == 0 {
+		return nil, scope.notFoundError(idOrName, inputLooksLikeID)
+	}
+	if len(matches) > 1 {
+		return nil, tui.UserFacingError{Message: scope.multipleMatchesMessage(idOrName)}
+	}
+	return s.repo.GetPostgres(ctx, matches[0].Id)
+}
+
+func (s resolveScope) environmentIDs() ([]string, bool) {
+	if s.env != nil {
+		return []string{s.env.Id}, true
+	}
+	if s.project != nil {
+		return s.project.EnvironmentIds, true
+	}
+	return nil, false
+}
+
+func (s resolveScope) checkMatch(pg *client.PostgresDetail) error {
+	if s.env == nil && s.project == nil {
+		return nil
+	}
+	if s.env != nil && pg.EnvironmentId != nil && *pg.EnvironmentId == s.env.Id {
+		return nil
+	}
+	if s.env != nil {
+		return tui.UserFacingError{Message: fmt.Sprintf(
+			"Postgres database %s is not in environment %s. Re-run without --environment, or pass the correct environment.",
+			rstrings.ResourceLabel(pg.Name, pg.Id), postgresEnvironmentLabel(s.env),
+		)}
+	}
+	if pg.EnvironmentId != nil {
+		for _, envID := range s.project.EnvironmentIds {
+			if *pg.EnvironmentId == envID {
+				return nil
+			}
+		}
+	}
+	return tui.UserFacingError{Message: fmt.Sprintf(
+		"Postgres database %s is not in project %s. Re-run without --project, or pass the correct project.",
+		rstrings.ResourceLabel(pg.Name, pg.Id), postgresProjectLabel(s.project),
+	)}
+}
+
+func (s resolveScope) notFoundError(idOrName string, inputLooksLikeID bool) error {
+	if inputLooksLikeID {
+		return tui.UserFacingError{Message: fmt.Sprintf("No Postgres database with ID '%s'.", idOrName)}
+	}
+	if s.env != nil {
+		return tui.UserFacingError{Message: fmt.Sprintf(
+			"No Postgres database named '%s' in environment %s.",
+			idOrName, postgresEnvironmentLabel(s.env),
+		)}
+	}
+	if s.project != nil {
+		return tui.UserFacingError{Message: fmt.Sprintf(
+			"No Postgres database named '%s' in project %s.",
+			idOrName, postgresProjectLabel(s.project),
+		)}
+	}
+	workspace := activeWorkspaceLabel()
+	if workspace == "" {
+		return tui.UserFacingError{Message: fmt.Sprintf("No Postgres database named '%s'.", idOrName)}
+	}
+	return tui.UserFacingError{Message: fmt.Sprintf(
+		"No Postgres database named '%s' in workspace %s. To search another workspace, run `render workspace set <name|ID>`, or pass the Postgres database ID instead.",
+		idOrName, workspace,
+	)}
+}
+
+func (s resolveScope) multipleMatchesMessage(idOrName string) string {
+	if s.env != nil {
+		return fmt.Sprintf("Multiple Postgres databases found with name '%s' in environment %s. Please specify the Postgres database ID instead.", idOrName, postgresEnvironmentLabel(s.env))
+	}
+	if s.project != nil {
+		return fmt.Sprintf(
+			"Multiple Postgres databases found with name '%s' in project %s. Pass the Postgres database ID, or use --environment <id|name> to disambiguate.",
+			idOrName, postgresProjectLabel(s.project),
+		)
+	}
+	return fmt.Sprintf("Multiple Postgres databases found with name '%s'. Pass the Postgres database ID, or use --environment <id|name> to disambiguate.", idOrName)
+}
+
+func postgresEnvironmentLabel(env *client.Environment) string {
+	if env == nil {
+		return ""
+	}
+	return rstrings.ResourceLabel(env.Name, env.Id)
+}
+
+func postgresProjectLabel(project *client.Project) string {
+	if project == nil {
+		return ""
+	}
+	return rstrings.ResourceLabel(project.Name, project.Id)
+}
+
+func activeWorkspaceLabel() string {
+	id, _ := config.WorkspaceID()
+	name, _ := config.WorkspaceName()
+	return rstrings.ResourceLabel(name, id)
+}

pkg/postgres/service.go

@@ -71,6 +71,16 @@ func (s *Service) RestartPostgresDatabase(ctx context.Context, id string) error
 	return s.repo.RestartPostgresDatabase(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) {
+	return s.resolve(ctx, input)
+}
+
+func (s *Service) Delete(ctx context.Context, id string) error {
+	return s.repo.DeletePostgres(ctx, id)
+}
+
 // Create applies defaults, resolves workspace/project/environment scope,
 // and calls the Postgres create endpoint. The non-interactive flag path
 // and (eventually) the interactive wizard both go through here.