postgres suspend and resume commands (#455)

Adds two new commands:

- `render ea postgres suspend`
- `render ea postgres resume`

Closes https://linear.app/render-com/issue/GROW-2558/pg-suspend  and https://linear.app/render-com/issue/GROW-2559/pg-resume
Stacked on https://github.com/renderinc/cli/pull/453.

GitOrigin-RevId: 3de76799b4ed7afe7e45dc278d780d035dc3805d

Author: davidharting

cmd/pgresume.go

@@ -0,0 +1,86 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/render-oss/cli/pkg/client"
+	"github.com/render-oss/cli/pkg/command"
+	"github.com/render-oss/cli/pkg/dependencies"
+	"github.com/render-oss/cli/pkg/postgres"
+	"github.com/render-oss/cli/pkg/text"
+	pgtypes "github.com/render-oss/cli/pkg/types/postgres"
+)
+
+func newPgResumeCmd(deps *dependencies.Dependencies) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:          "resume <postgresID|postgresName>",
+		Short:        "Resume a suspended Postgres database",
+		Args:         cobra.ExactArgs(1),
+		SilenceUsage: true,
+		Long: `Resume a suspended Postgres database on Render.
+
+The positional argument accepts either a Postgres ID (dpg-...) or a name.
+If the name matches more than one database, narrow the search with
+--project <id|name>, --environment <id|name>, or pass the Postgres ID directly.
+
+Name lookup is scoped to your active workspace. If a name isn't found, switch
+workspaces with 'render workspace set <name|ID>' and try again, or pass the
+Postgres ID instead (which works across workspaces).`,
+		Example: `  # Resume by ID
+  render ea pg resume dpg-abc123def456ghi789jkl0
+
+  # Resume by name
+  render ea pg resume my-db
+
+  # Disambiguate a name that exists in multiple environments
+  render ea pg resume my-db --environment production
+
+  # Disambiguate a name that exists in multiple projects
+  render ea pg resume my-db --project analytics
+
+  # JSON output
+  render ea pg resume dpg-abc123def456ghi789jkl0 --output json`,
+	}
+
+	cmd.Flags().String("project", "",
+		"Project ID or name (optional). Narrows name lookup when the same Postgres database name exists in multiple projects.")
+	cmd.Flags().String("environment", "",
+		"Environment ID or name (optional). Narrows name lookup when the same Postgres database name exists in multiple environments.")
+
+	cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		command.DefaultFormatNonInteractive(cmd)
+
+		var input pgtypes.ResumePostgresInput
+		if err := command.ParseCommand(cmd, args, &input); err != nil {
+			return err
+		}
+		input = pgtypes.NormalizeResumeInput(input)
+
+		loadData := func() (*client.PostgresDetail, error) {
+			pg, err := deps.PostgresService().Resolve(cmd.Context(), postgres.ResolveInput{
+				IDOrName:            input.IDOrName,
+				ProjectIDOrName:     input.ProjectIDOrName,
+				EnvironmentIDOrName: input.EnvironmentIDOrName,
+			})
+			if err != nil {
+				return nil, err
+			}
+			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})
+		}
+
+		_, err := command.NonInteractive(cmd,
+			loadData,
+			pgResumeTextOutput,
+		)
+		return err
+	}
+
+	return cmd
+}
+
+func pgResumeTextOutput(pg *client.PostgresDetail) string {
+	return "Resumed this Postgres database:\n\n" + text.PostgresDetail(pg) + "\n"
+}

cmd/pgresume_test.go

