Prod deploy

.golangci.yml

@@ -21,7 +21,3 @@ issues:
     - linters:
         - stylecheck
       text: "ST1003:"
-    - linters:
-        - staticcheck
-        - stylecheck
-      text: "ST1005:"

cmd/bootstrap.go

@@ -0,0 +1,88 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"strings"
+
+	"github.com/spf13/afero"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	"github.com/supabase/cli/internal/bootstrap"
+	"github.com/supabase/cli/internal/utils"
+)
+
+var (
+	templateUrl string
+
+	bootstrapCmd = &cobra.Command{
+		GroupID: groupQuickStart,
+		Use:     "bootstrap [template]",
+		Short:   "Bootstrap a Supabase project from a starter template",
+		Args:    cobra.MaximumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if !viper.IsSet("WORKDIR") {
+				title := fmt.Sprintf("Enter a directory to bootstrap your project (or leave blank to use %s): ", utils.Bold(utils.CurrentDirAbs))
+				workdir, err := utils.PromptText(title, os.Stdin)
+				if err != nil {
+					return err
+				}
+				viper.Set("WORKDIR", workdir)
+			}
+			ctx, _ := signal.NotifyContext(cmd.Context(), os.Interrupt)
+			client := bootstrap.GetGtihubClient(ctx)
+			templates, err := bootstrap.ListSamples(ctx, client)
+			if err != nil {
+				return err
+			}
+			if len(args) > 0 {
+				name := strings.ToLower(args[0])
+				for _, t := range templates {
+					if t.Name == name {
+						templateUrl = t.Url
+					}
+				}
+			}
+			if len(templateUrl) == 0 {
+				if err := promptStarterTemplate(ctx, templates); err != nil {
+					return err
+				}
+			}
+			return bootstrap.Run(ctx, templateUrl, afero.NewOsFs())
+		},
+	}
+)
+
+func init() {
+	bootstrapFlags := bootstrapCmd.Flags()
+	bootstrapFlags.StringP("password", "p", "", "Password to your remote Postgres database.")
+	cobra.CheckErr(viper.BindPFlag("DB_PASSWORD", bootstrapFlags.Lookup("password")))
+	rootCmd.AddCommand(bootstrapCmd)
+}
+
+func promptStarterTemplate(ctx context.Context, templates []bootstrap.StarterTemplate) error {
+	items := make([]utils.PromptItem, len(templates))
+	for i, t := range templates {
+		items[i] = utils.PromptItem{
+			Index:   i,
+			Summary: t.Name,
+			Details: t.Description,
+		}
+	}
+	items = append(items, utils.PromptItem{
+		Index:   len(items),
+		Summary: "scratch",
+		Details: "An empty project from scratch.",
+	})
+	title := "Which starter template do you want to use?"
+	choice, err := utils.PromptChoice(ctx, title, items)
+	if err != nil {
+		return err
+	}
+	if choice.Index < len(templates) {
+		templateUrl = templates[choice.Index].Url
+	}
+	return nil
+}

cmd/gen.go

