8998328342

Committed 08 May 2024 07:59AM UTC coverage: 57.396% (-0.07%) from 57.468%

Build Type

github

Committed by

Commit Message

fix: add send sms hook as test

Pull Request Pull Request #2129: feat: add HTTP hook Secret Configuration

Run Details

26 of 56 new or added lines in 2 files covered. (46.43%)

10 existing lines in 3 files now uncovered.

6402 of 11154 relevant lines covered (57.4%)

656.46 hits per line

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

90.48

/internal/storage/rm/rm.go

package rm

import (
        "context"
        "fmt"
        "os"
        "strings"

        "github.com/go-errors/errors"
        "github.com/spf13/afero"
        "github.com/supabase/cli/internal/storage/client"
        "github.com/supabase/cli/internal/storage/cp"
        "github.com/supabase/cli/internal/storage/ls"
        "github.com/supabase/cli/internal/utils"
        "github.com/supabase/cli/internal/utils/flags"
        "github.com/supabase/cli/pkg/storage"
)

var (
        errMissingObject = errors.New("Object not found")
        errMissingBucket = errors.New("You must specify a bucket to delete.")
        errMissingFlag   = errors.New("You must specify -r flag to delete directories.")
)

type PrefixGroup struct {
        Bucket   string
        Prefixes []string
}

func Run(ctx context.Context, paths []string, recursive bool, fsys afero.Fs) error {
        // Group paths by buckets
        groups := map[string][]string{}
        for _, objectPath := range paths {
                remotePath, err := client.ParseStorageURL(objectPath)
                if err != nil {
                        return err
                }
                bucket, prefix := client.SplitBucketPrefix(remotePath)
                // Ignore attempts to delete all buckets
                if len(bucket) == 0 {
                        return errors.New(errMissingBucket)
                }
                if cp.IsDir(prefix) && !recursive {
                        return errors.New(errMissingFlag)
                }
                groups[bucket] = append(groups[bucket], prefix)
        }
        api, err := client.NewStorageAPI(ctx, flags.ProjectRef)
        if err != nil {
                return err
        }
        for bucket, prefixes := range groups {
                confirm := fmt.Sprintf("Confirm deleting files in bucket %v?", utils.Bold(bucket))
                if shouldDelete := utils.NewConsole().PromptYesNo(confirm, false); !shouldDelete {
                        continue
                }
                // Always try deleting first in case the paths resolve to extensionless files
                fmt.Fprintln(os.Stderr, "Deleting objects:", prefixes)
                removed, err := api.DeleteObjects(ctx, bucket, prefixes)
                if err != nil {
                        return err
                }
                set := map[string]struct{}{}
                for _, object := range removed {
                        set[object.Name] = struct{}{}
                }
                for _, prefix := range prefixes {
                        if _, ok := set[prefix]; ok {
                                continue
                        }
                        if !recursive {
                                fmt.Fprintln(os.Stderr, "Object not found:", prefix)
                                continue
                        }
                        if len(prefix) > 0 {
                                prefix += "/"
                        }
                        if err := RemoveStoragePathAll(ctx, api, bucket, prefix); err != nil {
                                return err
                        }
                }
        }
        return nil
}

// Expects prefix to be terminated by "/" or ""
func RemoveStoragePathAll(ctx context.Context, api storage.StorageAPI, bucket, prefix string) error {
        // We must remove one directory at a time to avoid breaking pagination result
        queue := make([]string, 0)
        queue = append(queue, prefix)
        for len(queue) > 0 {
                dirPrefix := queue[len(queue)-1]
                queue = queue[:len(queue)-1]
                paths, err := ls.ListStoragePaths(ctx, api, fmt.Sprintf("/%s/%s", bucket, dirPrefix))
                if err != nil {
                        return err
                }
                if len(paths) == 0 && len(prefix) > 0 {
                        return errors.Errorf("%w: %s/%s", errMissingObject, bucket, prefix)
                }
                var files []string
                for _, objectName := range paths {
                        objectPrefix := dirPrefix + objectName
                        if strings.HasSuffix(objectName, "/") {
                                queue = append(queue, objectPrefix)
                        } else {
                                files = append(files, objectPrefix)
                        }
                }
                if len(files) > 0 {
                        fmt.Fprintln(os.Stderr, "Deleting objects:", files)
                        if _, err := api.DeleteObjects(ctx, bucket, files); err != nil {
                                return err
                        }
                }
        }
        if len(prefix) == 0 {
                fmt.Fprintln(os.Stderr, "Deleting bucket:", bucket)
                if data, err := api.DeleteBucket(ctx, bucket); err == nil {
                        fmt.Fprintln(os.Stderr, data.Message)
                } else if strings.Contains(err.Error(), `"error":"Bucket not found"`) {
                        fmt.Fprintln(os.Stderr, "Bucket not found:", bucket)
                } else {
                        return err
                }
        }
        return nil
}

