18438581361

Committed 12 Oct 2025 03:31AM UTC coverage: 54.641% (-0.06%) from 54.701%

Build # 18438581361

Build Type

Pull #4293

github

Committed by

web-flow

Commit Message

Merge fb164500a into 4785f7a63

Pull Request Pull Request #4293: chore: bump openapi spec and overlay

Run Details

1 of 6 new or added lines in 2 files covered. (16.67%)

8 existing lines in 2 files now uncovered.

6405 of 11722 relevant lines covered (54.64%)

6.09 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/cmd/projects.go

package cmd

import (
        "os"
        "sort"

        "github.com/spf13/afero"
        "github.com/spf13/cobra"
        "github.com/spf13/viper"
        "github.com/supabase/cli/internal/projects/apiKeys"
        "github.com/supabase/cli/internal/projects/create"
        "github.com/supabase/cli/internal/projects/delete"
        "github.com/supabase/cli/internal/projects/list"
        "github.com/supabase/cli/internal/utils"
        "github.com/supabase/cli/internal/utils/flags"
        "github.com/supabase/cli/pkg/api"
        "github.com/supabase/cli/pkg/cast"
        "golang.org/x/term"
)

var (
        projectsCmd = &cobra.Command{
                GroupID: groupManagementAPI,
                Use:     "projects",
                Short:   "Manage Supabase projects",
        }

        interactive bool
        projectName string
        orgId       string
        dbPassword  string

        region = utils.EnumFlag{
                Allowed: awsRegions(),
        }
        size = utils.EnumFlag{
                Allowed: []string{
                        string(api.V1CreateProjectBodyDesiredInstanceSizeLarge),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeMedium),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeMicro),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeN12xlarge),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeN16xlarge),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeN24xlarge),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeN24xlargeHighMemory),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeN24xlargeOptimizedCpu),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeN24xlargeOptimizedMemory),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeN2xlarge),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeN48xlarge),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeN48xlargeHighMemory),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeN48xlargeOptimizedCpu),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeN48xlargeOptimizedMemory),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeN4xlarge),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeN8xlarge),
                        string(api.V1CreateProjectBodyDesiredInstanceSizePico),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeSmall),
                        string(api.V1CreateProjectBodyDesiredInstanceSizeXlarge),
                },
        }

        projectsCreateCmd = &cobra.Command{
                Use:     "create [project name]",
                Short:   "Create a project on Supabase",
                Args:    cobra.MaximumNArgs(1),
                Example: `supabase projects create my-project --org-id cool-green-pqdr0qc --db-password ******** --region us-east-1`,
                PreRunE: func(cmd *cobra.Command, args []string) error {
                        if !term.IsTerminal(int(os.Stdin.Fd())) || !interactive {
                                cobra.CheckErr(cmd.MarkFlagRequired("org-id"))
                                cobra.CheckErr(cmd.MarkFlagRequired("db-password"))
                                cobra.CheckErr(cmd.MarkFlagRequired("region"))
                                return cobra.ExactArgs(1)(cmd, args)
                        }
                        return nil
                },
                RunE: func(cmd *cobra.Command, args []string) error {
                        if len(args) > 0 {
                                projectName = args[0]
                        }
                        body := api.V1CreateProjectBody{
                                Name:           projectName,
                                OrganizationId: orgId,
                                DbPass:         dbPassword,
                                Region:         cast.Ptr(api.V1CreateProjectBodyRegion(region.Value)),
                        }
                        if cmd.Flags().Changed("size") {
                                body.DesiredInstanceSize = (*api.V1CreateProjectBodyDesiredInstanceSize)(&size.Value)
                        }
                        return create.Run(cmd.Context(), body, afero.NewOsFs())
                },
        }

        projectsListCmd = &cobra.Command{
                Use:   "list",
                Short: "List all Supabase projects",
                Long:  "List all Supabase projects the logged-in user can access.",
                RunE: func(cmd *cobra.Command, args []string) error {
                        return list.Run(cmd.Context(), afero.NewOsFs())
                },
        }

        projectsApiKeysCmd = &cobra.Command{
                Use:   "api-keys",
                Short: "List all API keys for a Supabase project",
                RunE: func(cmd *cobra.Command, args []string) error {
                        return apiKeys.Run(cmd.Context(), flags.ProjectRef, afero.NewOsFs())
                },
        }

        projectsDeleteCmd = &cobra.Command{
                Use:   "delete [ref]",
                Short: "Delete a Supabase project",
                Args:  cobra.MaximumNArgs(1),
                PreRunE: func(cmd *cobra.Command, args []string) error {
                        if !term.IsTerminal(int(os.Stdin.Fd())) {
                                return cobra.ExactArgs(1)(cmd, args)
                        }
                        return nil
                },
                RunE: func(cmd *cobra.Command, args []string) error {
                        ctx := cmd.Context()
                        if len(args) == 0 {
                                title := "Which project do you want to delete?"
                                cobra.CheckErr(flags.PromptProjectRef(ctx, title))
                        } else {
                                flags.ProjectRef = args[0]
                        }
                        if err := delete.PreRun(ctx, flags.ProjectRef); err != nil {
                                return err
                        }
                        return delete.Run(ctx, flags.ProjectRef, afero.NewOsFs())
                },
        }
)