@@ -1,11 +1,11 @@
 package cmd
 
 import (
-	"errors"
 	"os"
 	"os/signal"
 
 	env "github.com/Netflix/go-env"
+	"github.com/go-errors/errors"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 	"github.com/supabase/cli/internal/gen/keys"

cmd/init.go

@@ -12,9 +12,10 @@ import (
 
 var (
 	createVscodeSettings   = new(bool)
-	useOrioleDB            bool
 	createIntellijSettings = new(bool)
-	initCmd                = &cobra.Command{
+	initParams             = utils.InitParams{}
+
+	initCmd = &cobra.Command{
 		GroupID: groupLocalDev,
 		Use:     "init",
 		Short:   "Initialize a local project",
@@ -26,7 +27,7 @@ var (
 			return cmd.Root().PersistentPreRunE(cmd, args)
 		},
 		PreRun: func(cmd *cobra.Command, args []string) {
-			if useOrioleDB {
+			if initParams.UseOrioleDB {
 				cobra.CheckErr(cmd.MarkFlagRequired("experimental"))
 			}
 		},
@@ -40,7 +41,7 @@ var (
 				createIntellijSettings = nil
 			}
 
-			return _init.Run(fsys, createVscodeSettings, createIntellijSettings, useOrioleDB)
+			return _init.Run(fsys, createVscodeSettings, createIntellijSettings, initParams)
 		},
 		PostRun: func(cmd *cobra.Command, args []string) {
 			fmt.Println("Finished " + utils.Aqua("supabase init") + ".")
@@ -54,6 +55,7 @@ func init() {
 	cobra.CheckErr(flags.MarkHidden("with-vscode-workspace"))
 	flags.BoolVar(createVscodeSettings, "with-vscode-settings", false, "Generate VS Code settings for Deno.")
 	flags.BoolVar(createIntellijSettings, "with-intellij-settings", false, "Generate IntelliJ IDEA settings for Deno.")
-	flags.BoolVar(&useOrioleDB, "use-orioledb", false, "Use OrioleDB storage engine for Postgres")
+	flags.BoolVar(&initParams.UseOrioleDB, "use-orioledb", false, "Use OrioleDB storage engine for Postgres.")
+	flags.BoolVar(&initParams.Overwrite, "force", false, "Overwrite existing "+utils.ConfigPath+".")
 	rootCmd.AddCommand(initCmd)
 }

cmd/login.go

@@ -1,16 +1,9 @@
 package cmd
 
 import (
-	"bytes"
-	"fmt"
-	"io"
 	"os"
-	"os/user"
-	"strings"
-	"time"
 
 	"github.com/go-errors/errors"
-	"github.com/google/uuid"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
 	"github.com/supabase/cli/internal/login"
@@ -22,94 +15,37 @@ var (
 	ErrMissingToken = errors.Errorf("Cannot use automatic login flow inside non-TTY environments. Please provide %s flag or set the %s environment variable.", utils.Aqua("--token"), utils.Aqua("SUPABASE_ACCESS_TOKEN"))
 )
 
-func generateTokenName() (string, error) {
-	user, err := user.Current()
-	if err != nil {
-		return "", errors.Errorf("cannot retrieve username: %w", err)
-	}
-
-	hostname, err := os.Hostname()
-	if err != nil {
-		return "", errors.Errorf("cannot retrieve hostname: %w", err)
+var (
+	params = login.RunParams{
+		// Skip the browser if we are inside non-TTY environment, which is the case for any CI.
+		OpenBrowser: term.IsTerminal(int(os.Stdin.Fd())),
+		Fsys:        afero.NewOsFs(),
 	}
 
-	return fmt.Sprintf("cli_%s@%s_%d", user.Username, hostname, time.Now().Unix()), nil
-}
-
-var (
 	loginCmd = &cobra.Command{
 		GroupID: groupLocalDev,
 		Use:     "login",
 		Short:   "Authenticate using an access token",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			params := login.RunParams{
-				Fsys: afero.NewOsFs(),
-			}
-
-			if !term.IsTerminal(int(os.Stdin.Fd())) {
-				var buf bytes.Buffer
-				if _, err := io.Copy(&buf, os.Stdin); err == nil {
-					token := strings.TrimSpace(buf.String())
-					if len(token) > 0 {
-						params.Token = token
-					}
-				}
-			} else if cmd.Flags().Changed("token") {
-				token, err := cmd.Flags().GetString("token")
-				if err != nil {
-					return errors.Errorf("cannot parse 'token' flag: %w", err)
-				}
-				params.Token = token
-			} else if token := os.Getenv("SUPABASE_ACCESS_TOKEN"); token != "" {
-				params.Token = token
-			}
-
-			// Login encryption and Session ID are only required for end-to-end communication.
-			// We can skip it if token is already provided by user.
 			if params.Token == "" {
-				enc, err := login.NewLoginEncryption()
-				if err != nil {
-					return err
-				}
-				params.Encryption = enc
-				params.SessionId = uuid.New().String()
+				params.Token = login.ParseAccessToken(os.Stdin)
 			}
-
-			if !term.IsTerminal(int(os.Stdin.Fd())) && params.Token == "" {
+			if params.Token == "" && !params.OpenBrowser {
 				return ErrMissingToken
 			}
-
-			if cmd.Flags().Changed("name") {
-				name, err := cmd.Flags().GetString("name")
-				if err != nil {
-					return errors.Errorf("cannot parse 'name' flag: %w", err)
-				}
-				params.TokenName = name
-			} else {
-				name, err := generateTokenName()
-				if err != nil {
-					params.TokenName = fmt.Sprintf("cli_%d", time.Now().Unix())
-				} else {
-					params.TokenName = name
-				}
-			}
-
 			if cmd.Flags().Changed("no-browser") {
 				params.OpenBrowser = false
-			} else {
-				// Skip the browser if we are inside non-TTY environment, which is the case for any CI.
-				params.OpenBrowser = term.IsTerminal(int(os.Stdin.Fd()))
 			}
-
 			return login.Run(cmd.Context(), os.Stdout, params)
 		},
 	}
 )
 
 func init() {
 	loginFlags := loginCmd.Flags()
-	loginFlags.String("token", "", "Use provided token instead of automatic login flow")
-	loginFlags.String("name", "", "Name that will be used to store token in your settings, defaults to built-in token name generator")
+	loginFlags.StringVar(&params.Token, "token", "", "Use provided token instead of automatic login flow")
+	loginFlags.StringVar(&params.TokenName, "name", "", "Name that will be used to store token in your settings")
+	loginFlags.Lookup("name").DefValue = "built-in token name generator"
 	loginFlags.Bool("no-browser", false, "Do not open browser automatically")
 	rootCmd.AddCommand(loginCmd)
 }

cmd/projects.go

@@ -1,11 +1,8 @@
 package cmd
 
 import (
-	"errors"
-	"fmt"
 	"os"
 	"sort"
-	"strings"
 
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
@@ -58,9 +55,6 @@ var (
 			if len(args) > 0 {
 				projectName = args[0]
 			}
-			if interactive {
-				cobra.CheckErr(PromptCreateFlags(cmd))
-			}
 			return create.Run(cmd.Context(), api.CreateProjectBody{
 				Name:           projectName,
 				OrganizationId: orgId,
@@ -141,64 +135,3 @@ func init() {
 	projectsCmd.AddCommand(projectsApiKeysCmd)
 	rootCmd.AddCommand(projectsCmd)
 }
-
-func PromptCreateFlags(cmd *cobra.Command) error {
-	ctx := cmd.Context()
-	if len(projectName) > 0 {
-		fmt.Fprintln(os.Stderr, printKeyValue("Creating project", projectName))
-	} else {
-		name, err := utils.PromptText("Enter your project name: ", os.Stdin)
-		if err != nil {
-			return err
-		}
-		if len(name) == 0 {
-			return errors.New("project name cannot be empty")
-		}
-		projectName = name
-	}
-	if !cmd.Flags().Changed("org-id") {
-		title := "Which organisation do you want to create the project for?"
-		resp, err := utils.GetSupabase().GetOrganizationsWithResponse(ctx)
-		if err != nil {
-			return err
-		}
-		if resp.JSON200 == nil {
-			return errors.New("Unexpected error retrieving organizations: " + string(resp.Body))
-		}
-		items := make([]utils.PromptItem, len(*resp.JSON200))
-		for i, org := range *resp.JSON200 {
-			items[i] = utils.PromptItem{Summary: org.Name, Details: org.Id}
-		}
-		choice, err := utils.PromptChoice(ctx, title, items)
-		if err != nil {
-			return err
-		}
-		orgId = choice.Details
-	}
-	fmt.Fprintln(os.Stderr, printKeyValue("Selected org-id", orgId))
-	if !cmd.Flags().Changed("region") {
-		title := "Which region do you want to host the project in?"
-		items := make([]utils.PromptItem, len(utils.RegionMap))
-		i := 0
-		for k, v := range utils.RegionMap {
-			items[i] = utils.PromptItem{Summary: k, Details: v}
-			i++
-		}
-		choice, err := utils.PromptChoice(ctx, title, items)
-		if err != nil {
-			return err
-		}
-		region.Value = choice.Summary
-	}
-	fmt.Fprintln(os.Stderr, printKeyValue("Selected region", region.Value))
-	if dbPassword == "" {
-		dbPassword = flags.PromptPassword(os.Stdin)
-	}
-	return nil
-}
-
-func printKeyValue(key, value string) string {
-	indent := 20 - len(key)
-	spaces := strings.Repeat(" ", indent)
-	return key + ":" + spaces + value
-}