@@ -0,0 +1,159 @@
+package cmd
+
+import (
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	renderapi "github.com/render-oss/cli/internal/fakes/renderapi"
+	"github.com/render-oss/cli/internal/testids"
+	"github.com/render-oss/cli/pkg/client"
+)
+
+type pgResumeHarness struct {
+	t      *testing.T
+	server *renderapi.Server
+}
+
+// newPGResumeHarness sets up a server fake and seeds it with an (active) workspace.
+func newPGResumeHarness(t *testing.T) pgResumeHarness {
+	t.Helper()
+
+	server := renderapi.NewServer(t)
+	server.Owners.Add(renderapi.NewOwner(client.Owner{Id: pgActiveWorkspaceID, Name: "Test Workspace"}))
+	t.Setenv("RENDER_WORKSPACE", pgActiveWorkspaceID)
+
+	return pgResumeHarness{t: t, server: server}
+}
+
+// execute invokes `render ea pg resume`, passing through all extraArgs.
+func (h pgResumeHarness) execute(extraArgs ...string) (CommandResult, error) {
+	h.t.Helper()
+
+	return executePGCommand(h.t, h.server, append([]string{"ea", "pg", "resume"}, extraArgs...)...)
+}
+
+// seedSuspendedPG seeds a Postgres pre-set to Suspended so resume tests can assert
+// the status flips back to Available.
+func seedSuspendedPG(server *renderapi.Server, name string) *client.PostgresDetail {
+	pg := seedPG(server, name)
+	pg.Status = client.DatabaseStatusSuspended
+	return pg
+}
+
+func TestPGResume_ByID_Resumes(t *testing.T) {
+	harness := newPGResumeHarness(t)
+	pg := seedSuspendedPG(harness.server, "my-db")
+
+	result, err := harness.execute(pg.Id, "--output", "text")
+	require.NoError(t, err)
+
+	assert.Equal(t, client.DatabaseStatusAvailable, harness.server.Postgres.Instances[0].Status)
+	assert.Contains(t, result.Stdout, "Resumed")
+	assert.Contains(t, result.Stdout, pg.Id)
+}
+
+func TestPGResume_ByName_Resumes(t *testing.T) {
+	harness := newPGResumeHarness(t)
+	pg := seedSuspendedPG(harness.server, "by-name-db")
+
+	result, err := harness.execute("by-name-db", "--output", "text")
+	require.NoError(t, err)
+
+	assert.Equal(t, client.DatabaseStatusAvailable, harness.server.Postgres.Instances[0].Status)
+	assert.Contains(t, result.Stdout, "Resumed")
+	assert.Contains(t, result.Stdout, pg.Id)
+}
+
+func TestPGResume_NameCollision_Errors(t *testing.T) {
+	harness := newPGResumeHarness(t)
+	seedSuspendedPG(harness.server, "not-unique")
+	seedSuspendedPG(harness.server, "not-unique")
+
+	_, err := harness.execute("not-unique", "--output", "text")
+	require.Error(t, err)
+
+	assert.Contains(t, err.Error(), "Multiple Postgres databases")
+	for _, pg := range harness.server.Postgres.Instances {
+		assert.Equal(t, client.DatabaseStatusSuspended, pg.Status, "no resume on ambiguity")
+	}
+	assert.False(t, harness.server.HasRequest("POST", "/postgres/"))
+}
+
+func TestPGResume_UnknownID_Errors(t *testing.T) {
+	harness := newPGResumeHarness(t)
+	missing := testids.PostgresID("missing")
+
+	_, err := harness.execute(missing, "--output", "text")
+	require.Error(t, err)
+	assert.ErrorContains(t, err, missing)
+}
+
+func TestPGResume_JSONOutput(t *testing.T) {
+	harness := newPGResumeHarness(t)
+	pg := seedSuspendedPG(harness.server, "json-db")
+
+	result, err := harness.execute(pg.Id, "--output", "json")
+	require.NoError(t, err)
+	assert.Equal(t, client.DatabaseStatusAvailable, harness.server.Postgres.Instances[0].Status)
+
+	var body struct {
+		ID     string `json:"id"`
+		Name   string `json:"name"`
+		Status string `json:"status"`
+	}
+	require.NoError(t, json.Unmarshal([]byte(result.Stdout), &body))
+	assert.Equal(t, pg.Id, body.ID)
+	assert.Equal(t, "json-db", body.Name)
+	assert.Equal(t, string(client.DatabaseStatusAvailable), body.Status)
+}
+
+func TestPGResume_NameCollision_NarrowedByEnvironment_Resumes(t *testing.T) {
+	harness := newPGResumeHarness(t)
+	proj := harness.server.CreateProject(
+		renderapi.ProjectAttrs{Name: "My Project", OwnerId: pgActiveWorkspaceID},
+		renderapi.EnvAttrs{Name: "production"},
+		renderapi.EnvAttrs{Name: "staging"},
+	)
+
+	prodPG := seedPGInEnv(harness.server, "not-unique", proj.Env("production").Id)
+	prodPG.Status = client.DatabaseStatusSuspended
+	stagingPG := seedPGInEnv(harness.server, "not-unique", proj.Env("staging").Id)
+	stagingPG.Status = client.DatabaseStatusSuspended
+
+	result, err := harness.execute("not-unique", "--environment", "production", "--output", "text")
+	require.NoError(t, err)
+
+	assert.Contains(t, result.Stdout, "Resumed")
+	assert.Contains(t, result.Stdout, prodPG.Id)
+	assert.Equal(t, client.DatabaseStatusAvailable, prodPG.Status)
+	assert.Equal(t, client.DatabaseStatusSuspended, stagingPG.Status, "staging database must not be resumed")
+}
+
+func TestPGResume_APIError_Surfaced(t *testing.T) {
+	// First nextError is consumed by Resolve's GET; surface the error from there
+	// to confirm the failure path propagates and no resume POST fires.
+	harness := newPGResumeHarness(t)
+	pg := seedSuspendedPG(harness.server, "my-db")
+	harness.server.Postgres.RespondWith(http.StatusInternalServerError)
+
+	_, err := harness.execute(pg.Id, "--output", "text")
+	require.Error(t, err)
+	assert.Equal(t, client.DatabaseStatusSuspended, harness.server.Postgres.Instances[0].Status, "API error must not flip status")
+	assert.False(t, harness.server.HasRequest("POST", "/postgres/"+pg.Id+"/resume"))
+}
+
+func TestPGResume_DefaultOutput_TreatedAsText(t *testing.T) {
+	harness := newPGResumeHarness(t)
+	pg := seedSuspendedPG(harness.server, "default-out")
+
+	result, err := harness.execute(pg.Id)
+	require.NoError(t, err)
+
+	assert.Equal(t, client.DatabaseStatusAvailable, harness.server.Postgres.Instances[0].Status)
+	assert.Contains(t, result.Stdout, "Resumed")
+	assert.Contains(t, result.Stdout, pg.Id)
+}