func init() {
        // Add flags to cobra command
        createFlags := projectsCreateCmd.Flags()
        createFlags.BoolVarP(&interactive, "interactive", "i", true, "Enables interactive mode.")
        cobra.CheckErr(createFlags.MarkHidden("interactive"))
        createFlags.StringVar(&orgId, "org-id", "", "Organization ID to create the project in.")
        createFlags.StringVar(&dbPassword, "db-password", "", "Database password of the project.")
        createFlags.Var(&region, "region", "Select a region close to you for the best performance.")
        createFlags.String("plan", "", "Select a plan that suits your needs.")
        cobra.CheckErr(createFlags.MarkHidden("plan"))
        createFlags.Var(&size, "size", "Select a desired instance size for your project.")
        cobra.CheckErr(viper.BindPFlag("DB_PASSWORD", createFlags.Lookup("db-password")))

        apiKeysFlags := projectsApiKeysCmd.Flags()
        apiKeysFlags.StringVar(&flags.ProjectRef, "project-ref", "", "Project ref of the Supabase project.")

        // Add commands to root
        projectsCmd.AddCommand(projectsCreateCmd)
        projectsCmd.AddCommand(projectsDeleteCmd)
        projectsCmd.AddCommand(projectsListCmd)
        projectsCmd.AddCommand(projectsApiKeysCmd)
        rootCmd.AddCommand(projectsCmd)
}

func awsRegions() []string {
        result := make([]string, len(utils.RegionMap))
        i := 0
        for k := range utils.RegionMap {
                result[i] = k
                i++
        }
        sort.Strings(result)
        return result
}

