19494768794

Committed 19 Nov 2025 08:27AM UTC coverage: 55.051% (-0.03%) from 55.076%

Build # 19494768794

Build Type

Pull #4448

github

Committed by

web-flow

Commit Message

Merge 8fcb18af5 into 10cdd70c7

Pull Request Pull Request #4448: chore: sync API types from infrastructure

Run Details

4 of 10 new or added lines in 4 files covered. (40.0%)

5 existing lines in 1 file now uncovered.

6507 of 11820 relevant lines covered (55.05%)

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

supabase / cli / 19494768794

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