16976524820

Committed 14 Aug 2025 08:57PM UTC coverage: 54.808% (-0.5%) from 55.271%

Build # 16976524820

Build Type

Pull #3969

github

Committed by

web-flow

Commit Message

Merge 419dd46ad into b3d509dd5

Pull Request Pull Request #3969: feat: generate jwt tokens from signing key

Run Details

11 of 13 new or added lines in 1 file covered. (84.62%)

391 existing lines in 14 files now uncovered.

6196 of 11305 relevant lines covered (54.81%)

6.09 hits per line

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

0.0

/internal/branches/get/get.go

package get

import (
        "context"
        "fmt"
        "os"

        "github.com/go-errors/errors"
        "github.com/google/uuid"
        "github.com/jackc/pgconn"
        "github.com/spf13/afero"
        "github.com/supabase/cli/internal/migration/list"
        "github.com/supabase/cli/internal/projects/apiKeys"
        "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"
)

func Run(ctx context.Context, branchId string, fsys afero.Fs) error {
        detail, err := getBranchDetail(ctx, branchId)
        if err != nil {
                return err
        }

        if utils.OutputFormat.Value != utils.OutputPretty {
                keys, err := apiKeys.RunGetApiKeys(ctx, detail.Ref)
                if err != nil {
                        return err
                }
                pooler, err := getPoolerConfig(ctx, detail.Ref)
                if err != nil {
                        return err
                }
                envs := toStandardEnvs(detail, pooler, keys)
                return utils.EncodeOutput(utils.OutputFormat.Value, os.Stdout, envs)
        }

        table := `|HOST|PORT|USER|PASSWORD|JWT SECRET|POSTGRES VERSION|STATUS|
|-|-|-|-|-|-|-|
` + fmt.Sprintf(
                "|`%s`|`%d`|`%s`|`%s`|`%s`|`%s`|`%s`|\n",
                detail.DbHost,
                detail.DbPort,
                *detail.DbUser,
                *detail.DbPass,
                *detail.JwtSecret,
                detail.PostgresVersion,
                detail.Status,
        )

        return list.RenderTable(table)
}

func getBranchDetail(ctx context.Context, branchId string) (api.BranchDetailResponse, error) {
        var result api.BranchDetailResponse
        parsed, err := GetBranchID(ctx, branchId)
        if err != nil {
                return result, err
        }
        resp, err := utils.GetSupabase().V1GetABranchConfigWithResponse(ctx, parsed)
        if err != nil {
                return result, errors.Errorf("failed to get branch: %w", err)
        } else if resp.JSON200 == nil {
                return result, errors.Errorf("unexpected get branch status %d: %s", resp.StatusCode(), string(resp.Body))
        }
        masked := "******"
        if resp.JSON200.DbUser == nil {
                resp.JSON200.DbUser = &masked
        }
        if resp.JSON200.DbPass == nil {
                resp.JSON200.DbPass = &masked
        }
        if resp.JSON200.JwtSecret == nil {
                resp.JSON200.JwtSecret = &masked
        }
        return *resp.JSON200, nil
}

func GetBranchID(ctx context.Context, branchId string) (uuid.UUID, error) {
        parsed, err := uuid.Parse(branchId)
        if err == nil {
                return parsed, nil
        }
        resp, err := utils.GetSupabase().V1GetABranchWithResponse(ctx, flags.ProjectRef, branchId)
        if err != nil {
                return parsed, errors.Errorf("failed to get branch: %w", err)
        } else if resp.JSON200 == nil {
                return parsed, errors.Errorf("unexpected get branch status %d: %s", resp.StatusCode(), string(resp.Body))
        }
        return resp.JSON200.Id, nil
}

