12212288177

Committed 07 Dec 2024 10:53AM UTC coverage: 59.644% (-0.003%) from 59.647%

Build # 12212288177

Build Type

Pull #2952

github

Committed by

sweatybridge

Commit Message

fix: account for remote config when pushing

Pull Request Pull Request #2952: fix: account for remote config when pushing

Run Details

38 of 58 new or added lines in 10 files covered. (65.52%)

8 existing lines in 3 files now uncovered.

6404 of 10737 relevant lines covered (59.64%)

6.07 hits per line

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

14.55

/internal/utils/flags/db_url.go

package flags

import (
        "crypto/rand"
        "fmt"
        "math/big"
        "os"
        "strings"

        "github.com/go-errors/errors"
        "github.com/jackc/pgconn"
        "github.com/spf13/afero"
        "github.com/spf13/pflag"
        "github.com/spf13/viper"
        "github.com/supabase/cli/internal/utils"
        "github.com/supabase/cli/internal/utils/credentials"
        "github.com/supabase/cli/pkg/api"
)

type connection int

const (
        unknown connection = iota
        direct
        local
        linked
        proxy
)

var DbConfig pgconn.Config

func ParseDatabaseConfig(flagSet *pflag.FlagSet, fsys afero.Fs) error {
        // Changed flags take precedence over default values
        var connType connection
        if flag := flagSet.Lookup("db-url"); flag != nil && flag.Changed {
                connType = direct
        } else if flag := flagSet.Lookup("local"); flag != nil && flag.Changed {
                connType = local
        } else if flag := flagSet.Lookup("linked"); flag != nil && flag.Changed {
                connType = linked
        } else if flag := flagSet.Lookup("proxy"); flag != nil && flag.Changed {
                connType = proxy
        } else if value, err := flagSet.GetBool("local"); err == nil && value {
                connType = local
        } else if value, err := flagSet.GetBool("linked"); err == nil && value {
                connType = linked
        } else if value, err := flagSet.GetBool("proxy"); err == nil && value {
                connType = proxy
        }
        // Update connection config
        switch connType {
        case direct:
                if err := utils.Config.Load("", utils.NewRootFS(fsys)); err != nil && !errors.Is(err, os.ErrNotExist) {
                        return err
                }
                if flag := flagSet.Lookup("db-url"); flag != nil {
                        config, err := pgconn.ParseConfig(flag.Value.String())
                        if err != nil {
                                return errors.Errorf("failed to parse connection string: %w", err)
                        }
                        DbConfig = *config
                }
        case local:
                if err := utils.LoadConfigFS(fsys); err != nil {
                        return err
                }
                // Ignore other PG settings
                DbConfig.Host = utils.Config.Hostname
                DbConfig.Port = utils.Config.Db.Port
                DbConfig.User = "postgres"
                DbConfig.Password = utils.Config.Db.Password
                DbConfig.Database = "postgres"
        case linked:
                if err := utils.LoadConfigFS(fsys); err != nil {
                        return err
                }
                if err := LoadProjectRef(fsys); err != nil {
                        return err
                }
                DbConfig = NewDbConfigWithPassword(ProjectRef)
        case proxy:
                token, err := utils.LoadAccessTokenFS(fsys)
                if err != nil {
                        return err
                }
                if err := LoadProjectRef(fsys); err != nil {
                        return err
                }
                DbConfig.Host = utils.GetSupabaseAPIHost()
                DbConfig.Port = 443
                DbConfig.User = "postgres"
                DbConfig.Password = token
                DbConfig.Database = ProjectRef
        }
        return nil
}

func NewDbConfigWithPassword(projectRef string) pgconn.Config {
        config := getDbConfig(projectRef)
        config.Password = getPassword(projectRef)
        return config
}

func getPassword(projectRef string) string {
        if password := viper.GetString("DB_PASSWORD"); len(password) > 0 {
                return password
        }
        if password, err := credentials.StoreProvider.Get(projectRef); err == nil {
                return password
        }
        resetUrl := fmt.Sprintf("%s/project/%s/settings/database", utils.GetSupabaseDashboardURL(), projectRef)
        fmt.Fprintln(os.Stderr, "Forgot your password? Reset it from the Dashboard:", utils.Bold(resetUrl))
        fmt.Fprint(os.Stderr, "Enter your database password: ")
        return credentials.PromptMasked(os.Stdin)
}

