Add pg update command (#459)

Implements `render ea pg update` to update a postgres instance.

Decisions:
- No support for modifying read replicas today
- No support for clearing out all postgres parameters today

I think both of these things need to be handled carefully, perhaps with dedicated subcommands. So would like to see some demand for it before doing so.

https://linear.app/render-com/issue/GROW-2120/pg-update

GitOrigin-RevId: e750844e4d3326fe0b8f9f62ce7cd5659b8b5f47

Author: davidharting

cmd/pgupdate.go

@@ -0,0 +1,136 @@
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	"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"
+	"github.com/render-oss/cli/pkg/types"
+	pgtypes "github.com/render-oss/cli/pkg/types/postgres"
+)
+
+func newPgUpdateCmd(deps *dependencies.Dependencies) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:          "update <postgresID|postgresName>",
+		Short:        "Update a Postgres database",
+		Args:         cobra.ExactArgs(1),
+		SilenceUsage: true,
+		Long: `Update an existing Postgres database on Render.
+
+The positional argument is the target database (ID dpg-... or name). At least
+one mutating flag must be supplied. Use --name to rename the database; the
+positional argument always identifies the target and is never the new name.
+
+Only the fields you pass are changed; everything else is left untouched.
+
+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). If a name matches more
+than one database, narrow the search with --project <id|name> or
+--environment <id|name>.
+
+The --ip-allow-list flag replaces the server-side list; pass it once per entry.
+To remove all allow-list entries, pass --clear-ip-allow-list. The two flags are
+mutually exclusive.`,
+		Example: `  # Rename
+  render ea pg update dpg-abc123def456ghi789jkl0 --name application_db
+
+  # Change plan
+  render ea pg update my-db --plan pro_4gb
+
+  # Grow the disk and enable autoscaling
+  render ea pg update my-db --disk-size-gb 50 --disk-autoscaling
+
+  # Replace the IP allow-list (entire list, not append)
+  render ea pg update my-db \
+    --ip-allow-list "cidr=203.0.113.5/32,description=office" \
+    --ip-allow-list "cidr=10.0.0.0/8,description=internal"
+
+  # Clear the IP allow-list
+  render ea pg update my-db --clear-ip-allow-list
+
+  # Disambiguate a name that exists in multiple environments
+  render ea pg update my-db --environment production --plan pro_8gb
+
+  # JSON output
+  render ea pg update dpg-abc123def456ghi789jkl0 --plan pro_4gb --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.Flags().String("name", "", "Rename the database")
+	cmd.Flags().String("plan", "", "Plan name. Examples: "+strings.Join(postgres.ModernPlans, " | "))
+
+	cmd.Flags().Int("disk-size-gb", 0, "Disk size in GB. Must be 1 or a multiple of 5.")
+	cmd.Flags().Bool("disk-autoscaling", false, "Enable disk autoscaling. Pass --disk-autoscaling=false to disable.")
+	cmd.Flags().Bool("high-availability", false, "Enable high availability (Pro plans and above). Pass --high-availability=false to disable.")
+
+	cmd.Flags().String("datadog-api-key", "", "Datadog API key for monitoring. Pass an empty string to remove.")
+	cmd.Flags().String("datadog-site", "", "Datadog region/site (e.g. US1, US3, EU)")
+
+	cmd.Flags().StringArray("parameter-override", nil,
+		"Override a Postgres server parameter. Repeat the flag for multiple entries.\n"+
+			"Format: KEY=VALUE\n"+
+			"Example: --parameter-override max_connections=100\n\n"+
+			"Entries not mentioned in the flag are preserved (upsert semantics — keys\n"+
+			"you supply are added or updated; all other existing overrides are kept).\n"+
+			"To remove an individual override, use the Render dashboard.")
+	cmd.Flags().StringArray("ip-allow-list", nil,
+		"Replace the IP allow-list with the supplied entries. Repeat the flag for multiple entries.\n"+
+			"Format: cidr=<range>,description=<label>")
+	cmd.Flags().Bool("clear-ip-allow-list", false,
+		"Remove all IP allow-list entries. Mutually exclusive with --ip-allow-list")
+
+	cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		// No interactive flow yet; collapse --output interactive onto text so
+		// the standard NonInteractive path handles every format.
+		command.DefaultFormatNonInteractive(cmd)
+
+		var input pgtypes.UpdatePostgresInput
+		if err := command.ParseCommand(cmd, args, &input); err != nil {
+			return err
+		}
+		input.ProjectIDOrName = types.OptionalNonZeroString(input.ProjectIDOrName)
+		input.EnvironmentIDOrName = types.OptionalNonZeroString(input.EnvironmentIDOrName)
+
+		// Captured by both closures so the text formatter can render a diff
+		// while JSON/YAML output stays simple — just the new state, matching
+		// pg create's output shape.
+		var before *client.PostgresDetail
+
+		_, err := command.NonInteractive(cmd,
+			func() (*client.PostgresDetail, error) {
+				result, err := deps.PostgresService().Update(cmd.Context(), input)
+				if err != nil {
+					return nil, err
+				}
+				before = result.Before
+				return result.After, nil
+			},
+			func(after *client.PostgresDetail) string {
+				return pgUpdateSuccessMessage(before, after)
+			},
+		)
+		return err
+	}
+
+	return cmd
+}
+
+func pgUpdateSuccessMessage(before, after *client.PostgresDetail) string {
+	details := "Full details:\n  " + strings.ReplaceAll(text.PostgresDetail(after), "\n", "\n  ")
+	diff := text.PostgresUpdateDiff(before, after)
+	if diff == "" {
+		return fmt.Sprintf("No changes applied to Postgres database\n\n%s\n", details)
+	}
+	return fmt.Sprintf("Updated Postgres database\n\nChanges:\n%s\n\n%s\n", diff, details)
+}

cmd/pgupdate_test.go

@@ -0,0 +1,244 @@
+package cmd
+
+import (
+	"encoding/json"
+	"strings"
+	"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/testassert"
+	"github.com/render-oss/cli/internal/testids"
+	"github.com/render-oss/cli/pkg/client"
+	pgclient "github.com/render-oss/cli/pkg/client/postgres"
+	"github.com/render-oss/cli/pkg/pointers"
+)
+
+type pgUpdateHarness struct {
+	t      *testing.T
+	server *renderapi.Server
+}
+
+// newPGUpdateHarness sets up a server fake and seeds it with an (active) workspace.
+func newPGUpdateHarness(t *testing.T) pgUpdateHarness {
+	t.Helper()
+
+	server := renderapi.NewServer(t)
+	server.Owners.Add(renderapi.NewOwner(client.Owner{Id: pgActiveWorkspaceID, Name: "Test Workspace"}))
+	t.Setenv("RENDER_WORKSPACE", pgActiveWorkspaceID)
+
+	return pgUpdateHarness{t: t, server: server}
+}
+
+// execute invokes the `render ea pg update` command, passing through all extraArgs.
+func (h pgUpdateHarness) execute(extraArgs ...string) (CommandResult, error) {
+	h.t.Helper()
+	return executePGCommand(h.t, h.server, append([]string{"ea", "pg", "update"}, extraArgs...)...)
+}
+
+func TestPGUpdate_ByID_RendersDiff(t *testing.T) {
+	harness := newPGUpdateHarness(t)
+	pg := seedPG(harness.server, "my-db")
+
+	result, err := harness.execute(pg.Id, "--name", "renamed-db", "--output", "text")
+	require.NoError(t, err)
+
+	assert.Contains(t, result.Stdout, "Updated Postgres database")
+	testassert.ContainsInOrder(t, result.Stdout, "Changes:", "Name:", "my-db → renamed-db")
+	assert.Equal(t, "renamed-db", pg.Name, "stored database should be renamed in place")
+}
+
+func TestPGUpdate_ByName(t *testing.T) {
+	harness := newPGUpdateHarness(t)
+	pg := seedPG(harness.server, "by-name-db")
+	// pg is a live pointer to the server's stored state, so it starts on the
+	// seed default and reflects the update in place once the command runs.
+	require.Equal(t, pgclient.Free, pg.Plan, "precondition: seeded database starts on the free plan")
+
+	result, err := harness.execute("by-name-db", "--plan", "pro_4gb", "--output", "text")
+	require.NoError(t, err)
+
+	assert.Contains(t, result.Stdout, "Updated Postgres database")
+	assert.Equal(t, pgclient.PostgresPlans("pro_4gb"), pg.Plan)
+}
+
+func TestPGUpdate_PartialUpdate_LeavesOtherFieldsUntouched(t *testing.T) {
+	harness := newPGUpdateHarness(t)
+	pg := harness.server.Postgres.Add(renderapi.NewPostgres(client.PostgresDetail{
+		Name:       "app-db",
+		Owner:      client.Owner{Id: pgActiveWorkspaceID},
+		Plan:       pgclient.PostgresPlans("pro_4gb"),
+		DiskSizeGB: pointers.From(20),
+	}))
+
+	result, err := harness.execute(pg.Id, "--name", "app-db-renamed", "--output", "text")
+	require.NoError(t, err)
+
+	// Only the name changed; plan and disk are untouched server-side.
+	assert.Equal(t, "app-db-renamed", pg.Name)
+	assert.Equal(t, pgclient.PostgresPlans("pro_4gb"), pg.Plan)
+	require.NotNil(t, pg.DiskSizeGB)
+	assert.Equal(t, 20, *pg.DiskSizeGB)
+
+	// The Changes section reflects only the field that changed (the full-state
+	// block below it still lists every field, so scope the check to the diff).
+	changes, _, _ := strings.Cut(result.Stdout, "Full details:")
+	assert.Contains(t, changes, "Name:")
+	assert.NotContains(t, changes, "Plan:")
+	assert.NotContains(t, changes, "Disk size:")
+}
+
+func TestPGUpdate_NoEffectiveChange_SaysNoChanges(t *testing.T) {
+	harness := newPGUpdateHarness(t)
+	pg := seedPG(harness.server, "same-name")
+
+	// Renaming to the current name is a valid request but changes nothing.
+	result, err := harness.execute(pg.Id, "--name", "same-name", "--output", "text")
+	require.NoError(t, err)
+
+	assert.Contains(t, result.Stdout, "No changes applied to Postgres database")
+}
+
+func TestPGUpdate_IPAllowListReplace(t *testing.T) {
+	harness := newPGUpdateHarness(t)
+	pg := harness.server.Postgres.Add(renderapi.NewPostgres(client.PostgresDetail{
+		Name:  "ip-db",
+		Owner: client.Owner{Id: pgActiveWorkspaceID},
+		IpAllowList: []client.CidrBlockAndDescription{
+			{CidrBlock: "192.0.2.0/24", Description: "old"},
+		},
+	}))
+
+	_, err := harness.execute(pg.Id,
+		"--ip-allow-list", "cidr=10.0.0.0/8,description=internal",
+		"--output", "text")
+	require.NoError(t, err)
+
+	require.Len(t, pg.IpAllowList, 1)
+	assert.Equal(t, "10.0.0.0/8", pg.IpAllowList[0].CidrBlock)
+	assert.Equal(t, "internal", pg.IpAllowList[0].Description)
+}
+
+func TestPGUpdate_ClearIPAllowList(t *testing.T) {
+	harness := newPGUpdateHarness(t)
+	pg := harness.server.Postgres.Add(renderapi.NewPostgres(client.PostgresDetail{
+		Name:  "ip-db",
+		Owner: client.Owner{Id: pgActiveWorkspaceID},
+		IpAllowList: []client.CidrBlockAndDescription{
+			{CidrBlock: "10.0.0.0/8", Description: "internal"},
+		},
+	}))
+
+	_, err := harness.execute(pg.Id, "--clear-ip-allow-list", "--output", "text")
+	require.NoError(t, err)
+
+	assert.Empty(t, pg.IpAllowList, "clear should remove all allow-list entries")
+}
+
+func TestPGUpdate_EnvironmentDisambiguation(t *testing.T) {
+	harness := newPGUpdateHarness(t)
+	project := harness.server.CreateProject(
+		renderapi.ProjectAttrs{Name: "My Project", OwnerId: pgActiveWorkspaceID},
+		renderapi.EnvAttrs{Name: "production"},
+		renderapi.EnvAttrs{Name: "staging"},
+	)
+	prodPG := seedPGInEnv(harness.server, "not-very-unique", project.Env("production").Id)
+	stagingPG := seedPGInEnv(harness.server, "not-very-unique", project.Env("staging").Id)
+
+	_, err := harness.execute("not-very-unique", "--environment", "production", "--name", "so-special", "--output", "text")
+	require.NoError(t, err)
+
+	assert.Equal(t, "so-special", prodPG.Name, "the production database should be the one updated")
+	assert.Equal(t, "not-very-unique", stagingPG.Name, "the staging database must be untouched")
+}
+
+func TestPGUpdate_NameCollision_Errors(t *testing.T) {
+	harness := newPGUpdateHarness(t)
+	seedPG(harness.server, "not-unique")
+	seedPG(harness.server, "not-unique")
+
+	_, err := harness.execute("not-unique", "--name", "renamed", "--output", "text")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "Multiple Postgres databases")
+}
+
+func TestPGUpdate_JSONOutput_ReturnsNewState(t *testing.T) {
+	harness := newPGUpdateHarness(t)
+	pg := seedPG(harness.server, "json-db")
+
+	result, err := harness.execute(pg.Id, "--name", "json-renamed", "--output", "json")
+	require.NoError(t, err)
+
+	var body struct {
+		ID   string `json:"id"`
+		Name string `json:"name"`
+	}
+	require.NoError(t, json.Unmarshal([]byte(result.Stdout), &body))
+	assert.Equal(t, pg.Id, body.ID)
+	assert.Equal(t, "json-renamed", body.Name)
+	// JSON returns just the new state, not a before/after wrapper.
+	assert.NotContains(t, result.Stdout, "Changes:")
+}
+
+func TestPGUpdate_UnknownID_Errors(t *testing.T) {
+	harness := newPGUpdateHarness(t)
+	missing := testids.PostgresID("missing")
+
+	_, err := harness.execute(missing, "--name", "whatever", "--output", "text")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), missing)
+}
+
+func TestPGUpdate_NoMutationFields_Errors(t *testing.T) {
+	harness := newPGUpdateHarness(t)
+	pg := seedPG(harness.server, "my-db")
+
+	_, err := harness.execute(pg.Id, "--output", "text")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "at least one field")
+}
+
+func TestPGUpdate_ParameterOverrideUpsert(t *testing.T) {
+	harness := newPGUpdateHarness(t)
+	existing := client.PostgresParameterOverrides{"work_mem": "64MB", "max_connections": "100"}
+	pg := harness.server.Postgres.Add(renderapi.NewPostgres(client.PostgresDetail{
+		Name:               "param-db",
+		Owner:              client.Owner{Id: pgActiveWorkspaceID},
+		ParameterOverrides: &existing,
+	}))
+
+	_, err := harness.execute(pg.Id,
+		"--parameter-override", "max_connections=200",
+		"--parameter-override", "lock_timeout=5000",
+		"--output", "text")
+	require.NoError(t, err)
+
+	require.NotNil(t, pg.ParameterOverrides)
+	overrides := *pg.ParameterOverrides
+	assert.Equal(t, "200", overrides["max_connections"], "supplied key should be updated")
+	assert.Equal(t, "5000", overrides["lock_timeout"], "new key should be added")
+	assert.Equal(t, "64MB", overrides["work_mem"], "unsupplied key should be preserved")
+}
+
+func TestPGUpdate_BadParameterOverride_Errors(t *testing.T) {
+	harness := newPGUpdateHarness(t)
+	pg := seedPG(harness.server, "my-db")
+
+	_, err := harness.execute(pg.Id, "--parameter-override", "noequals", "--output", "text")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "expected KEY=VALUE format")
+}
+
+func TestPGUpdate_BothIPAllowListAndClearFlags_Errors(t *testing.T) {
+	harness := newPGUpdateHarness(t)
+	pg := seedPG(harness.server, "my-db")
+
+	_, err := harness.execute(pg.Id,
+		"--ip-allow-list", "cidr=10.0.0.0/8,description=internal",
+		"--clear-ip-allow-list",
+		"--output", "text")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "mutually exclusive")
+}

cmd/root.go

@@ -155,7 +155,7 @@ func setupWorkspaceCommands(deps *dependencies.Dependencies) {
 }
 
 func setupPGCommands(earlyAccess *cobra.Command, deps *dependencies.Dependencies) {
-	earlyAccess.AddCommand(newPgCmd(newPgCreateCmd(deps), newPgDeleteCmd(deps), newPgGetCmd(deps), newPgListCmd(deps)))
+	earlyAccess.AddCommand(newPgCmd(newPgCreateCmd(deps), newPgDeleteCmd(deps), newPgGetCmd(deps), newPgListCmd(deps), newPgUpdateCmd(deps)))
 }
 
 func SetupCommands() error {