19699968033

Committed 26 Nov 2025 10:07AM UTC coverage: 54.995% (-0.4%) from 55.403%

Build # 19699968033

Build Type

Pull #4368

github

Committed by

web-flow

Commit Message

Merge b6a3e01eb into 6558d59e6

Pull Request Pull Request #4368: feat: add deploy command to push all changes to linked project

Run Details

45 of 181 new or added lines in 10 files covered. (24.86%)

15 existing lines in 2 files now uncovered.

6705 of 12192 relevant lines covered (55.0%)

6.2 hits per line

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

0.0

/cmd/functions.go

package cmd

import (
        "fmt"
        "os"

        "github.com/go-errors/errors"
        "github.com/spf13/afero"
        "github.com/spf13/cobra"
        "github.com/supabase/cli/internal/functions/delete"
        "github.com/supabase/cli/internal/functions/deploy"
        "github.com/supabase/cli/internal/functions/download"
        "github.com/supabase/cli/internal/functions/list"
        new_ "github.com/supabase/cli/internal/functions/new"
        "github.com/supabase/cli/internal/functions/serve"
        "github.com/supabase/cli/internal/utils"
        "github.com/supabase/cli/internal/utils/flags"
        "github.com/supabase/cli/pkg/cast"
)

var (
        functionsCmd = &cobra.Command{
                GroupID: groupManagementAPI,
                Use:     "functions",
                Short:   "Manage Supabase Edge functions",
        }

        functionsListCmd = &cobra.Command{
                Use:   "list",
                Short: "List all Functions in Supabase",
                Long:  "List all Functions in the linked Supabase project.",
                RunE: func(cmd *cobra.Command, args []string) error {
                        return list.Run(cmd.Context(), flags.ProjectRef, afero.NewOsFs())
                },
        }

        functionsDeleteCmd = &cobra.Command{
                Use:   "delete <Function name>",
                Short: "Delete a Function from Supabase",
                Long:  "Delete a Function from the linked Supabase project. This does NOT remove the Function locally.",
                Args:  cobra.ExactArgs(1),
                RunE: func(cmd *cobra.Command, args []string) error {
                        return delete.Run(cmd.Context(), args[0], flags.ProjectRef, afero.NewOsFs())
                },
        }

        functionsDownloadCmd = &cobra.Command{
                Use:   "download <Function name>",
                Short: "Download a Function from Supabase",
                Long:  "Download the source code for a Function from the linked Supabase project.",
                Args:  cobra.ExactArgs(1),
                RunE: func(cmd *cobra.Command, args []string) error {
                        if useApi {
                                useDocker = false
                        }
                        return download.Run(cmd.Context(), args[0], flags.ProjectRef, useLegacyBundle, useDocker, afero.NewOsFs())
                },
        }

        useApi          bool
        useDocker       bool
        useLegacyBundle bool
        noVerifyJWT     = new(bool)
        importMapPath   string
        prune           bool
        functionsDryRun bool

        functionsDeployCmd = &cobra.Command{
                Use:   "deploy [Function name]",
                Short: "Deploy a Function to Supabase",
                Long:  "Deploy a Function to the linked Supabase project.",
                RunE: func(cmd *cobra.Command, args []string) error {
                        // Fallback to config if user did not set the flag.
                        if !cmd.Flags().Changed("no-verify-jwt") {
                                noVerifyJWT = nil
                        }
                        if useApi {
                                useDocker = false
                        } else if maxJobs > 1 {
                                return errors.New("--jobs must be used together with --use-api")
                        }
                        keep := func(name string) bool {
                                if functionsDryRun {
                                        fmt.Fprintln(os.Stderr, "Would deploy:", name)
                                        return false
                                }
                                return true
                        }
                        return deploy.Run(cmd.Context(), args, useDocker, noVerifyJWT, importMapPath, maxJobs, prune, afero.NewOsFs(), keep)
                },
        }

        functionsNewCmd = &cobra.Command{
                Use:   "new <Function name>",
                Short: "Create a new Function locally",
                Args:  cobra.ExactArgs(1),
                PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
                        cmd.GroupID = groupLocalDev
                        return cmd.Root().PersistentPreRunE(cmd, args)
                },
                RunE: func(cmd *cobra.Command, args []string) error {
                        return new_.Run(cmd.Context(), args[0], afero.NewOsFs())
                },
        }

        envFilePath string
        inspectBrk  bool
        inspectMode = utils.EnumFlag{
                Allowed: []string{
                        string(serve.InspectModeRun),
                        string(serve.InspectModeBrk),
                        string(serve.InspectModeWait),
                },
        }
        runtimeOption serve.RuntimeOption

        functionsServeCmd = &cobra.Command{
                Use:   "serve",
                Short: "Serve all Functions locally",
                PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
                        cmd.GroupID = groupLocalDev
                        return cmd.Root().PersistentPreRunE(cmd, args)
                },
                RunE: func(cmd *cobra.Command, args []string) error {
                        // Fallback to config if user did not set the flag.
                        if !cmd.Flags().Changed("no-verify-jwt") {
                                noVerifyJWT = nil
                        }

                        if len(inspectMode.Value) > 0 {
                                runtimeOption.InspectMode = cast.Ptr(serve.InspectMode(inspectMode.Value))
                        } else if inspectBrk {
                                runtimeOption.InspectMode = cast.Ptr(serve.InspectModeBrk)
                        }
                        if runtimeOption.InspectMode == nil && runtimeOption.InspectMain {
                                return fmt.Errorf("--inspect-main must be used together with one of these flags: [inspect inspect-mode]")
                        }

                        return serve.Run(cmd.Context(), envFilePath, noVerifyJWT, importMapPath, runtimeOption, afero.NewOsFs())
                },
        }
)