func getPoolerConfig(ctx context.Context, ref string) (api.SupavisorConfigResponse, error) {
        var result api.SupavisorConfigResponse
        resp, err := utils.GetSupabase().V1GetPoolerConfigWithResponse(ctx, ref)
        if err != nil {
                return result, errors.Errorf("failed to get pooler: %w", err)
        } else if resp.JSON200 == nil {
                return result, errors.Errorf("unexpected get pooler status %d: %s", resp.StatusCode(), string(resp.Body))
        }
        for _, config := range *resp.JSON200 {
                if config.DatabaseType == api.PRIMARY {
                        return config, nil
                }
        }
        return result, errors.Errorf("primary database not found: %s", ref)
}

func toStandardEnvs(detail api.BranchDetailResponse, pooler api.SupavisorConfigResponse, keys []api.ApiKeyResponse) map[string]string {
        direct := pgconn.Config{
                Host:     detail.DbHost,
                Port:     cast.UIntToUInt16(cast.IntToUint(detail.DbPort)),
                User:     *detail.DbUser,
                Password: *detail.DbPass,
                Database: "postgres",
        }
        config, err := utils.ParsePoolerURL(pooler.ConnectionString)
        if err != nil {
                fmt.Fprintln(os.Stderr, utils.Yellow("WARNING:"), err)
                config = &direct
        } else {
                config.Password = direct.Password
        }
        envs := apiKeys.ToEnv(keys)
        envs["POSTGRES_URL"] = utils.ToPostgresURL(*config)
        envs["POSTGRES_URL_NON_POOLING"] = utils.ToPostgresURL(direct)
        envs["SUPABASE_URL"] = "https://" + utils.GetSupabaseHost(detail.Ref)
        envs["SUPABASE_JWT_SECRET"] = *detail.JwtSecret
        return envs
}

