23560422207

Committed 25 Mar 2026 07:38PM UTC coverage: 63.16%. First build

Build # 23560422207

Build Type

Pull #4962

github

Committed by

web-flow

Commit Message

Merge a0799e307 into 5025dd2ab

Pull Request Pull Request #4962: Prod deploy

Coverage Stats

905 of 2078 new or added lines in 27 files covered. (43.55%)

9191 of 14552 relevant lines covered (63.16%)

6.85 hits per line

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

27.08

/internal/db/diff/explicit.go

package diff

import (
        "context"
        "fmt"

        "github.com/go-errors/errors"
        "github.com/jackc/pgconn"
        "github.com/jackc/pgx/v4"
        "github.com/spf13/afero"
        "github.com/supabase/cli/internal/db/pgcache"
        "github.com/supabase/cli/internal/db/start"
        "github.com/supabase/cli/internal/utils"
        "github.com/supabase/cli/internal/utils/flags"
)

type linkedConfigResolver func(context.Context, afero.Fs) (pgconn.Config, error)
type migrationsRefResolver func(context.Context, afero.Fs, ...func(*pgx.ConnConfig)) (string, error)

func RunExplicit(ctx context.Context, fromRef, toRef string, schema []string, outputPath string, fsys afero.Fs, options ...func(*pgx.ConnConfig)) error {
        source, err := resolveExplicitDatabaseRef(ctx, fromRef, fsys, resolveLinkedConfig, resolveMigrationsCatalogRef, options...)
        if err != nil {
                return err
        }
        target, err := resolveExplicitDatabaseRef(ctx, toRef, fsys, resolveLinkedConfig, resolveMigrationsCatalogRef, options...)
        if err != nil {
                return err
        }
        out, err := DiffPgDeltaRef(ctx, source, target, schema, pgDeltaFormatOptions(), options...)
        if err != nil {
                return err
        }
        if len(outputPath) > 0 {
                return writeOutput(out, outputPath, fsys)
        }
        fmt.Print(out)
        return nil
}

var validTargets = map[string]bool{"local": true, "linked": true, "migrations": true}

func resolveExplicitDatabaseRef(ctx context.Context, ref string, fsys afero.Fs, resolveLinked linkedConfigResolver, resolveMigrations migrationsRefResolver, options ...func(*pgx.ConnConfig)) (string, error) {
        if !validTargets[ref] && !isPostgresURL(ref) {
                return "", errors.Errorf("unknown target %q: must be one of 'local', 'linked', 'migrations', or a postgres:// URL", ref)
        }
        switch ref {
        case "local":
                return utils.ToPostgresURL(pgconn.Config{
                        Host:     utils.Config.Hostname,
                        Port:     utils.Config.Db.Port,
                        User:     "postgres",
                        Password: utils.Config.Db.Password,
                        Database: "postgres",
                }), nil
        case "linked":
                if resolveLinked == nil {
                        resolveLinked = resolveLinkedConfig
                }
                config, err := resolveLinked(ctx, fsys)
                if err != nil {
                        return "", err
                }
                return utils.ToPostgresURL(config), nil
        case "migrations":
                if resolveMigrations == nil {
                        resolveMigrations = resolveMigrationsCatalogRef
                }
                return resolveMigrations(ctx, fsys, options...)
        default:
                return ref, nil
        }
}

func writeOutput(out, outputPath string, fsys afero.Fs) error {
        return utils.WriteFile(outputPath, []byte(out), fsys)
}

func resolveLinkedConfig(ctx context.Context, fsys afero.Fs) (pgconn.Config, error) {
        if err := flags.LoadProjectRef(fsys); err != nil {
                return pgconn.Config{}, err
        }
        if err := flags.LoadConfig(fsys); err != nil {
                return pgconn.Config{}, err
        }
        return flags.NewDbConfigWithPassword(ctx, flags.ProjectRef)
}