func init() {
        functionsListCmd.Flags().StringVar(&flags.ProjectRef, "project-ref", "", "Project ref of the Supabase project.")
        functionsDeleteCmd.Flags().StringVar(&flags.ProjectRef, "project-ref", "", "Project ref of the Supabase project.")
        deployFlags := functionsDeployCmd.Flags()
        deployFlags.BoolVar(&useApi, "use-api", false, "Bundle functions server-side without using Docker.")
        deployFlags.BoolVar(&useDocker, "use-docker", true, "Use Docker to bundle functions.")
        deployFlags.BoolVar(&useLegacyBundle, "legacy-bundle", false, "Use legacy bundling mechanism.")
        functionsDeployCmd.MarkFlagsMutuallyExclusive("use-api", "use-docker", "legacy-bundle")
        cobra.CheckErr(deployFlags.MarkHidden("legacy-bundle"))
        cobra.CheckErr(deployFlags.MarkHidden("use-docker"))
        deployFlags.UintVarP(&maxJobs, "jobs", "j", 1, "Maximum number of parallel jobs.")
        deployFlags.BoolVar(noVerifyJWT, "no-verify-jwt", false, "Disable JWT verification for the Function.")
        deployFlags.BoolVar(&prune, "prune", false, "Delete Functions that exist in Supabase project but not locally.")
        deployFlags.BoolVar(&functionsDryRun, "dry-run", false, "Print operations that would be performed without executing them.")
        deployFlags.StringVar(&flags.ProjectRef, "project-ref", "", "Project ref of the Supabase project.")
        deployFlags.StringVar(&importMapPath, "import-map", "", "Path to import map file.")
        functionsServeCmd.Flags().BoolVar(noVerifyJWT, "no-verify-jwt", false, "Disable JWT verification for the Function.")
        functionsServeCmd.Flags().StringVar(&envFilePath, "env-file", "", "Path to an env file to be populated to the Function environment.")
        functionsServeCmd.Flags().StringVar(&importMapPath, "import-map", "", "Path to import map file.")
        functionsServeCmd.Flags().BoolVar(&inspectBrk, "inspect", false, "Alias of --inspect-mode brk.")
        functionsServeCmd.Flags().Var(&inspectMode, "inspect-mode", "Activate inspector capability for debugging.")
        functionsServeCmd.Flags().BoolVar(&runtimeOption.InspectMain, "inspect-main", false, "Allow inspecting the main worker.")
        functionsServeCmd.MarkFlagsMutuallyExclusive("inspect", "inspect-mode")
        functionsServeCmd.Flags().Bool("all", true, "Serve all Functions.")
        cobra.CheckErr(functionsServeCmd.Flags().MarkHidden("all"))
        downloadFlags := functionsDownloadCmd.Flags()
        downloadFlags.StringVar(&flags.ProjectRef, "project-ref", "", "Project ref of the Supabase project.")
        downloadFlags.BoolVar(&useLegacyBundle, "legacy-bundle", false, "Use legacy bundling mechanism.")
        downloadFlags.BoolVar(&useApi, "use-api", false, "Unbundle functions server-side without using Docker.")
        downloadFlags.BoolVar(&useDocker, "use-docker", true, "Use Docker to unbundle functions client-side.")
        functionsDownloadCmd.MarkFlagsMutuallyExclusive("use-api", "use-docker", "legacy-bundle")
        cobra.CheckErr(downloadFlags.MarkHidden("legacy-bundle"))
        cobra.CheckErr(downloadFlags.MarkHidden("use-docker"))
        functionsCmd.AddCommand(functionsListCmd)
        functionsCmd.AddCommand(functionsDeleteCmd)
        functionsCmd.AddCommand(functionsDeployCmd)
        functionsCmd.AddCommand(functionsNewCmd)
        functionsCmd.AddCommand(functionsServeCmd)
        functionsCmd.AddCommand(functionsDownloadCmd)
        rootCmd.AddCommand(functionsCmd)
}