1	package cmd
2
3	import (
4	"os"
5	"sort"
6
7	"github.com/spf13/afero"
8	"github.com/spf13/cobra"
9	"github.com/spf13/viper"
10	"github.com/supabase/cli/internal/projects/apiKeys"
11	"github.com/supabase/cli/internal/projects/create"
12	"github.com/supabase/cli/internal/projects/delete"
13	"github.com/supabase/cli/internal/projects/list"
14	"github.com/supabase/cli/internal/utils"
15	"github.com/supabase/cli/internal/utils/flags"
16	"github.com/supabase/cli/pkg/api"
17	"github.com/supabase/cli/pkg/cast"
18	"golang.org/x/term"
19	)
20
21	var (
22	projectsCmd = &cobra.Command{
23	GroupID: groupManagementAPI,
24	Use: "projects",
25	Short: "Manage Supabase projects",
26	}
27
28	interactive bool
29	projectName string
30	orgId string
31	dbPassword string
32
33	region = utils.EnumFlag{
34	Allowed: awsRegions(),
35	}
36	size = utils.EnumFlag{
37	Allowed: []string{
38	string(api.V1CreateProjectBodyDesiredInstanceSizeLarge),
39	string(api.V1CreateProjectBodyDesiredInstanceSizeMedium),
40	string(api.V1CreateProjectBodyDesiredInstanceSizeMicro),
41	string(api.V1CreateProjectBodyDesiredInstanceSizeN12xlarge),
42	string(api.V1CreateProjectBodyDesiredInstanceSizeN16xlarge),
43	string(api.V1CreateProjectBodyDesiredInstanceSizeN24xlarge),
44	string(api.V1CreateProjectBodyDesiredInstanceSizeN24xlargeHighMemory),
45	string(api.V1CreateProjectBodyDesiredInstanceSizeN24xlargeOptimizedCpu),
46	string(api.V1CreateProjectBodyDesiredInstanceSizeN24xlargeOptimizedMemory),
47	string(api.V1CreateProjectBodyDesiredInstanceSizeN2xlarge),
48	string(api.V1CreateProjectBodyDesiredInstanceSizeN48xlarge),
49	string(api.V1CreateProjectBodyDesiredInstanceSizeN48xlargeHighMemory),
50	string(api.V1CreateProjectBodyDesiredInstanceSizeN48xlargeOptimizedCpu),
51	string(api.V1CreateProjectBodyDesiredInstanceSizeN48xlargeOptimizedMemory),
52	string(api.V1CreateProjectBodyDesiredInstanceSizeN4xlarge),
53	string(api.V1CreateProjectBodyDesiredInstanceSizeN8xlarge),
54	string(api.V1CreateProjectBodyDesiredInstanceSizePico),
55	string(api.V1CreateProjectBodyDesiredInstanceSizeSmall),
56	string(api.V1CreateProjectBodyDesiredInstanceSizeXlarge),
57	},
58	}
59
60	projectsCreateCmd = &cobra.Command{
61	Use: "create [project name]",
62	Short: "Create a project on Supabase",
63	Args: cobra.MaximumNArgs(1),
64	Example: `supabase projects create my-project --org-id cool-green-pqdr0qc --db-password ******** --region us-east-1`,
65	PreRunE: func(cmd *cobra.Command, args []string) error {	×
66	if !term.IsTerminal(int(os.Stdin.Fd())) \|\| !interactive {	×
67	cobra.CheckErr(cmd.MarkFlagRequired("org-id"))	×
68	cobra.CheckErr(cmd.MarkFlagRequired("db-password"))	×
69	cobra.CheckErr(cmd.MarkFlagRequired("region"))	×
70	return cobra.ExactArgs(1)(cmd, args)	×
71	}	×
72	return nil	×
73	},
74	RunE: func(cmd *cobra.Command, args []string) error {	×
75	if len(args) > 0 {	×
76	projectName = args[0]	×
77	}	×
78	body := api.V1CreateProjectBody{	×
79	Name: projectName,	×
80	OrganizationId: orgId,	×
81	DbPass: dbPassword,	×
NEW 82	Region: cast.Ptr(api.V1CreateProjectBodyRegion(region.Value)),	×
83	}	×
84	if cmd.Flags().Changed("size") {	×
85	body.DesiredInstanceSize = (*api.V1CreateProjectBodyDesiredInstanceSize)(&size.Value)	×
86	}	×
87	return create.Run(cmd.Context(), body, afero.NewOsFs())	×
88	},
89	}
90
91	projectsListCmd = &cobra.Command{
92	Use: "list",
93	Short: "List all Supabase projects",
94	Long: "List all Supabase projects the logged-in user can access.",
95	RunE: func(cmd *cobra.Command, args []string) error {	×
96	return list.Run(cmd.Context(), afero.NewOsFs())	×
97	},	×
98	}
99
100	projectsApiKeysCmd = &cobra.Command{
101	Use: "api-keys",
102	Short: "List all API keys for a Supabase project",
103	RunE: func(cmd *cobra.Command, args []string) error {	×
104	return apiKeys.Run(cmd.Context(), flags.ProjectRef, afero.NewOsFs())	×
105	},	×
106	}
107
108	projectsDeleteCmd = &cobra.Command{
109	Use: "delete [ref]",
110	Short: "Delete a Supabase project",
111	Args: cobra.MaximumNArgs(1),
112	PreRunE: func(cmd *cobra.Command, args []string) error {	×
113	if !term.IsTerminal(int(os.Stdin.Fd())) {	×
114	return cobra.ExactArgs(1)(cmd, args)	×
115	}	×
116	return nil	×
117	},
118	RunE: func(cmd *cobra.Command, args []string) error {	×
119	ctx := cmd.Context()	×
120	if len(args) == 0 {	×
121	title := "Which project do you want to delete?"	×
122	cobra.CheckErr(flags.PromptProjectRef(ctx, title))	×
123	} else {	×
124	flags.ProjectRef = args[0]	×
125	}	×
126	if err := delete.PreRun(ctx, flags.ProjectRef); err != nil {	×
127	return err	×
128	}	×
129	return delete.Run(ctx, flags.ProjectRef, afero.NewOsFs())	×
130	},
131	}
132	)
133
134	func init() {	×
135	// Add flags to cobra command	×
136	createFlags := projectsCreateCmd.Flags()	×
137	createFlags.BoolVarP(&interactive, "interactive", "i", true, "Enables interactive mode.")	×
138	cobra.CheckErr(createFlags.MarkHidden("interactive"))	×
139	createFlags.StringVar(&orgId, "org-id", "", "Organization ID to create the project in.")	×
140	createFlags.StringVar(&dbPassword, "db-password", "", "Database password of the project.")	×
141	createFlags.Var(&region, "region", "Select a region close to you for the best performance.")	×
142	createFlags.String("plan", "", "Select a plan that suits your needs.")	×
143	cobra.CheckErr(createFlags.MarkHidden("plan"))	×
144	createFlags.Var(&size, "size", "Select a desired instance size for your project.")	×
145	cobra.CheckErr(viper.BindPFlag("DB_PASSWORD", createFlags.Lookup("db-password")))	×
146		×
147	apiKeysFlags := projectsApiKeysCmd.Flags()	×
148	apiKeysFlags.StringVar(&flags.ProjectRef, "project-ref", "", "Project ref of the Supabase project.")	×
149		×
150	// Add commands to root	×
151	projectsCmd.AddCommand(projectsCreateCmd)	×
152	projectsCmd.AddCommand(projectsDeleteCmd)	×
153	projectsCmd.AddCommand(projectsListCmd)	×
154	projectsCmd.AddCommand(projectsApiKeysCmd)	×
155	rootCmd.AddCommand(projectsCmd)	×
156	}	×
157
158	func awsRegions() []string {	×
159	result := make([]string, len(utils.RegionMap))	×
160	i := 0	×
161	for k := range utils.RegionMap {	×
162	result[i] = k	×
163	i++	×
164	}	×
165	sort.Strings(result)	×
166	return result	×
167	}

supabase / cli / 18438581361

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous