Add Postgres create command (#442)

Implements `render ea pg create` command.

https://linear.app/render-com/issue/GROW-2118/pg-create

GitOrigin-RevId: 36a70020a9e0fe3b682468f94c090d5f7817d3eb

Author: davidharting

cmd/earlyaccess.go

@@ -4,12 +4,16 @@ import (
 	"github.com/spf13/cobra"
 )
 
-var EarlyAccessCmd = &cobra.Command{
-	Use:   "ea",
-	Short: "Use early access commands",
-	Long:  `These commands are in early access and are subject to change.`,
-	Example: `  # List early access object storage resources
+var EarlyAccessCmd = newEarlyAccessCmd()
+
+func newEarlyAccessCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "ea",
+		Short: "Use early access commands",
+		Long:  `These commands are in early access and are subject to change.`,
+		Example: `  # List early access object storage resources
   render ea objects list --region=oregon`,
+	}
 }
 
 func init() {

cmd/pg.go

@@ -0,0 +1,19 @@
+package cmd
+
+import "github.com/spf13/cobra"
+
+func newPgCmd(children ...*cobra.Command) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "pg",
+		Aliases: []string{"postgres"},
+		Short:   "Manage Postgres databases",
+		Long: `Manage Postgres databases.
+
+Lives under 'ea' while the command surface stabilizes. Postgres itself is
+generally available, but the flag set and output format for these commands may
+still change. We'll promote them out of 'ea' once we're confident in the
+contract.`,
+	}
+	cmd.AddCommand(children...)
+	return cmd
+}

cmd/pgcreate.go

@@ -0,0 +1,106 @@
+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 newPgCreateCmd(deps *dependencies.Dependencies) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:          "create",
+		Short:        "Create a new Postgres database",
+		Args:         cobra.NoArgs,
+		SilenceUsage: true,
+		Long: `Create a new Postgres database on Render.
+
+Every flag is optional: running 'render ea pg create' with no flags provisions
+a database in the active workspace with sensible defaults.
+
+Output defaults to text. Use --output json or --output yaml for
+machine-readable output.
+
+Examples:
+  # Create with all defaults
+  render ea pg create
+
+  # Pick a plan, version, and region
+  render ea pg create --name analytics --plan pro_8gb --version 17 --region ohio
+
+  # Restrict inbound traffic (repeat the flag for multiple entries)
+  render ea pg create --name analytics \
+    --ip-allow-list "cidr=203.0.113.5/32,description=office" \
+    --ip-allow-list "cidr=10.0.0.0/8,description=internal"
+
+  # Machine-readable output
+  render ea pg create --output json`,
+	}
+
+	cmd.Flags().String("name", "", "Database name (generated if not provided)")
+	cmd.Flags().String("workspace", "", "Workspace ID or name. Defaults to the active workspace (set via 'render workspace set').")
+	cmd.Flags().String("project", "", "Project ID or name (optional). Scopes environment lookup; if the project has exactly one environment it is used automatically.")
+	cmd.Flags().String("environment", "", "Environment ID or name (optional). Example: Production or evm-abc123def456")
+
+	cmd.Flags().String("plan", "", "Plan name. Examples: "+strings.Join(postgres.ModernPlans, " | "))
+	cmd.Flags().Int("version", 0, fmt.Sprintf("Postgres major version. Defaults to %d.", postgres.DefaultPostgresVersion))
+
+	regionFlag := command.NewEnumInput(types.RegionValues(), false)
+	cmd.Flags().Var(regionFlag, "region", "Region: "+strings.Join(types.RegionValues(), " | ")+" (server picks if unset)")
+
+	cmd.Flags().String("database-name", "", "Postgres database name (server generates one if unset)")
+	cmd.Flags().String("database-user", "", "Postgres database user (server generates one if unset)")
+
+	cmd.Flags().Int("disk-size-gb", 0, "Disk size in GB. Must be 1 or a multiple of 5. Server picks a sensible default based on compute size if unset.")
+	cmd.Flags().Bool("disk-autoscaling", false, "Enable disk autoscaling")
+	cmd.Flags().Bool("high-availability", false, "Enable high availability (Pro plans and above)")
+
+	cmd.Flags().String("datadog-api-key", "", "Datadog API key for monitoring")
+	cmd.Flags().String("datadog-site", "", "Datadog region/site (e.g. US1, US3, EU). Server default is US1.")
+
+	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.RunE = func(cmd *cobra.Command, args []string) error {
+		command.DefaultFormatNonInteractive(cmd)
+
+		var input pgtypes.CreatePostgresInput
+		if err := command.ParseCommand(cmd, args, &input); err != nil {
+			return err
+		}
+
+		_, err := command.NonInteractive(cmd,
+			func() (*client.PostgresDetail, error) {
+				return deps.PostgresService().Create(cmd.Context(), input)
+			},
+			func(pg *client.PostgresDetail) string {
+				return pgCreateSuccessMessage(pg)
+			},
+		)
+		return err
+	}
+
+	return cmd
+}
+
+func pgCreateSuccessMessage(pg *client.PostgresDetail) string {
+	return fmt.Sprintf(
+		"Created Postgres database\n\n%s\n",
+		text.PostgresDetail(pg),
+	)
+}

cmd/pgcreate_test.go

@@ -0,0 +1,194 @@
+package cmd
+
+import (
+	"bytes"
+	"encoding/json"
+	"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"
+	pgclient "github.com/render-oss/cli/pkg/client/postgres"
+	"github.com/render-oss/cli/pkg/command"
+	"github.com/render-oss/cli/pkg/dependencies"
+)
+
+var pgActiveWorkspaceID = testids.WorkspaceID("active")
+
+func executePGCreate(t *testing.T, server *renderapi.Server, extraArgs ...string) (CommandResult, error) {
+	t.Helper()
+	server.Owners.Add(renderapi.NewOwner(client.Owner{Id: pgActiveWorkspaceID, Name: "Test Workspace"}))
+	t.Setenv("RENDER_WORKSPACE", pgActiveWorkspaceID)
+
+	return executePGCommand(t, server, append([]string{"ea", "pg", "create"}, extraArgs...)...)
+}
+
+func executePGCommand(t *testing.T, server *renderapi.Server, args ...string) (CommandResult, error) {
+	t.Helper()
+	t.Setenv("RENDER_CLI_CONFIG_PATH", newTestConfigPath(t))
+	t.Setenv("RENDER_API_KEY", "test-api-key")
+
+	c, err := client.NewClientWithResponses(server.URL())
+	require.NoError(t, err)
+	deps := dependencies.New(c)
+	deps.DetectRuntimeSignals = func() (command.RuntimeSignals, error) {
+		return command.RuntimeSignals{
+			StdinTTY:  false,
+			StdoutTTY: false,
+			StderrTTY: false,
+		}, nil
+	}
+
+	root := newRootCmd()
+	ea := newEarlyAccessCmd()
+	root.AddCommand(ea)
+	setupPGCommands(ea, deps)
+	setupRootCmdPersistentRun(root, deps)
+
+	var stdout, stderr bytes.Buffer
+	root.SetOut(&stdout)
+	root.SetErr(&stderr)
+	root.SetArgs(args)
+
+	execErr := root.Execute()
+	return CommandResult{Stdout: stdout.String(), Stderr: stderr.String()}, execErr
+}
+
+func TestPGCreate_ZeroFlags_AppliesDefaults(t *testing.T) {
+	server := renderapi.NewServer(t)
+	result, err := executePGCreate(t, server, "--output", "text")
+	require.NoError(t, err)
+
+	require.Len(t, server.Postgres.Instances, 1)
+	pg := server.Postgres.Instances[0]
+	assert.NotEmpty(t, pg.Name)
+	assert.Equal(t, pgclient.Free, pg.Plan)
+	assert.Equal(t, client.PostgresVersion("18"), pg.Version)
+	assert.Equal(t, pgActiveWorkspaceID, pg.Owner.Id)
+	assert.Equal(t, client.Oregon, pg.Region)
+	assert.Contains(t, result.Stdout, pg.Name)
+	assert.Contains(t, result.Stdout, pg.Id)
+}
+
+func TestPGCreate_AllFlags(t *testing.T) {
+	server := renderapi.NewServer(t)
+	result, err := executePGCreate(t, server,
+		"--name", "analytics",
+		"--plan", "pro_4gb",
+		"--version", "17",
+		"--region", "ohio",
+		"--database-name", "metrics",
+		"--database-user", "metrics_user",
+		"--disk-size-gb", "105",
+		"--disk-autoscaling",
+		"--high-availability",
+		"--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",
+	)
+	require.NoError(t, err)
+
+	require.Len(t, server.Postgres.Instances, 1)
+	pg := server.Postgres.Instances[0]
+	assert.Equal(t, "analytics", pg.Name)
+	assert.Equal(t, pgclient.Pro4gb, pg.Plan)
+	assert.Equal(t, client.PostgresVersion("17"), pg.Version)
+	assert.Equal(t, client.Region("ohio"), pg.Region)
+	assert.Equal(t, "metrics", pg.DatabaseName)
+	assert.Equal(t, "metrics_user", pg.DatabaseUser)
+	require.NotNil(t, pg.DiskSizeGB)
+	assert.Equal(t, 105, *pg.DiskSizeGB)
+	assert.True(t, pg.DiskAutoscalingEnabled)
+	assert.True(t, pg.HighAvailabilityEnabled)
+	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)
+	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.Contains(t, result.Stdout, "analytics")
+	assert.Contains(t, result.Stdout, "Read replicas:")
+}
+
+func TestPGCreate_OutputJSON_IsMachineReadable(t *testing.T) {
+	server := renderapi.NewServer(t)
+	result, err := executePGCreate(t, server,
+		"--name", "my-pg",
+		"--output", "json",
+	)
+	require.NoError(t, err)
+
+	var decoded map[string]any
+	require.NoError(t, json.Unmarshal([]byte(result.Stdout), &decoded))
+	assert.Equal(t, "my-pg", decoded["name"])
+	assert.NotEmpty(t, decoded["id"])
+}
+
+func TestPGCreate_PostgresAlias(t *testing.T) {
+	server := renderapi.NewServer(t)
+	server.Owners.Add(renderapi.NewOwner(client.Owner{Id: pgActiveWorkspaceID, Name: "Test Workspace"}))
+	t.Setenv("RENDER_WORKSPACE", pgActiveWorkspaceID)
+
+	_, err := executePGCommand(t, server,
+		"ea", "postgres", "create",
+		"--name", "alias-pg",
+		"--output", "text",
+	)
+	require.NoError(t, err)
+
+	require.Len(t, server.Postgres.Instances, 1)
+	assert.Equal(t, "alias-pg", server.Postgres.Instances[0].Name)
+}
+
+func TestPGCreate_InvalidParameterOverride(t *testing.T) {
+	server := renderapi.NewServer(t)
+	result, err := executePGCreate(t, server,
+		"--parameter-override", "noequals",
+		"--output", "text",
+	)
+	require.Error(t, err)
+
+	assert.Contains(t, result.Stderr, "expected KEY=VALUE format")
+	assert.Empty(t, server.Postgres.Instances)
+}
+
+func TestPGCreate_NoWorkspaceConfigured(t *testing.T) {
+	server := renderapi.NewServer(t)
+	result, err := executePGCommand(t, server, "ea", "pg", "create", "--output", "text")
+	require.Error(t, err)
+	assert.Contains(t, result.Stderr, "no workspace")
+	assert.Empty(t, server.Postgres.Instances)
+}
+
+func TestPGCreate_ProjectFlag_SingleEnv(t *testing.T) {
+	server := renderapi.NewServer(t)
+	projectID := testids.ProjectID("project")
+	environmentID := testids.EnvironmentID("production")
+	server.Projects.Add(renderapi.NewProject(renderapi.ProjectAttrs{
+		Id:      projectID,
+		Name:    "My Project",
+		OwnerId: pgActiveWorkspaceID,
+	}))
+	server.Environments.Add(renderapi.NewEnvironment(client.Environment{
+		Id:        environmentID,
+		Name:      "production",
+		ProjectId: projectID,
+	}))
+
+	_, err := executePGCreate(t, server,
+		"--project", "My Project",
+		"--output", "text",
+	)
+	require.NoError(t, err)
+
+	require.Len(t, server.Postgres.Instances, 1)
+	require.NotNil(t, server.Postgres.Instances[0].EnvironmentId)
+	assert.Equal(t, environmentID, *server.Postgres.Instances[0].EnvironmentId)
+}

cmd/root.go

@@ -154,6 +154,10 @@ func setupWorkspaceCommands(deps *dependencies.Dependencies) {
 	workspaceCmd.AddCommand(deps.Commands.Workspace.WorkspaceSetCmd)
 }
 
+func setupPGCommands(earlyAccess *cobra.Command, deps *dependencies.Dependencies) {
+	earlyAccess.AddCommand(newPgCmd(newPgCreateCmd(deps)))
+}
+
 func SetupCommands() error {
 	c, err := client.NewDefaultClient()
 	if err != nil {
@@ -172,6 +176,7 @@ func SetupCommands() error {
 	setupWorkflowCommands(deps)
 	setupLogCommands(deps)
 	setupWorkspaceCommands(deps)
+	setupPGCommands(EarlyAccessCmd, deps)
 	setupRootCmdPersistentRun(rootCmd, deps)
 
 	return nil

pkg/postgres/create.go

@@ -19,7 +19,7 @@ const defaultPlan = pgclient.Free
 // Default Postgres major version when --version is not supplied. Server-side
 // validation is the source of truth for which versions are accepted; bump this
 // when we want new databases to default to a newer version.
-const defaultPostgresVersion = 18
+const DefaultPostgresVersion = 18
 
 // CreateRequestInput is the resolved input to BuildCreateRequest.
 // All client-side defaults have been applied and the scope has been resolved to an owner
@@ -54,7 +54,7 @@ func buildRequestInput(in pgtypes.CreatePostgresInput, ownerID string, environme
 	if plan == "" {
 		plan = string(defaultPlan)
 	}
-	version := defaultPostgresVersion
+	version := DefaultPostgresVersion
 	if in.Version != nil {
 		version = *in.Version
 	}