render psql supports non-interactive outputs (#254)

Adds --command/-c flag that runs a query and exits, with output
controlled by -o json|yaml|text. Additional psql flags pass through
via -- [args].

# Interactive mode (default)
render psql my-database

# Non-interactive outputs
render psql my-database -c "SELECT NOW();" -o text
render psql my-database -c "SELECT NOW();" -o json
render psql my-database -c "SELECT NOW();" -o yaml

# Passthrough psql flags
render psql my-database -c "SELECT id, email FROM users;" -o text -- --csv
render psql my-database -c "SELECT count(*) FROM orders;" -o text -- -t -A

Author: metonym

cmd/psql.go

@@ -2,13 +2,15 @@ package cmd
 
 import (
 	"context"
+	"fmt"
 
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/spf13/cobra"
 
 	"github.com/render-oss/cli/pkg/client"
 	"github.com/render-oss/cli/pkg/command"
 	"github.com/render-oss/cli/pkg/postgres"
+	"github.com/render-oss/cli/pkg/text"
 	"github.com/render-oss/cli/pkg/tui"
 	"github.com/render-oss/cli/pkg/tui/flows"
 	"github.com/render-oss/cli/pkg/tui/views"
@@ -19,7 +21,13 @@ var psqlCmd = &cobra.Command{
 	Use:   "psql [postgresID|postgresName]",
 	Short: "Open a psql session to a PostgreSQL database",
 	Long: `Open a psql session to a PostgreSQL database. Optionally pass the database id or name as an argument.
-To pass arguments to psql, use the following syntax: render psql [postgresID|postgresName] -- [psql args]`,
+To pass arguments to psql, use the following syntax: render psql [postgresID|postgresName] -- [psql args]
+
+For non-interactive usage, use the --command flag:
+  render psql [postgresID|postgresName] -c "SELECT * FROM users;" -o text
+
+Additional psql flags can be passed after --:
+  render psql [postgresID|postgresName] -c "SELECT 1;" -o json -- --csv -q`,
 	GroupID: GroupSession.ID,
 }
 
@@ -51,10 +59,12 @@ func getPsqlTableOptions(ctx context.Context, input *views.PSQLInput) []tui.Cust
 func init() {
 	rootCmd.AddCommand(psqlCmd)
 
+	psqlCmd.Flags().StringP("command", "c", "", "SQL command to execute (enables non-interactive mode)")
+
 	psqlCmd.RunE = func(cmd *cobra.Command, args []string) error {
 		ctx := cmd.Context()
 		var input views.PSQLInput
-		err := command.ParseCommandInteractiveOnly(cmd, args, &input)
+		err := command.ParseCommand(cmd, args, &input)
 		if err != nil {
 			return err
 		}
@@ -67,6 +77,27 @@ func init() {
 			input.Args = args[cmd.ArgsLenAtDash():]
 		}
 
+		input.Tool = views.PSQL
+
+		outputFormat := command.GetFormatFromContext(ctx)
+		if outputFormat != nil && !outputFormat.Interactive() {
+			if input.Command == "" {
+				return fmt.Errorf("--command flag is required in non-interactive mode\nUsage: render psql <postgresID> --command \"SELECT ...\" -o json")
+			}
+
+			if input.PostgresIDOrName == "" {
+				return fmt.Errorf("postgres ID or name is required in non-interactive mode")
+			}
+
+			result, err := views.ExecutePSQLNonInteractive(ctx, &input)
+			if err != nil {
+				return err
+			}
+
+			_, err = command.PrintData(cmd, result, text.PSQLResultText)
+			return err
+		}
+
 		InteractivePSQLView(ctx, &input)
 		return nil
 	}

pkg/text/psql.go

@@ -0,0 +1,7 @@
+package text
+
+import "github.com/render-oss/cli/pkg/tui/views"
+
+func PSQLResultText(result *views.PSQLResult) string {
+	return result.Output
+}

pkg/text/psql_test.go

@@ -0,0 +1,34 @@
+package text
+
+import (
+	"testing"
+
+	"github.com/render-oss/cli/pkg/tui/views"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPSQLResultText(t *testing.T) {
+	tests := []struct {
+		name     string
+		result   *views.PSQLResult
+		expected string
+	}{
+		{
+			name:     "returns raw output",
+			result:   &views.PSQLResult{Output: " id | name\n----+------\n  1 | test\n(1 row)\n"},
+			expected: " id | name\n----+------\n  1 | test\n(1 row)\n",
+		},
+		{
+			name:     "empty output",
+			result:   &views.PSQLResult{Output: ""},
+			expected: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := PSQLResultText(tt.result)
+			require.Equal(t, tt.expected, result)
+		})
+	}
+}

pkg/tui/stack.go

@@ -20,7 +20,16 @@ type UserFacingError struct {
 }
 
 func (u UserFacingError) Error() string {
-	return u.Err.Error()
+	if u.Err != nil {
+		return u.Err.Error()
+	}
+	if u.Message != "" {
+		return u.Message
+	}
+	if u.Title != "" {
+		return u.Title
+	}
+	return "unknown error"
 }
 
 var stackHeaderStyle = lipgloss.NewStyle().MarginTop(1).MarginBottom(1)

pkg/tui/views/psql.go

@@ -1,12 +1,14 @@
 package views
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"io"
 	"net"
 	"net/http"
 	"os/exec"
+	"strings"
 
 	tea "github.com/charmbracelet/bubbletea"
 
@@ -26,6 +28,7 @@ type PSQLInput struct {
 	Project          *client.Project
 	EnvironmentIDs   []string
 	Tool             PSQLTool
+	Command          string `cli:"command"`
 
 	Args []string
 }
@@ -35,6 +38,63 @@ type PSQLView struct {
 	execModel     *tui.ExecModel
 }
 
+type PSQLResult struct {
+	Output string `json:"output"`
+}
+
+func ExecutePSQLNonInteractive(ctx context.Context, input *PSQLInput) (*PSQLResult, error) {
+	c, err := client.NewDefaultClient()
+	if err != nil {
+		return nil, err
+	}
+
+	pgc := postgres.NewRepo(c)
+
+	pg, err := getPostgresFromIDOrName(ctx, c, input.PostgresIDOrName)
+	if err != nil {
+		return nil, err
+	}
+
+	userIP, ok := getUserIP()
+	if ok {
+		hasAccess, err := hasAccessToPostgres(pg, userIP)
+		if err != nil {
+			return nil, err
+		}
+
+		if !hasAccess {
+			return nil, fmt.Errorf("IP address (%s) not in allow list for %s", userIP, pg.Name)
+		}
+	}
+
+	connectionInfo, err := pgc.GetPostgresConnectionInfo(ctx, pg.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	args := []string{connectionInfo.ExternalConnectionString, "-c", input.Command}
+	for _, arg := range input.Args {
+		args = append(args, arg)
+	}
+
+	cmd := exec.CommandContext(ctx, string(input.Tool), args...)
+
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	err = cmd.Run()
+	if err != nil {
+		errMsg := stderr.String()
+		if errMsg != "" {
+			return nil, fmt.Errorf("%s: %s", err, strings.TrimSpace(errMsg))
+		}
+		return nil, err
+	}
+
+	return &PSQLResult{Output: stdout.String()}, nil
+}
+
 func NewPSQLView(ctx context.Context, input *PSQLInput, opts ...tui.TableOption[*postgres.Model]) *PSQLView {
 	psqlView := &PSQLView{
 		execModel: tui.NewExecModel(string(input.Tool), handlePSQLError(input.Tool), command.LoadCmd(ctx, loadDataPSQL, input)),

pkg/tui/views/psql_test.go

@@ -0,0 +1,50 @@
+package views
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"gopkg.in/yaml.v3"
+)
+
+func TestPSQLResult_JSONMarshal(t *testing.T) {
+	tests := []struct {
+		name     string
+		result   PSQLResult
+		expected string
+	}{
+		{
+			name:     "tabular output",
+			result:   PSQLResult{Output: " id | name\n----+------\n  1 | test\n(1 row)\n"},
+			expected: `{"output":" id | name\n----+------\n  1 | test\n(1 row)\n"}`,
+		},
+		{
+			name:     "empty output",
+			result:   PSQLResult{Output: ""},
+			expected: `{"output":""}`,
+		},
+		{
+			name:     "csv output from passthrough",
+			result:   PSQLResult{Output: "id,name\n1,alice\n2,bob\n"},
+			expected: `{"output":"id,name\n1,alice\n2,bob\n"}`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			b, err := json.Marshal(tt.result)
+			require.NoError(t, err)
+			require.JSONEq(t, tt.expected, string(b))
+		})
+	}
+}
+
+func TestPSQLResult_YAMLMarshal(t *testing.T) {
+	result := PSQLResult{Output: "hello world\n"}
+
+	b, err := yaml.Marshal(result)
+	require.NoError(t, err)
+	require.Contains(t, string(b), "output:")
+	require.Contains(t, string(b), "hello world")
+}