12001912209

Committed 25 Nov 2024 02:09AM UTC coverage: 59.524% (-0.03%) from 59.552%

Build # 12001912209

Build Type

Pull #2906

github

Committed by

sweatybridge

Commit Message

chore: revert to single quote

Pull Request Pull Request #2906: chore: update api/beta.yaml from staging v1-yaml

Run Details

8 of 14 new or added lines in 7 files covered. (57.14%)

5 existing lines in 1 file now uncovered.

6381 of 10720 relevant lines covered (59.52%)

6.05 hits per line

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

41.56

/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"
        "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(),
        }
        plan = utils.EnumFlag{
                Allowed: []string{string(api.V1CreateProjectBodyDtoPlanFree), string(api.V1CreateProjectBodyDtoPlanPro)},
                Value:   string(api.V1CreateProjectBodyDtoPlanFree),
        }
        size = utils.EnumFlag{
                Allowed: []string{
                        string(api.DesiredInstanceSizeMicro),
                        string(api.DesiredInstanceSizeSmall),
                        string(api.DesiredInstanceSizeMedium),
                        string(api.DesiredInstanceSizeLarge),
                        string(api.DesiredInstanceSizeXlarge),
                        string(api.DesiredInstanceSizeN2xlarge),
                        string(api.DesiredInstanceSizeN4xlarge),
                        string(api.DesiredInstanceSizeN8xlarge),
                        string(api.DesiredInstanceSizeN12xlarge),
                        string(api.DesiredInstanceSizeN16xlarge),
                },
        }

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

supabase / cli / 12001912209

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