func resolveMigrationsCatalogRef(ctx context.Context, fsys afero.Fs, options ...func(*pgx.ConnConfig)) (string, error) {
        hash, err := pgcache.HashMigrations(fsys)
        if err != nil {
                return "", err
        }
        if cachePath, ok, err := pgcache.ResolveMigrationCatalogPath(fsys, hash, "local"); err != nil {
                return "", err
        } else if ok {
                return cachePath, nil
        }
        shadow, err := CreateShadowDatabase(ctx, utils.Config.Db.ShadowPort)
        if err != nil {
                return "", err
        }
        defer utils.DockerRemove(shadow)
        if err := start.WaitForHealthyService(ctx, utils.Config.Db.HealthTimeout, shadow); err != nil {
                utils.DockerRemove(shadow)
                return "", err
        }
        if err := MigrateShadowDatabase(ctx, shadow, fsys, options...); err != nil {
                return "", err
        }
        shadowConfig := pgconn.Config{
                Host:     utils.Config.Hostname,
                Port:     utils.Config.Db.ShadowPort,
                User:     "postgres",
                Password: utils.Config.Db.Password,
                Database: "postgres",
        }
        snapshot, err := ExportCatalogPgDelta(ctx, utils.ToPostgresURL(shadowConfig), "postgres", options...)
        if err != nil {
                return "", err
        }
        cachePath, err := pgcache.WriteMigrationCatalogSnapshot(fsys, "local", hash, snapshot)
        if err != nil {
                return "", err
        }
        return cachePath, nil
}