cmd/pgsuspend.go

@@ -0,0 +1,110 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/render-oss/cli/pkg/client"
+	"github.com/render-oss/cli/pkg/command"
+	"github.com/render-oss/cli/pkg/dependencies"
+	"github.com/render-oss/cli/pkg/postgres"
+	"github.com/render-oss/cli/pkg/text"
+	pgtypes "github.com/render-oss/cli/pkg/types/postgres"
+)
+
+type pgSuspendResult struct {
+	Postgres  *client.PostgresDetail `json:"postgres"`
+	Suspended bool                   `json:"suspended"`
+}
+
+func newPgSuspendCmd(deps *dependencies.Dependencies) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:          "suspend <postgresID|postgresName>",
+		Short:        "Suspend a Postgres database",
+		Args:         cobra.ExactArgs(1),
+		SilenceUsage: true,
+		Long: `Suspend a Postgres database on Render.
+
+Without --confirm, this command previews what would be suspended and makes no
+changes. Pass --confirm to actually suspend the database.
+
+The positional argument accepts either a Postgres ID (dpg-...) or a name.
+If the name matches more than one database, narrow the search with
+--project <id|name>, --environment <id|name>, or pass the Postgres ID directly.
+
+Name lookup is scoped to your active workspace. If a name isn't found, switch
+workspaces with 'render workspace set <name|ID>' and try again, or pass the
+Postgres ID instead (which works across workspaces).`,
+		Example: `  # Preview suspension (no changes made)
+  render ea pg suspend dpg-abc123def456ghi789jkl0
+
+  # Suspend by ID
+  render ea pg suspend dpg-abc123def456ghi789jkl0 --confirm
+
+  # Suspend by name
+  render ea pg suspend my-db --confirm
+
+  # Disambiguate a name that exists in multiple environments
+  render ea pg suspend my-db --environment production --confirm
+
+  # Disambiguate a name that exists in multiple projects
+  render ea pg suspend my-db --project analytics --confirm
+
+  # JSON output
+  render ea pg suspend dpg-abc123def456ghi789jkl0 --confirm --output json`,
+	}
+
+	cmd.Flags().String("project", "",
+		"Project ID or name (optional). Narrows name lookup when the same Postgres database name exists in multiple projects.")
+	cmd.Flags().String("environment", "",
+		"Environment ID or name (optional). Narrows name lookup when the same Postgres database name exists in multiple environments.")
+
+	cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		command.DefaultFormatNonInteractive(cmd)
+
+		var input pgtypes.SuspendPostgresInput
+		if err := command.ParseCommand(cmd, args, &input); err != nil {
+			return err
+		}
+		input = pgtypes.NormalizeSuspendInput(input)
+		confirm := command.GetConfirmFromContext(cmd.Context())
+
+		loadData := func() (*pgSuspendResult, error) {
+			pg, err := deps.PostgresService().Resolve(cmd.Context(), postgres.ResolveInput{
+				IDOrName:            input.IDOrName,
+				ProjectIDOrName:     input.ProjectIDOrName,
+				EnvironmentIDOrName: input.EnvironmentIDOrName,
+			})
+			if err != nil {
+				return nil, err
+			}
+			if !confirm {
+				return &pgSuspendResult{Postgres: pg, Suspended: false}, nil
+			}
+			if err := deps.PostgresService().SuspendPostgres(cmd.Context(), pg.Id); err != nil {
+				return nil, err
+			}
+			post, err := deps.PostgresService().Resolve(cmd.Context(), postgres.ResolveInput{IDOrName: pg.Id})
+			if err != nil {
+				return nil, err
+			}
+			return &pgSuspendResult{Postgres: post, Suspended: true}, nil
+		}
+
+		_, err := command.NonInteractive(cmd,
+			loadData,
+			pgSuspendTextOutput,
+		)
+		return err
+	}
+
+	return cmd
+}
+
+func pgSuspendTextOutput(r *pgSuspendResult) string {
+	if r.Suspended {
+		return "Suspended this Postgres database:\n\n" + text.PostgresDetail(r.Postgres) + "\n"
+	}
+	return "This command would suspend this Postgres database:\n\n" +
+		text.PostgresDetail(r.Postgres) +
+		"\n\nRe-run with --confirm to proceed\n"
+}