Create Postgres interactively (#462)

Create a Render Postgres with a step-by-step wizard when you run `render ea pg create` in `--output=interactive` (which is the default).

Agents or hasty humans can still create a postgres in one command by either:

- Passing `--confirm`
- Swapping to `--output=[text, json, or yaml]`

The flow is modeled after `render ea keyvalue create`.

GROW-1942

GitOrigin-RevId: 7e52e523a81810edae384cefd829fbfaf4eeb55a

Author: davidharting

cmd/pgcreate.go

@@ -11,6 +11,7 @@ import (
 	"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/tui/views"
 	"github.com/render-oss/cli/pkg/types"
 	pgtypes "github.com/render-oss/cli/pkg/types/postgres"
 )
@@ -23,21 +24,28 @@ func newPgCreateCmd(deps *dependencies.Dependencies) *cobra.Command {
 		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.
+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.
 
-Output defaults to text. Use --output json or --output yaml for
-machine-readable output.
+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
+printed as text. Use --output json, yaml, or text for non-interactive output.
 
 Examples:
-  # Create with all defaults
+  # Launch the interactive wizard
   render ea pg create
 
-  # Pick a plan, version, and region
-  render ea pg create --name analytics --plan pro_8gb --version 17 --region ohio
+  # Create immediately with defaults and text output
+  render ea pg create --confirm
 
-  # Restrict inbound traffic (repeat the flag for multiple entries)
-  render ea pg create --name analytics \
+  # Create immediately with explicit values
+  render ea pg create --confirm --name analytics --plan pro_8gb --version 17 --region ohio
+
+  # Include flag-only settings while using the wizard for prompted values
+  render ea pg create \
     --ip-allow-list "cidr=203.0.113.5/32,description=office" \
     --ip-allow-list "cidr=10.0.0.0/8,description=internal"
 
@@ -77,21 +85,40 @@ Examples:
 		"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)
+		if command.GetConfirmFromContext(cmd.Context()) {
+			command.DefaultFormatNonInteractive(cmd)
+		}
 
 		var input pgtypes.CreatePostgresInput
 		if err := command.ParseCommand(cmd, args, &input); err != nil {
 			return err
 		}
 
-		_, err := command.NonInteractive(cmd,
+		// There are two execution paths:
+		//  1. Non-interactive output (text/json/yaml): create and print via the shared formatter.
+		//  2. Interactive output: run the TUI wizard, which owns its styled output.
+		// --confirm skips prompts, so collapse default interactive output to text before
+		// this gate. command.NonInteractive returns (false, nil) only when the resolved
+		// output format is still interactive, without calling loadData.
+		nonInteractive, err := command.NonInteractive(cmd,
 			func() (*client.PostgresDetail, error) {
 				return deps.PostgresService().Create(cmd.Context(), input)
 			},
 			func(pg *client.PostgresDetail) string {
 				return pgCreateSuccessMessage(pg)
 			},
 		)
+		if err != nil || nonInteractive {
+			return err
+		}
+
+		repos := views.PostgresCreateRepos{
+			Owners:   deps.OwnerRepo(),
+			Projects: deps.ProjectRepo(),
+			Envs:     deps.EnvironmentRepo(),
+			Postgres: deps.PostgresRepo(),
+		}
+		_, err = views.RunPostgresCreate(cmd, repos, input)
 		return err
 	}
 

cmd/pgcreate_test.go

@@ -94,6 +94,30 @@ func TestPGCreate_OutputJSON_IsMachineReadable(t *testing.T) {
 	assert.NotEmpty(t, decoded["id"])
 }
 
+// Verifies that --confirm in interactive output mode creates without launching the wizard.
+func TestPGCreate_InteractiveConfirm_PrintsTextSuccess(t *testing.T) {
+	server := renderapi.NewServer(t)
+	result, err := executePGCreate(t, server,
+		"--confirm",
+		"--name", "confirm-pg",
+		"--plan", "basic_256mb",
+		"--version", "17",
+		"--region", "oregon",
+		"--output", "interactive",
+	)
+	require.NoError(t, err)
+
+	require.Len(t, server.Postgres.Instances, 1)
+	pg := server.Postgres.Instances[0]
+	assert.Equal(t, "confirm-pg", pg.Name)
+	assert.Equal(t, pgclient.Basic256mb, pg.Plan)
+	assert.Equal(t, client.PostgresVersion("17"), pg.Version)
+	assert.Equal(t, client.Oregon, pg.Region)
+	assert.Contains(t, result.Stdout, "Created Postgres database")
+	assert.Contains(t, result.Stdout, "confirm-pg")
+	assert.Contains(t, result.Stdout, pg.Id)
+}
+
 func TestPGCreate_PostgresAlias(t *testing.T) {
 	server := renderapi.NewServer(t)
 	server.Owners.Add(renderapi.NewOwner(client.Owner{Id: pgActiveWorkspaceID, Name: "Test Workspace"}))

pkg/tui/testhelper/util.go

@@ -1,7 +1,13 @@
 package testhelper
 
 import (
+	"bytes"
+	"io"
+	"testing"
+	"time"
+
 	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/x/exp/teatest"
 	"github.com/render-oss/cli/pkg/tui"
 )
 
@@ -10,3 +16,49 @@ func Stackify(m tea.Model) tea.Model {
 	stack.Push(tui.ModelWithCmd{Model: m, Cmd: ""})
 	return stack
 }
+
+type WaitForContainsOptions struct {
+	Duration      time.Duration
+	CheckInterval time.Duration
+}
+
+var defaultWaitForContainsOptions = WaitForContainsOptions{
+	Duration:      3 * time.Second,
+	CheckInterval: 10 * time.Millisecond,
+}
+
+// WaitForContains waits until output contains text, failing the test if the text
+// does not appear before the timeout. Any zero-valued option fields are filled
+// with defaults.
+func WaitForContains(t testing.TB, output io.Reader, text string, opts ...WaitForContainsOptions) {
+	t.Helper()
+	options := waitForContainsOptions(opts...)
+	teatest.WaitFor(t, output, func(b []byte) bool {
+		return bytes.Contains(b, []byte(text))
+	},
+		teatest.WithCheckInterval(options.CheckInterval),
+		teatest.WithDuration(options.Duration),
+	)
+}
+
+func waitForContainsOptions(opts ...WaitForContainsOptions) WaitForContainsOptions {
+	if len(opts) > 1 {
+		panic("WaitForContains accepts at most one options struct")
+	}
+	options := defaultWaitForContainsOptions
+	if len(opts) == 1 {
+		options = mergeWaitForContainsOptions(options, opts[0])
+	}
+	return options
+}
+
+func mergeWaitForContainsOptions(base, override WaitForContainsOptions) WaitForContainsOptions {
+	options := base
+	if override.Duration != 0 {
+		options.Duration = override.Duration
+	}
+	if override.CheckInterval != 0 {
+		options.CheckInterval = override.CheckInterval
+	}
+	return options
+}

pkg/tui/testhelper/util_test.go

@@ -0,0 +1,35 @@
+package testhelper
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestWaitForContainsOptions(t *testing.T) {
+	t.Run("uses defaults for zero values", func(t *testing.T) {
+		options := waitForContainsOptions(WaitForContainsOptions{})
+
+		assert.Equal(t, 3*time.Second, options.Duration)
+		assert.Equal(t, 10*time.Millisecond, options.CheckInterval)
+	})
+
+	t.Run("layers non-zero values over defaults", func(t *testing.T) {
+		options := waitForContainsOptions(WaitForContainsOptions{
+			Duration: 5 * time.Second,
+		})
+
+		assert.Equal(t, 5*time.Second, options.Duration)
+		assert.Equal(t, 10*time.Millisecond, options.CheckInterval)
+	})
+
+	t.Run("panics when multiple options are passed", func(t *testing.T) {
+		assert.Panics(t, func() {
+			waitForContainsOptions(
+				WaitForContainsOptions{Duration: 5 * time.Second},
+				WaitForContainsOptions{CheckInterval: 5 * time.Millisecond},
+			)
+		})
+	})
+}