1	package diff
2
3	import (
4	"context"
5	"fmt"
6
7	"github.com/go-errors/errors"
8	"github.com/jackc/pgconn"
9	"github.com/jackc/pgx/v4"
10	"github.com/spf13/afero"
11	"github.com/supabase/cli/internal/db/pgcache"
12	"github.com/supabase/cli/internal/db/start"
13	"github.com/supabase/cli/internal/utils"
14	"github.com/supabase/cli/internal/utils/flags"
15	)
16
17	type linkedConfigResolver func(context.Context, afero.Fs) (pgconn.Config, error)
18	type migrationsRefResolver func(context.Context, afero.Fs, ...func(*pgx.ConnConfig)) (string, error)
19
NEW 20	func RunExplicit(ctx context.Context, fromRef, toRef string, schema []string, outputPath string, fsys afero.Fs, options ...func(*pgx.ConnConfig)) error {	×
NEW 21	source, err := resolveExplicitDatabaseRef(ctx, fromRef, fsys, resolveLinkedConfig, resolveMigrationsCatalogRef, options...)	×
NEW 22	if err != nil {	×
NEW 23	return err	×
NEW 24	}	×
NEW 25	target, err := resolveExplicitDatabaseRef(ctx, toRef, fsys, resolveLinkedConfig, resolveMigrationsCatalogRef, options...)	×
NEW 26	if err != nil {	×
NEW 27	return err	×
NEW 28	}	×
NEW 29	out, err := DiffPgDeltaRef(ctx, source, target, schema, pgDeltaFormatOptions(), options...)	×
NEW 30	if err != nil {	×
NEW 31	return err	×
NEW 32	}	×
NEW 33	if len(outputPath) > 0 {	×
NEW 34	return writeOutput(out, outputPath, fsys)	×
NEW 35	}	×
NEW 36	fmt.Print(out)	×
NEW 37	return nil	×
38	}
39
40	var validTargets = map[string]bool{"local": true, "linked": true, "migrations": true}
41
42	func resolveExplicitDatabaseRef(ctx context.Context, ref string, fsys afero.Fs, resolveLinked linkedConfigResolver, resolveMigrations migrationsRefResolver, options ...func(*pgx.ConnConfig)) (string, error) {	5✔
43	if !validTargets[ref] && !isPostgresURL(ref) {	6✔
44	return "", errors.Errorf("unknown target %q: must be one of 'local', 'linked', 'migrations', or a postgres:// URL", ref)	1✔
45	}	1✔
46	switch ref {	4✔
47	case "local":	1✔
48	return utils.ToPostgresURL(pgconn.Config{	1✔
49	Host: utils.Config.Hostname,	1✔
50	Port: utils.Config.Db.Port,	1✔
51	User: "postgres",	1✔
52	Password: utils.Config.Db.Password,	1✔
53	Database: "postgres",	1✔
54	}), nil	1✔
55	case "linked":	1✔
56	if resolveLinked == nil {	1✔
NEW 57	resolveLinked = resolveLinkedConfig	×
NEW 58	}	×
59	config, err := resolveLinked(ctx, fsys)	1✔
60	if err != nil {	1✔
NEW 61	return "", err	×
NEW 62	}	×
63	return utils.ToPostgresURL(config), nil	1✔
64	case "migrations":	1✔
65	if resolveMigrations == nil {	1✔
NEW 66	resolveMigrations = resolveMigrationsCatalogRef	×
NEW 67	}	×
68	return resolveMigrations(ctx, fsys, options...)	1✔
69	default:	1✔
70	return ref, nil	1✔
71	}
72	}
73
74	func writeOutput(out, outputPath string, fsys afero.Fs) error {	1✔
75	return utils.WriteFile(outputPath, []byte(out), fsys)	1✔
76	}	1✔
77
NEW 78	func resolveLinkedConfig(ctx context.Context, fsys afero.Fs) (pgconn.Config, error) {	×
NEW 79	if err := flags.LoadProjectRef(fsys); err != nil {	×
NEW 80	return pgconn.Config{}, err	×
NEW 81	}	×
NEW 82	if err := flags.LoadConfig(fsys); err != nil {	×
NEW 83	return pgconn.Config{}, err	×
NEW 84	}	×
NEW 85	return flags.NewDbConfigWithPassword(ctx, flags.ProjectRef)	×
86	}
87
NEW 88	func resolveMigrationsCatalogRef(ctx context.Context, fsys afero.Fs, options ...func(*pgx.ConnConfig)) (string, error) {	×
NEW 89	hash, err := pgcache.HashMigrations(fsys)	×
NEW 90	if err != nil {	×
NEW 91	return "", err	×
NEW 92	}	×
NEW 93	if cachePath, ok, err := pgcache.ResolveMigrationCatalogPath(fsys, hash, "local"); err != nil {	×
NEW 94	return "", err	×
NEW 95	} else if ok {	×
NEW 96	return cachePath, nil	×
NEW 97	}	×
NEW 98	shadow, err := CreateShadowDatabase(ctx, utils.Config.Db.ShadowPort)	×
NEW 99	if err != nil {	×
NEW 100	return "", err	×
NEW 101	}	×
NEW 102	defer utils.DockerRemove(shadow)	×
NEW 103	if err := start.WaitForHealthyService(ctx, utils.Config.Db.HealthTimeout, shadow); err != nil {	×
NEW 104	utils.DockerRemove(shadow)	×
NEW 105	return "", err	×
NEW 106	}	×
NEW 107	if err := MigrateShadowDatabase(ctx, shadow, fsys, options...); err != nil {	×
NEW 108	return "", err	×
NEW 109	}	×
NEW 110	shadowConfig := pgconn.Config{	×
NEW 111	Host: utils.Config.Hostname,	×
NEW 112	Port: utils.Config.Db.ShadowPort,	×
NEW 113	User: "postgres",	×
NEW 114	Password: utils.Config.Db.Password,	×
NEW 115	Database: "postgres",	×
NEW 116	}	×
NEW 117	snapshot, err := ExportCatalogPgDelta(ctx, utils.ToPostgresURL(shadowConfig), "postgres", options...)	×
NEW 118	if err != nil {	×
NEW 119	return "", err	×
NEW 120	}	×
NEW 121	cachePath, err := pgcache.WriteMigrationCatalogSnapshot(fsys, "local", hash, snapshot)	×
NEW 122	if err != nil {	×
NEW 123	return "", err	×
NEW 124	}	×
NEW 125	return cachePath, nil	×
126	}

supabase / cli / 23560422207

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