const PASSWORD_LENGTH = 16

func PromptPassword(stdin *os.File) string {
        fmt.Fprint(os.Stderr, "Enter your database password (or leave blank to generate one): ")
        if input := credentials.PromptMasked(stdin); len(input) > 0 {
                return input
        }
        // Generate a password, see ./Settings/Database/DatabaseSettings/ResetDbPassword.tsx#L83
        var password []byte
        charset := string(api.AbcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567891)
        charset = strings.ReplaceAll(charset, ":", "")
        maxRange := big.NewInt(int64(len(charset)))
        for i := 0; i < PASSWORD_LENGTH; i++ {
                random, err := rand.Int(rand.Reader, maxRange)
                if err != nil {
                        fmt.Fprintln(os.Stderr, "Failed to randomise password:", err)
                        continue
                }
                password = append(password, charset[random.Int64()])
        }
        return string(password)
}

func getDbConfig(projectRef string) pgconn.Config {
        if poolerConfig := utils.GetPoolerConfig(projectRef); poolerConfig != nil {
                return *poolerConfig
        }
        return pgconn.Config{
                Host:     utils.GetSupabaseDbHost(projectRef),
                Port:     5432,
                User:     "postgres",
                Database: "postgres",
        }
}

func GetDbConfigOptionalPassword(projectRef string) pgconn.Config {
        config := getDbConfig(projectRef)
        config.Password = viper.GetString("DB_PASSWORD")
        if config.Password == "" {
                fmt.Fprint(os.Stderr, "Enter your database password (or leave blank to skip): ")
                config.Password = credentials.PromptMasked(os.Stdin)
        }
        return config
}

