Remove parameter overrides from postgres commands (#501)

Removes all references to parameter overrides from Postgres commands

This is essentially a boundary-level concern:
- Remove the CLI flag for `--parameter-override`
- Nil out `ParameterOverrides` map on the output structs, so that when we serialize to JSON omit it entirely
- For text-based output, stop outputting the parameter overrides

Letting users override parameters in Render Postgres is built out but very early access and only available to a few customers. Bel asked me to hide the concept from the CLI.

GROW-2618

GitOrigin-RevId: 9210e5c463c9054075b9ab186b771bb57f95b512

Author: davidharting

cmd/pgcreate.go

@@ -25,9 +25,8 @@ func newPgCreateCmd(deps *dependencies.Dependencies) *cobra.Command {
 
 In interactive mode, a wizard guides you through the core choices for the
 database. The wizard owns those prompted values. Flag-only settings, such as
---disk-size-gb, --database-name, --database-user, --ip-allow-list,
---parameter-override, and --read-replica, are still included in the create
-request.
+--disk-size-gb, --database-name, --database-user, --ip-allow-list, and --read-replica,
+are still included in the create request.
 
 Use --confirm to skip the wizard and create immediately from flags and defaults.
 When --confirm is used with the default interactive output mode, output is
@@ -76,10 +75,6 @@ Examples:
 	cmd.Flags().StringArray("ip-allow-list", nil,
 		"Restrict inbound traffic to specific IP ranges. Repeat the flag for multiple entries.\n"+
 			"Format: cidr=<range>,description=<label>")
-	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")
 	cmd.Flags().StringArray("read-replica", nil,
 		"Name of a read replica to create alongside the primary. Repeat the flag for multiple replicas.")
 

cmd/pgcreate_test.go

@@ -51,7 +51,6 @@ func TestPGCreate_AllFlags(t *testing.T) {
 		"--datadog-api-key", "dd-key",
 		"--datadog-site", "US3",
 		"--ip-allow-list", "cidr=10.0.0.0/8,description=internal",
-		"--parameter-override", "max_connections=111",
 		"--read-replica", "analytics-replica-1",
 		"--output", "text",
 	)
@@ -74,8 +73,7 @@ func TestPGCreate_AllFlags(t *testing.T) {
 	assert.Equal(t, "internal", pg.IpAllowList[0].Description)
 	require.Len(t, pg.ReadReplicas, 1)
 	assert.Equal(t, "analytics-replica-1", pg.ReadReplicas[0].Name)
-	require.NotNil(t, pg.ParameterOverrides)
-	assert.Equal(t, "111", (*pg.ParameterOverrides)["max_connections"])
+	assert.Nil(t, pg.ParameterOverrides)
 	assert.Contains(t, result.Stdout, "analytics")
 	assert.Contains(t, result.Stdout, "Read replicas:")
 }
@@ -144,15 +142,15 @@ func TestPGCreate_PostgresAlias(t *testing.T) {
 	assert.Equal(t, "alias-pg", server.Postgres.Instances[0].Name)
 }
 
-func TestPGCreate_InvalidParameterOverride(t *testing.T) {
+func TestPGCreate_ParameterOverrideFlagIsUnknown(t *testing.T) {
 	server := renderapi.NewServer(t)
 	result, err := executePGCreate(t, server,
-		"--parameter-override", "noequals",
+		"--parameter-override", "max_connections=111",
 		"--output", "text",
 	)
 	require.Error(t, err)
 
-	assert.Contains(t, result.Stderr, "expected KEY=VALUE format")
+	assert.Contains(t, result.Stderr, "unknown flag: --parameter-override")
 	assert.Empty(t, server.Postgres.Instances)
 }
 

cmd/pgupdate.go

@@ -76,13 +76,6 @@ mutually exclusive.`,
 	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/pgupdate_test.go

@@ -205,35 +205,13 @@ func TestPGUpdate_NoMutationFields_Errors(t *testing.T) {
 	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) {
+func TestPGUpdate_ParameterOverrideFlagIsUnknown(t *testing.T) {
 	harness := newPGUpdateHarness(t)
 	pg := seedPG(harness.server, "my-db")
 
-	_, err := harness.execute(pg.Id, "--parameter-override", "noequals", "--output", "text")
+	result, err := harness.execute(pg.Id, "--parameter-override", "max_connections=111", "--output", "text")
 	require.Error(t, err)
-	assert.Contains(t, err.Error(), "expected KEY=VALUE format")
+	assert.Contains(t, result.Stderr, "unknown flag: --parameter-override")
 }
 
 func TestPGUpdate_BothIPAllowListAndClearFlags_Errors(t *testing.T) {

pkg/postgres/create.go

@@ -25,22 +25,21 @@ const DefaultPostgresVersion = 18
 // All client-side defaults have been applied and the scope has been resolved to an owner
 // ID + optional environment ID by the time this struct is constructed.
 type CreateRequestInput struct {
-	Name               string
-	OwnerID            string
-	Plan               string
-	Version            int
-	Region             *string
-	EnvironmentID      *string
-	DatabaseName       *string
-	DatabaseUser       *string
-	HighAvailability   *bool
-	DiskSizeGB         *int
-	DiskAutoscaling    *bool
-	DatadogAPIKey      *string
-	DatadogSite        *string
-	IPAllowList        []string
-	ParameterOverrides []string
-	ReadReplicas       []string
+	Name             string
+	OwnerID          string
+	Plan             string
+	Version          int
+	Region           *string
+	EnvironmentID    *string
+	DatabaseName     *string
+	DatabaseUser     *string
+	HighAvailability *bool
+	DiskSizeGB       *int
+	DiskAutoscaling  *bool
+	DatadogAPIKey    *string
+	DatadogSite      *string
+	IPAllowList      []string
+	ReadReplicas     []string
 }
 
 // buildRequestInput applies defaults to CLI input and produces the resolved
@@ -59,22 +58,21 @@ func buildRequestInput(in pgtypes.CreatePostgresInput, ownerID string, environme
 		version = *in.Version
 	}
 	return CreateRequestInput{
-		Name:               name,
-		OwnerID:            ownerID,
-		Plan:               plan,
-		Version:            version,
-		Region:             in.Region,
-		EnvironmentID:      environmentID,
-		DatabaseName:       in.DatabaseName,
-		DatabaseUser:       in.DatabaseUser,
-		HighAvailability:   in.HighAvailability,
-		DiskSizeGB:         in.DiskSizeGB,
-		DiskAutoscaling:    in.DiskAutoscaling,
-		DatadogAPIKey:      in.DatadogAPIKey,
-		DatadogSite:        in.DatadogSite,
-		IPAllowList:        in.IPAllowList,
-		ParameterOverrides: in.ParameterOverrides,
-		ReadReplicas:       in.ReadReplicas,
+		Name:             name,
+		OwnerID:          ownerID,
+		Plan:             plan,
+		Version:          version,
+		Region:           in.Region,
+		EnvironmentID:    environmentID,
+		DatabaseName:     in.DatabaseName,
+		DatabaseUser:     in.DatabaseUser,
+		HighAvailability: in.HighAvailability,
+		DiskSizeGB:       in.DiskSizeGB,
+		DiskAutoscaling:  in.DiskAutoscaling,
+		DatadogAPIKey:    in.DatadogAPIKey,
+		DatadogSite:      in.DatadogSite,
+		IPAllowList:      in.IPAllowList,
+		ReadReplicas:     in.ReadReplicas,
 	}
 }
 
@@ -98,11 +96,6 @@ func BuildCreateRequest(input CreateRequestInput) (client.CreatePostgresJSONRequ
 		return client.CreatePostgresJSONRequestBody{}, err
 	}
 
-	paramOverrides, err := buildParameterOverrides(input.ParameterOverrides)
-	if err != nil {
-		return client.CreatePostgresJSONRequestBody{}, err
-	}
-
 	body := client.CreatePostgresJSONRequestBody{
 		Name:                   input.Name,
 		OwnerId:                input.OwnerID,
@@ -116,7 +109,6 @@ func BuildCreateRequest(input CreateRequestInput) (client.CreatePostgresJSONRequ
 		EnableDiskAutoscaling:  input.DiskAutoscaling,
 		EnableHighAvailability: input.HighAvailability,
 		EnvironmentId:          input.EnvironmentID,
-		ParameterOverrides:     paramOverrides,
 		ReadReplicas:           buildReadReplicas(input.ReadReplicas),
 	}
 

pkg/postgres/create_test.go

@@ -105,50 +105,7 @@ func TestBuildCreateRequest_AllFieldsSpecified(t *testing.T) {
 	assert.Equal(t, "internal", (*body.IpAllowList)[0].Description)
 	assert.Equal(t, "203.0.113.5/32", (*body.IpAllowList)[1].CidrBlock)
 	assert.Equal(t, "office", (*body.IpAllowList)[1].Description)
-}
-
-func TestBuildCreateRequest_ParameterOverrides(t *testing.T) {
-	t.Run("parses KEY=VALUE pairs and trims whitespace", func(t *testing.T) {
-		in := minimalInput()
-		in.ParameterOverrides = []string{"max_connections=100", "  shared_buffers = 256MB  "}
-		body, err := postgres.BuildCreateRequest(in)
-		require.NoError(t, err)
-		require.NotNil(t, body.ParameterOverrides)
-		assert.Equal(t, "100", (*body.ParameterOverrides)["max_connections"])
-		assert.Equal(t, "256MB", (*body.ParameterOverrides)["shared_buffers"])
-	})
-
-	t.Run("rejects when any entry is malformed", func(t *testing.T) {
-		in := minimalInput()
-		in.ParameterOverrides = []string{"max_connections=100", "noequals", "shared_buffers=256MB"}
-		_, err := postgres.BuildCreateRequest(in)
-		require.Error(t, err)
-		assert.Contains(t, err.Error(), `"noequals"`)
-	})
-
-	t.Run("rejects malformed entries", func(t *testing.T) {
-		cases := []struct {
-			name  string
-			entry string
-		}{
-			{"no equals sign", "noequals"},
-			{"empty string", ""},
-			{"missing key (=VALUE)", "=value"},
-			{"missing value (KEY=)", "max_connections="},
-			{"both sides empty (=)", "="},
-			{"whitespace-only key", "  =value"},
-			{"whitespace-only value", "max_connections=   "},
-		}
-		for _, tc := range cases {
-			t.Run(tc.name, func(t *testing.T) {
-				in := minimalInput()
-				in.ParameterOverrides = []string{tc.entry}
-				_, err := postgres.BuildCreateRequest(in)
-				require.Error(t, err)
-				assert.Contains(t, err.Error(), "KEY=VALUE")
-			})
-		}
-	})
+	assert.Nil(t, body.ParameterOverrides)
 }
 
 func TestBuildCreateRequest_ReadReplicas(t *testing.T) {

pkg/postgres/output.go

@@ -1,8 +1,6 @@
 package postgres
 
 import (
-	"reflect"
-
 	"github.com/render-oss/cli/internal/ipallowlist"
 	"github.com/render-oss/cli/pkg/client"
 	pgclient "github.com/render-oss/cli/pkg/client/postgres"
@@ -64,13 +62,12 @@ type PostgresUpdateOut struct {
 }
 
 type PostgresUpdateDiff struct {
-	Name                    *PostgresFieldDiff[string]                             `json:"name,omitempty"`
-	Plan                    *PostgresFieldDiff[pgclient.PostgresPlans]             `json:"plan,omitempty"`
-	DiskSizeGB              *PostgresFieldDiff[*int]                               `json:"diskSizeGB,omitempty"`
-	DiskAutoscalingEnabled  *PostgresFieldDiff[bool]                               `json:"diskAutoscalingEnabled,omitempty"`
-	HighAvailabilityEnabled *PostgresFieldDiff[bool]                               `json:"highAvailabilityEnabled,omitempty"`
-	IPAllowList             *PostgresFieldDiff[[]client.CidrBlockAndDescription]   `json:"ipAllowList,omitempty"`
-	ParameterOverrides      *PostgresFieldDiff[*client.PostgresParameterOverrides] `json:"parameterOverrides,omitempty"`
+	Name                    *PostgresFieldDiff[string]                           `json:"name,omitempty"`
+	Plan                    *PostgresFieldDiff[pgclient.PostgresPlans]           `json:"plan,omitempty"`
+	DiskSizeGB              *PostgresFieldDiff[*int]                             `json:"diskSizeGB,omitempty"`
+	DiskAutoscalingEnabled  *PostgresFieldDiff[bool]                             `json:"diskAutoscalingEnabled,omitempty"`
+	HighAvailabilityEnabled *PostgresFieldDiff[bool]                             `json:"highAvailabilityEnabled,omitempty"`
+	IPAllowList             *PostgresFieldDiff[[]client.CidrBlockAndDescription] `json:"ipAllowList,omitempty"`
 }
 
 type PostgresFieldDiff[T any] struct {
@@ -160,14 +157,6 @@ func newPostgresUpdateDiff(before *client.PostgresDetail, after *PostgresOut) Po
 	if !ipallowlist.Equal(before.IpAllowList, after.IpAllowList) {
 		diff.IPAllowList = newPostgresFieldDiff(before.IpAllowList, after.IpAllowList)
 	}
-	beforeOverrides := normalizePostgresParameterOverrides(before.ParameterOverrides)
-	afterOverrides := normalizePostgresParameterOverrides(after.ParameterOverrides)
-	if !reflect.DeepEqual(beforeOverrides, afterOverrides) {
-		diff.ParameterOverrides = newPostgresFieldDiff(
-			beforeOverrides,
-			afterOverrides,
-		)
-	}
 	return diff
 }
 
@@ -194,9 +183,10 @@ func finalizePostgresOut(out *PostgresOut, project *client.Project, env *client.
 	if out.ReadReplicas == nil {
 		out.ReadReplicas = client.ReadReplicas{}
 	}
-	if out.ParameterOverrides != nil && len(*out.ParameterOverrides) == 0 {
-		out.ParameterOverrides = nil
-	}
+	// Parameter overrides are still early in rollout, so keep them out of
+	// CLI-facing output even when the API/client type carries populated values.
+	out.ParameterOverrides = nil
+	hideReadReplicaParameterOverrides(out.ReadReplicas)
 	if env != nil {
 		out.EnvironmentId = &env.Id
 		out.EnvironmentName = env.Name
@@ -214,6 +204,7 @@ func finalizePostgresListItemOut(out *PostgresListItemOut, project *client.Proje
 	if out.ReadReplicas == nil {
 		out.ReadReplicas = client.ReadReplicas{}
 	}
+	hideReadReplicaParameterOverrides(out.ReadReplicas)
 	if env != nil {
 		out.EnvironmentId = &env.Id
 		out.EnvironmentName = env.Name
@@ -231,9 +222,10 @@ func newPostgresFieldDiff[T any](before, after T) *PostgresFieldDiff[T] {
 	}
 }
 
-func normalizePostgresParameterOverrides(overrides *client.PostgresParameterOverrides) *client.PostgresParameterOverrides {
-	if overrides == nil || len(*overrides) == 0 {
-		return nil
+func hideReadReplicaParameterOverrides(replicas client.ReadReplicas) {
+	// Read replicas share the same early-rollout parameter override field, so
+	// omit it from list/detail output until the feature is generally available.
+	for i := range replicas {
+		replicas[i].ParameterOverrides = nil
 	}
-	return overrides
 }

pkg/postgres/output_test.go

@@ -53,6 +53,7 @@ func TestNewPostgresListOut_ConstructsItems(t *testing.T) {
 
 	expectedPostgres := *pg
 	expectedPostgres.IpAllowList = []client.CidrBlockAndDescription{}
+	expectedPostgres.ReadReplicas[0].ParameterOverrides = nil
 	assert.Equal(t, expectedPostgres, out.Data[0].Postgres)
 	assert.Equal(t, pointers.From("prj-prod"), out.Data[0].ProjectID)
 	assert.Equal(t, "Production Project", out.Data[0].ProjectName)
@@ -132,13 +133,12 @@ func TestNewPostgresGetOut_JSONSerialization(t *testing.T) {
 		"diskAutoscalingEnabled":  true,
 		"highAvailabilityEnabled": true,
 		"ipAllowList":             []any{map[string]any{"cidrBlock": "203.0.113.5/32", "description": "office"}},
-		"readReplicas":            []any{map[string]any{"id": "dpg-replica", "name": "analytics-replica", "parameterOverrides": map[string]any{"work_mem": "64MB"}}},
+		"readReplicas":            []any{map[string]any{"id": "dpg-replica", "name": "analytics-replica"}},
 		"primaryPostgresID":       "dpg-primary",
 		"role":                    "primary",
 		"suspended":               "not_suspended",
 		"suspenders":              []any{},
 		"dashboardUrl":            "https://dashboard.render.com/d/dpg-detail",
-		"parameterOverrides":      map[string]any{"max_connections": "100"},
 		"connectionInfo": map[string]any{
 			"psqlCommand":              "psql postgres://example",
 			"internalConnectionString": "postgres://internal",
@@ -300,11 +300,9 @@ func TestNewPostgresUpdateOut(t *testing.T) {
 			"before": []any{map[string]any{"cidrBlock": "203.0.113.5/32", "description": "office"}},
 			"after":  []any{},
 		},
-		"parameterOverrides": map[string]any{
-			"before": map[string]any{"max_connections": "100"},
-			"after":  map[string]any{"max_connections": "200"},
-		},
 	}, diff)
+	assert.NotContains(t, body, "parameterOverrides")
+	assert.NotContains(t, testrequire.SubMap(t, body, "data"), "parameterOverrides")
 }
 
 func marshalJSONMap(t *testing.T, v any) map[string]any {