1	package rm
2
3	import (
4	"context"
5	"fmt"
6	"os"
7	"strings"
8
9	"github.com/go-errors/errors"
10	"github.com/spf13/afero"
11	"github.com/supabase/cli/internal/storage/client"
12	"github.com/supabase/cli/internal/storage/cp"
13	"github.com/supabase/cli/internal/storage/ls"
14	"github.com/supabase/cli/internal/utils"
15	"github.com/supabase/cli/internal/utils/flags"
16	"github.com/supabase/cli/pkg/storage"
17	)
18
19	var (
20	errMissingObject = errors.New("Object not found")
21	errMissingBucket = errors.New("You must specify a bucket to delete.")
22	errMissingFlag = errors.New("You must specify -r flag to delete directories.")
23	)
24
25	type PrefixGroup struct {
26	Bucket string
27	Prefixes []string
28	}
29
30	func Run(ctx context.Context, paths []string, recursive bool, fsys afero.Fs) error {	6✔
31	// Group paths by buckets	6✔
32	groups := map[string][]string{}	6✔
33	for _, objectPath := range paths {	14✔
34	remotePath, err := client.ParseStorageURL(objectPath)	8✔
35	if err != nil {	9✔
36	return err	1✔
37	}	1✔
38	bucket, prefix := client.SplitBucketPrefix(remotePath)	7✔
39	// Ignore attempts to delete all buckets	7✔
40	if len(bucket) == 0 {	8✔
41	return errors.New(errMissingBucket)	1✔
42	}	1✔
43	if cp.IsDir(prefix) && !recursive {	7✔
44	return errors.New(errMissingFlag)	1✔
45	}	1✔
46	groups[bucket] = append(groups[bucket], prefix)	5✔
47	}
48	api, err := client.NewStorageAPI(ctx, flags.ProjectRef)	3✔
49	if err != nil {	3✔
50	return err	×
51	}	×
52	for bucket, prefixes := range groups {	7✔
53	confirm := fmt.Sprintf("Confirm deleting files in bucket %v?", utils.Bold(bucket))	4✔
54	if shouldDelete := utils.NewConsole().PromptYesNo(confirm, false); !shouldDelete {	5✔
55	continue	1✔
56	}
57	// Always try deleting first in case the paths resolve to extensionless files
58	fmt.Fprintln(os.Stderr, "Deleting objects:", prefixes)	3✔
59	removed, err := api.DeleteObjects(ctx, bucket, prefixes)	3✔
60	if err != nil {	4✔
61	return err	1✔
62	}	1✔
63	set := map[string]struct{}{}	2✔
64	for _, object := range removed {	3✔
65	set[object.Name] = struct{}{}	1✔
66	}	1✔
67	for _, prefix := range prefixes {	5✔
68	if _, ok := set[prefix]; ok {	4✔
69	continue	1✔
70	}
71	if !recursive {	3✔
72	fmt.Fprintln(os.Stderr, "Object not found:", prefix)	1✔
73	continue	1✔
74	}
75	if len(prefix) > 0 {	2✔
76	prefix += "/"	1✔
77	}	1✔
78	if err := RemoveStoragePathAll(ctx, api, bucket, prefix); err != nil {	1✔
79	return err	×
80	}	×
81	}
82	}
83	return nil	2✔
84	}
85
86	// Expects prefix to be terminated by "/" or ""
87	func RemoveStoragePathAll(ctx context.Context, api storage.StorageAPI, bucket, prefix string) error {	6✔
88	// We must remove one directory at a time to avoid breaking pagination result	6✔
89	queue := make([]string, 0)	6✔
90	queue = append(queue, prefix)	6✔
91	for len(queue) > 0 {	13✔
92	dirPrefix := queue[len(queue)-1]	7✔
93	queue = queue[:len(queue)-1]	7✔
94	paths, err := ls.ListStoragePaths(ctx, api, fmt.Sprintf("/%s/%s", bucket, dirPrefix))	7✔
95	if err != nil {	8✔
96	return err	1✔
97	}	1✔
98	if len(paths) == 0 && len(prefix) > 0 {	7✔
99	return errors.Errorf("%w: %s/%s", errMissingObject, bucket, prefix)	1✔
100	}	1✔
101	var files []string	5✔
102	for _, objectName := range paths {	10✔
103	objectPrefix := dirPrefix + objectName	5✔
104	if strings.HasSuffix(objectName, "/") {	6✔
105	queue = append(queue, objectPrefix)	1✔
106	} else {	5✔
107	files = append(files, objectPrefix)	4✔
108	}	4✔
109	}
110	if len(files) > 0 {	8✔
111	fmt.Fprintln(os.Stderr, "Deleting objects:", files)	3✔
112	if _, err := api.DeleteObjects(ctx, bucket, files); err != nil {	4✔
113	return err	1✔
114	}	1✔
115	}
116	}
117	if len(prefix) == 0 {	4✔
118	fmt.Fprintln(os.Stderr, "Deleting bucket:", bucket)	1✔
119	if data, err := api.DeleteBucket(ctx, bucket); err == nil {	2✔
120	fmt.Fprintln(os.Stderr, data.Message)	1✔
121	} else if strings.Contains(err.Error(), `"error":"Bucket not found"`) {	1✔
UNCOV 122	fmt.Fprintln(os.Stderr, "Bucket not found:", bucket)	×
UNCOV 123	} else {	×
124	return err	×
125	}	×
126	}
127	return nil	3✔
128	}

supabase / cli / 8998328342

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