1	package flags
2
3	import (
4	"crypto/rand"
5	"fmt"
6	"math/big"
7	"os"
8	"strings"
9
10	"github.com/go-errors/errors"
11	"github.com/jackc/pgconn"
12	"github.com/spf13/afero"
13	"github.com/spf13/pflag"
14	"github.com/spf13/viper"
15	"github.com/supabase/cli/internal/utils"
16	"github.com/supabase/cli/internal/utils/credentials"
17	"github.com/supabase/cli/pkg/api"
18	)
19
20	type connection int
21
22	const (
23	unknown connection = iota
24	direct
25	local
26	linked
27	proxy
28	)
29
30	var DbConfig pgconn.Config
31
32	func ParseDatabaseConfig(flagSet *pflag.FlagSet, fsys afero.Fs) error {	×
33	// Changed flags take precedence over default values	×
34	var connType connection	×
35	if flag := flagSet.Lookup("db-url"); flag != nil && flag.Changed {	×
36	connType = direct	×
37	} else if flag := flagSet.Lookup("local"); flag != nil && flag.Changed {	×
38	connType = local	×
39	} else if flag := flagSet.Lookup("linked"); flag != nil && flag.Changed {	×
40	connType = linked	×
41	} else if flag := flagSet.Lookup("proxy"); flag != nil && flag.Changed {	×
42	connType = proxy	×
43	} else if value, err := flagSet.GetBool("local"); err == nil && value {	×
44	connType = local	×
45	} else if value, err := flagSet.GetBool("linked"); err == nil && value {	×
46	connType = linked	×
47	} else if value, err := flagSet.GetBool("proxy"); err == nil && value {	×
48	connType = proxy	×
49	}	×
50	// Update connection config
51	switch connType {	×
52	case direct:	×
NEW 53	if err := utils.Config.Load("", utils.NewRootFS(fsys)); err != nil && !errors.Is(err, os.ErrNotExist) {	×
NEW 54	return err	×
55	}	×
56	if flag := flagSet.Lookup("db-url"); flag != nil {	×
57	config, err := pgconn.ParseConfig(flag.Value.String())	×
58	if err != nil {	×
59	return errors.Errorf("failed to parse connection string: %w", err)	×
60	}	×
61	DbConfig = *config	×
62	}
63	case local:	×
64	if err := utils.LoadConfigFS(fsys); err != nil {	×
65	return err	×
66	}	×
67	// Ignore other PG settings
68	DbConfig.Host = utils.Config.Hostname	×
69	DbConfig.Port = utils.Config.Db.Port	×
70	DbConfig.User = "postgres"	×
71	DbConfig.Password = utils.Config.Db.Password	×
72	DbConfig.Database = "postgres"	×
73	case linked:	×
74	if err := utils.LoadConfigFS(fsys); err != nil {	×
75	return err	×
76	}	×
NEW 77	if err := LoadProjectRef(fsys); err != nil {	×
78	return err	×
79	}	×
NEW 80	DbConfig = NewDbConfigWithPassword(ProjectRef)	×
81	case proxy:	×
82	token, err := utils.LoadAccessTokenFS(fsys)	×
83	if err != nil {	×
84	return err	×
85	}	×
NEW 86	if err := LoadProjectRef(fsys); err != nil {	×
87	return err	×
88	}	×
89	DbConfig.Host = utils.GetSupabaseAPIHost()	×
90	DbConfig.Port = 443	×
91	DbConfig.User = "postgres"	×
92	DbConfig.Password = token	×
NEW 93	DbConfig.Database = ProjectRef	×
94	}
95	return nil	×
96	}
97
98	func NewDbConfigWithPassword(projectRef string) pgconn.Config {	×
99	config := getDbConfig(projectRef)	×
100	config.Password = getPassword(projectRef)	×
101	return config	×
102	}	×
103
104	func getPassword(projectRef string) string {	×
105	if password := viper.GetString("DB_PASSWORD"); len(password) > 0 {	×
106	return password	×
107	}	×
108	if password, err := credentials.StoreProvider.Get(projectRef); err == nil {	×
109	return password	×
110	}	×
111	resetUrl := fmt.Sprintf("%s/project/%s/settings/database", utils.GetSupabaseDashboardURL(), projectRef)	×
112	fmt.Fprintln(os.Stderr, "Forgot your password? Reset it from the Dashboard:", utils.Bold(resetUrl))	×
113	fmt.Fprint(os.Stderr, "Enter your database password: ")	×
114	return credentials.PromptMasked(os.Stdin)	×
115	}
116
117	const PASSWORD_LENGTH = 16
118
119	func PromptPassword(stdin *os.File) string {	×
120	fmt.Fprint(os.Stderr, "Enter your database password (or leave blank to generate one): ")	×
121	if input := credentials.PromptMasked(stdin); len(input) > 0 {	×
122	return input	×
123	}	×
124	// Generate a password, see ./Settings/Database/DatabaseSettings/ResetDbPassword.tsx#L83
125	var password []byte	×
126	charset := string(api.AbcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567891)	×
127	charset = strings.ReplaceAll(charset, ":", "")	×
128	maxRange := big.NewInt(int64(len(charset)))	×
129	for i := 0; i < PASSWORD_LENGTH; i++ {	×
130	random, err := rand.Int(rand.Reader, maxRange)	×
131	if err != nil {	×
132	fmt.Fprintln(os.Stderr, "Failed to randomise password:", err)	×
133	continue	×
134	}
135	password = append(password, charset[random.Int64()])	×
136	}
137	return string(password)	×
138	}
139
140	func getDbConfig(projectRef string) pgconn.Config {	3✔
141	if poolerConfig := utils.GetPoolerConfig(projectRef); poolerConfig != nil {	3✔
142	return *poolerConfig	×
143	}	×
144	return pgconn.Config{	3✔
145	Host: utils.GetSupabaseDbHost(projectRef),	3✔
146	Port: 5432,	3✔
147	User: "postgres",	3✔
148	Database: "postgres",	3✔
149	}	3✔
150	}
151
152	func GetDbConfigOptionalPassword(projectRef string) pgconn.Config {	3✔
153	config := getDbConfig(projectRef)	3✔
154	config.Password = viper.GetString("DB_PASSWORD")	3✔
155	if config.Password == "" {	6✔
156	fmt.Fprint(os.Stderr, "Enter your database password (or leave blank to skip): ")	3✔
157	config.Password = credentials.PromptMasked(os.Stdin)	3✔
158	}	3✔
159	return config	3✔
160	}

supabase / cli / 12212288177

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