1	package get
2
3	import (
4	"context"
5	"fmt"
6	"os"
7
8	"github.com/go-errors/errors"
9	"github.com/google/uuid"
10	"github.com/jackc/pgconn"
11	"github.com/spf13/afero"
12	"github.com/supabase/cli/internal/migration/list"
13	"github.com/supabase/cli/internal/projects/apiKeys"
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	)
19
20	func Run(ctx context.Context, branchId string, fsys afero.Fs) error {	×
21	detail, err := getBranchDetail(ctx, branchId)	×
22	if err != nil {	×
23	return err	×
UNCOV 24	}	×
25
26	if utils.OutputFormat.Value != utils.OutputPretty {	×
27	keys, err := apiKeys.RunGetApiKeys(ctx, detail.Ref)	×
28	if err != nil {	×
29	return err	×
30	}	×
31	pooler, err := getPoolerConfig(ctx, detail.Ref)	×
32	if err != nil {	×
33	return err	×
34	}	×
35	envs := toStandardEnvs(detail, pooler, keys)	×
UNCOV 36	return utils.EncodeOutput(utils.OutputFormat.Value, os.Stdout, envs)	×
37	}
38
39	table := `\|HOST\|PORT\|USER\|PASSWORD\|JWT SECRET\|POSTGRES VERSION\|STATUS\|	×
40	\|-\|-\|-\|-\|-\|-\|-\|	×
41	` + fmt.Sprintf(	×
42	"\|`%s`\|`%d`\|`%s`\|`%s`\|`%s`\|`%s`\|`%s`\|\n",	×
43	detail.DbHost,	×
44	detail.DbPort,	×
45	*detail.DbUser,	×
46	*detail.DbPass,	×
47	*detail.JwtSecret,	×
48	detail.PostgresVersion,	×
49	detail.Status,	×
50	)	×
51		×
UNCOV 52	return list.RenderTable(table)	×
53	}
54
55	func getBranchDetail(ctx context.Context, branchId string) (api.BranchDetailResponse, error) {	×
56	var result api.BranchDetailResponse	×
57	parsed, err := GetBranchID(ctx, branchId)	×
58	if err != nil {	×
59	return result, err	×
60	}	×
61	resp, err := utils.GetSupabase().V1GetABranchConfigWithResponse(ctx, parsed)	×
62	if err != nil {	×
63	return result, errors.Errorf("failed to get branch: %w", err)	×
64	} else if resp.JSON200 == nil {	×
65	return result, errors.Errorf("unexpected get branch status %d: %s", resp.StatusCode(), string(resp.Body))	×
66	}	×
67	masked := "******"	×
68	if resp.JSON200.DbUser == nil {	×
69	resp.JSON200.DbUser = &masked	×
70	}	×
71	if resp.JSON200.DbPass == nil {	×
72	resp.JSON200.DbPass = &masked	×
73	}	×
74	if resp.JSON200.JwtSecret == nil {	×
75	resp.JSON200.JwtSecret = &masked	×
76	}	×
UNCOV 77	return *resp.JSON200, nil	×
78	}
79
80	func GetBranchID(ctx context.Context, branchId string) (uuid.UUID, error) {	×
81	parsed, err := uuid.Parse(branchId)	×
82	if err == nil {	×
83	return parsed, nil	×
84	}	×
85	resp, err := utils.GetSupabase().V1GetABranchWithResponse(ctx, flags.ProjectRef, branchId)	×
86	if err != nil {	×
87	return parsed, errors.Errorf("failed to get branch: %w", err)	×
88	} else if resp.JSON200 == nil {	×
89	return parsed, errors.Errorf("unexpected get branch status %d: %s", resp.StatusCode(), string(resp.Body))	×
90	}	×
UNCOV 91	return resp.JSON200.Id, nil	×
92	}
93
UNCOV 94	func getPoolerConfig(ctx context.Context, ref string) (api.SupavisorConfigResponse, error) {	×
95	var result api.SupavisorConfigResponse	×
96	resp, err := utils.GetSupabase().V1GetPoolerConfigWithResponse(ctx, ref)	×
97	if err != nil {	×
98	return result, errors.Errorf("failed to get pooler: %w", err)	×
99	} else if resp.JSON200 == nil {	×
100	return result, errors.Errorf("unexpected get pooler status %d: %s", resp.StatusCode(), string(resp.Body))	×
101	}	×
102	for _, config := range *resp.JSON200 {	×
103	if config.DatabaseType == api.PRIMARY {	×
104	return config, nil	×
105	}	×
106	}
107	return result, errors.Errorf("primary database not found: %s", ref)	×
108	}
109
110	func toStandardEnvs(detail api.BranchDetailResponse, pooler api.SupavisorConfigResponse, keys []api.ApiKeyResponse) map[string]string {	×
111	direct := pgconn.Config{	×
112	Host: detail.DbHost,	×
113	Port: cast.UIntToUInt16(cast.IntToUint(detail.DbPort)),	×
114	User: *detail.DbUser,	×
UNCOV 115	Password: *detail.DbPass,	×
UNCOV 116	Database: "postgres",	×
UNCOV 117	}	×
UNCOV 118	config, err := utils.ParsePoolerURL(pooler.ConnectionString)	×
UNCOV 119	if err != nil {	×
UNCOV 120	fmt.Fprintln(os.Stderr, utils.Yellow("WARNING:"), err)	×
UNCOV 121	config = &direct	×
UNCOV 122	} else {	×
UNCOV 123	config.Password = direct.Password	×
UNCOV 124	}	×
UNCOV 125	envs := apiKeys.ToEnv(keys)	×
UNCOV 126	envs["POSTGRES_URL"] = utils.ToPostgresURL(*config)	×
UNCOV 127	envs["POSTGRES_URL_NON_POOLING"] = utils.ToPostgresURL(direct)	×
UNCOV 128	envs["SUPABASE_URL"] = "https://" + utils.GetSupabaseHost(detail.Ref)	×
UNCOV 129	envs["SUPABASE_JWT_SECRET"] = *detail.JwtSecret	×
UNCOV 130	return envs	×
131	}

supabase / cli / 16976524820

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