1	package cmd
2
3	import (
4	"fmt"
5	"os"
6
7	"github.com/go-errors/errors"
8	"github.com/spf13/afero"
9	"github.com/spf13/cobra"
10	"github.com/supabase/cli/internal/functions/delete"
11	"github.com/supabase/cli/internal/functions/deploy"
12	"github.com/supabase/cli/internal/functions/download"
13	"github.com/supabase/cli/internal/functions/list"
14	new_ "github.com/supabase/cli/internal/functions/new"
15	"github.com/supabase/cli/internal/functions/serve"
16	"github.com/supabase/cli/internal/utils"
17	"github.com/supabase/cli/internal/utils/flags"
18	"github.com/supabase/cli/pkg/cast"
19	)
20
21	var (
22	functionsCmd = &cobra.Command{
23	GroupID: groupManagementAPI,
24	Use: "functions",
25	Short: "Manage Supabase Edge functions",
26	}
27
28	functionsListCmd = &cobra.Command{
29	Use: "list",
30	Short: "List all Functions in Supabase",
31	Long: "List all Functions in the linked Supabase project.",
32	RunE: func(cmd *cobra.Command, args []string) error {	×
33	return list.Run(cmd.Context(), flags.ProjectRef, afero.NewOsFs())	×
34	},	×
35	}
36
37	functionsDeleteCmd = &cobra.Command{
38	Use: "delete <Function name>",
39	Short: "Delete a Function from Supabase",
40	Long: "Delete a Function from the linked Supabase project. This does NOT remove the Function locally.",
41	Args: cobra.ExactArgs(1),
42	RunE: func(cmd *cobra.Command, args []string) error {	×
43	return delete.Run(cmd.Context(), args[0], flags.ProjectRef, afero.NewOsFs())	×
44	},	×
45	}
46
47	functionsDownloadCmd = &cobra.Command{
48	Use: "download <Function name>",
49	Short: "Download a Function from Supabase",
50	Long: "Download the source code for a Function from the linked Supabase project.",
51	Args: cobra.ExactArgs(1),
52	RunE: func(cmd *cobra.Command, args []string) error {	×
53	if useApi {	×
54	useDocker = false	×
55	}	×
56	return download.Run(cmd.Context(), args[0], flags.ProjectRef, useLegacyBundle, useDocker, afero.NewOsFs())	×
57	},
58	}
59
60	useApi bool
61	useDocker bool
62	useLegacyBundle bool
63	noVerifyJWT = new(bool)
64	importMapPath string
65	prune bool
66	functionsDryRun bool
67
68	functionsDeployCmd = &cobra.Command{
69	Use: "deploy [Function name]",
70	Short: "Deploy a Function to Supabase",
71	Long: "Deploy a Function to the linked Supabase project.",
72	RunE: func(cmd *cobra.Command, args []string) error {	×
73	// Fallback to config if user did not set the flag.	×
74	if !cmd.Flags().Changed("no-verify-jwt") {	×
75	noVerifyJWT = nil	×
76	}	×
77	if useApi {	×
78	useDocker = false	×
79	} else if maxJobs > 1 {	×
80	return errors.New("--jobs must be used together with --use-api")	×
81	}	×
NEW 82	keep := func(name string) bool {	×
NEW 83	if functionsDryRun {	×
NEW 84	fmt.Fprintln(os.Stderr, "Would deploy:", name)	×
NEW 85	return false	×
NEW 86	}	×
NEW 87	return true	×
88	}
NEW 89	return deploy.Run(cmd.Context(), args, useDocker, noVerifyJWT, importMapPath, maxJobs, prune, afero.NewOsFs(), keep)	×
90	},
91	}
92
93	functionsNewCmd = &cobra.Command{
94	Use: "new <Function name>",
95	Short: "Create a new Function locally",
96	Args: cobra.ExactArgs(1),
97	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {	×
98	cmd.GroupID = groupLocalDev	×
99	return cmd.Root().PersistentPreRunE(cmd, args)	×
100	},	×
101	RunE: func(cmd *cobra.Command, args []string) error {	×
102	return new_.Run(cmd.Context(), args[0], afero.NewOsFs())	×
103	},	×
104	}
105
106	envFilePath string
107	inspectBrk bool
108	inspectMode = utils.EnumFlag{
109	Allowed: []string{
110	string(serve.InspectModeRun),
111	string(serve.InspectModeBrk),
112	string(serve.InspectModeWait),
113	},
114	}
115	runtimeOption serve.RuntimeOption
116
117	functionsServeCmd = &cobra.Command{
118	Use: "serve",
119	Short: "Serve all Functions locally",
120	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {	×
121	cmd.GroupID = groupLocalDev	×
122	return cmd.Root().PersistentPreRunE(cmd, args)	×
123	},	×
124	RunE: func(cmd *cobra.Command, args []string) error {	×
125	// Fallback to config if user did not set the flag.	×
126	if !cmd.Flags().Changed("no-verify-jwt") {	×
127	noVerifyJWT = nil	×
128	}	×
129
130	if len(inspectMode.Value) > 0 {	×
131	runtimeOption.InspectMode = cast.Ptr(serve.InspectMode(inspectMode.Value))	×
132	} else if inspectBrk {	×
133	runtimeOption.InspectMode = cast.Ptr(serve.InspectModeBrk)	×
134	}	×
135	if runtimeOption.InspectMode == nil && runtimeOption.InspectMain {	×
136	return fmt.Errorf("--inspect-main must be used together with one of these flags: [inspect inspect-mode]")	×
137	}	×
138
139	return serve.Run(cmd.Context(), envFilePath, noVerifyJWT, importMapPath, runtimeOption, afero.NewOsFs())	×
140	},
141	}
142	)
143
144	func init() {	×
145	functionsListCmd.Flags().StringVar(&flags.ProjectRef, "project-ref", "", "Project ref of the Supabase project.")	×
146	functionsDeleteCmd.Flags().StringVar(&flags.ProjectRef, "project-ref", "", "Project ref of the Supabase project.")	×
147	deployFlags := functionsDeployCmd.Flags()	×
148	deployFlags.BoolVar(&useApi, "use-api", false, "Bundle functions server-side without using Docker.")	×
149	deployFlags.BoolVar(&useDocker, "use-docker", true, "Use Docker to bundle functions.")	×
150	deployFlags.BoolVar(&useLegacyBundle, "legacy-bundle", false, "Use legacy bundling mechanism.")	×
151	functionsDeployCmd.MarkFlagsMutuallyExclusive("use-api", "use-docker", "legacy-bundle")	×
152	cobra.CheckErr(deployFlags.MarkHidden("legacy-bundle"))	×
153	cobra.CheckErr(deployFlags.MarkHidden("use-docker"))	×
154	deployFlags.UintVarP(&maxJobs, "jobs", "j", 1, "Maximum number of parallel jobs.")	×
155	deployFlags.BoolVar(noVerifyJWT, "no-verify-jwt", false, "Disable JWT verification for the Function.")	×
156	deployFlags.BoolVar(&prune, "prune", false, "Delete Functions that exist in Supabase project but not locally.")	×
NEW 157	deployFlags.BoolVar(&functionsDryRun, "dry-run", false, "Print operations that would be performed without executing them.")	×
158	deployFlags.StringVar(&flags.ProjectRef, "project-ref", "", "Project ref of the Supabase project.")	×
159	deployFlags.StringVar(&importMapPath, "import-map", "", "Path to import map file.")	×
160	functionsServeCmd.Flags().BoolVar(noVerifyJWT, "no-verify-jwt", false, "Disable JWT verification for the Function.")	×
161	functionsServeCmd.Flags().StringVar(&envFilePath, "env-file", "", "Path to an env file to be populated to the Function environment.")	×
162	functionsServeCmd.Flags().StringVar(&importMapPath, "import-map", "", "Path to import map file.")	×
163	functionsServeCmd.Flags().BoolVar(&inspectBrk, "inspect", false, "Alias of --inspect-mode brk.")	×
164	functionsServeCmd.Flags().Var(&inspectMode, "inspect-mode", "Activate inspector capability for debugging.")	×
165	functionsServeCmd.Flags().BoolVar(&runtimeOption.InspectMain, "inspect-main", false, "Allow inspecting the main worker.")	×
166	functionsServeCmd.MarkFlagsMutuallyExclusive("inspect", "inspect-mode")	×
167	functionsServeCmd.Flags().Bool("all", true, "Serve all Functions.")	×
168	cobra.CheckErr(functionsServeCmd.Flags().MarkHidden("all"))	×
169	downloadFlags := functionsDownloadCmd.Flags()	×
170	downloadFlags.StringVar(&flags.ProjectRef, "project-ref", "", "Project ref of the Supabase project.")	×
171	downloadFlags.BoolVar(&useLegacyBundle, "legacy-bundle", false, "Use legacy bundling mechanism.")	×
172	downloadFlags.BoolVar(&useApi, "use-api", false, "Unbundle functions server-side without using Docker.")	×
173	downloadFlags.BoolVar(&useDocker, "use-docker", true, "Use Docker to unbundle functions client-side.")	×
174	functionsDownloadCmd.MarkFlagsMutuallyExclusive("use-api", "use-docker", "legacy-bundle")	×
175	cobra.CheckErr(downloadFlags.MarkHidden("legacy-bundle"))	×
176	cobra.CheckErr(downloadFlags.MarkHidden("use-docker"))	×
177	functionsCmd.AddCommand(functionsListCmd)	×
178	functionsCmd.AddCommand(functionsDeleteCmd)	×
179	functionsCmd.AddCommand(functionsDeployCmd)	×
180	functionsCmd.AddCommand(functionsNewCmd)	×
181	functionsCmd.AddCommand(functionsServeCmd)	×
182	functionsCmd.AddCommand(functionsDownloadCmd)	×
183	rootCmd.AddCommand(functionsCmd)	×
184	}	×

supabase / cli / 19699968033

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