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

0.0

/internal/services/services.go

package services

import (
        "context"
        "errors"
        "fmt"
        "os"
        "strings"
        "sync"

        "github.com/spf13/afero"
        "github.com/supabase/cli/internal/migration/list"
        "github.com/supabase/cli/internal/utils"
        "github.com/supabase/cli/internal/utils/flags"
        "github.com/supabase/cli/internal/utils/tenant"
)

func Run(ctx context.Context, fsys afero.Fs) error {
        if err := flags.LoadProjectRef(fsys); err != nil && !errors.Is(err, utils.ErrNotLinked) {
                fmt.Fprintln(os.Stderr, err)
        }
        if err := utils.Config.Load("", utils.NewRootFS(fsys)); err != nil && !errors.Is(err, os.ErrNotExist) {
                fmt.Fprintln(os.Stderr, err)
        }

        serviceImages := CheckVersions(ctx, fsys)
        table := `|SERVICE IMAGE|LOCAL|LINKED|
|-|-|-|
`
        for _, image := range serviceImages {
                remote := image.Remote
                if len(remote) == 0 {
                        remote = "-"
                }
                table += fmt.Sprintf("|`%s`|`%s`|`%s`|\n", image.Name, image.Local, remote)
        }

        return list.RenderTable(table)
}

type imageVersion struct {
        Name   string `json:"name"`
        Local  string `json:"local"`
        Remote string `json:"remote"`
}

func CheckVersions(ctx context.Context, fsys afero.Fs) []imageVersion {
        var remote map[string]string
        if _, err := utils.LoadAccessTokenFS(fsys); err == nil && len(flags.ProjectRef) > 0 {
                remote = listRemoteImages(ctx, flags.ProjectRef)
        }
        var result []imageVersion
        for _, image := range utils.Config.GetServiceImages() {
                parts := strings.Split(image, ":")
                v := imageVersion{Name: parts[0], Local: parts[1]}
                if v.Remote = remote[image]; v.Remote == v.Local {
                        delete(remote, image)
                }
                result = append(result, v)
        }
        if len(remote) > 0 {
                fmt.Fprintln(os.Stderr, suggestUpdateCmd(remote))
        }
        return result
}

func listRemoteImages(ctx context.Context, projectRef string) map[string]string {
        linked := make(map[string]string, 4)
        var wg sync.WaitGroup
        wg.Add(1)
        go func() {
                defer wg.Done()
                if version, err := tenant.GetDatabaseVersion(ctx, projectRef); err == nil {
                        linked[utils.Config.Db.Image] = version
                }
        }()
        keys, err := tenant.GetApiKeys(ctx, projectRef)
        if err != nil {
                wg.Wait()
                return linked
        }
        api := tenant.NewTenantAPI(ctx, projectRef, keys.Anon)
        wg.Add(3)
        go func() {
                defer wg.Done()
                if version, err := api.GetGotrueVersion(ctx); err == nil {
                        linked[utils.Config.Auth.Image] = version
                }
        }()
        go func() {
                defer wg.Done()
                if version, err := api.GetPostgrestVersion(ctx); err == nil {
                        linked[utils.Config.Api.Image] = version
                }
        }()
        go func() {
                defer wg.Done()
                if version, err := api.GetStorageVersion(ctx); err == nil {
                        linked[utils.Config.Storage.Image] = version
                }
        }()
        wg.Wait()
        return linked
}

func suggestUpdateCmd(serviceImages map[string]string) string {
        cmd := fmt.Sprintln(utils.Yellow("WARNING:"), "You are running different service versions locally than your linked project:")
        for k, v := range serviceImages {
                cmd += fmt.Sprintf("%s => %s\n", k, v)
        }
        cmd += fmt.Sprintf("Run %s to update them.", utils.Aqua("supabase link"))
        return cmd
}

1	package services
2
3	import (
4	"context"
5	"errors"
6	"fmt"
7	"os"
8	"strings"
9	"sync"
10
11	"github.com/spf13/afero"
12	"github.com/supabase/cli/internal/migration/list"
13	"github.com/supabase/cli/internal/utils"
14	"github.com/supabase/cli/internal/utils/flags"
15	"github.com/supabase/cli/internal/utils/tenant"
16	)
17
18	func Run(ctx context.Context, fsys afero.Fs) error {	×
NEW 19	if err := flags.LoadProjectRef(fsys); err != nil && !errors.Is(err, utils.ErrNotLinked) {	×
20	fmt.Fprintln(os.Stderr, err)	×
21	}	×
22	if err := utils.Config.Load("", utils.NewRootFS(fsys)); err != nil && !errors.Is(err, os.ErrNotExist) {	×
23	fmt.Fprintln(os.Stderr, err)	×
24	}	×
25
26	serviceImages := CheckVersions(ctx, fsys)	×
27	table := `\|SERVICE IMAGE\|LOCAL\|LINKED\|	×
28	\|-\|-\|-\|	×
29	`	×
30	for _, image := range serviceImages {	×
31	remote := image.Remote	×
32	if len(remote) == 0 {	×
33	remote = "-"	×
34	}	×
35	table += fmt.Sprintf("\|`%s`\|`%s`\|`%s`\|\n", image.Name, image.Local, remote)	×
36	}
37
38	return list.RenderTable(table)	×
39	}
40
41	type imageVersion struct {
42	Name string `json:"name"`
43	Local string `json:"local"`
44	Remote string `json:"remote"`
45	}
46
47	func CheckVersions(ctx context.Context, fsys afero.Fs) []imageVersion {	×
48	var remote map[string]string	×
49	if _, err := utils.LoadAccessTokenFS(fsys); err == nil && len(flags.ProjectRef) > 0 {	×
50	remote = listRemoteImages(ctx, flags.ProjectRef)	×
51	}	×
52	var result []imageVersion	×
53	for _, image := range utils.Config.GetServiceImages() {	×
54	parts := strings.Split(image, ":")	×
55	v := imageVersion{Name: parts[0], Local: parts[1]}	×
56	if v.Remote = remote[image]; v.Remote == v.Local {	×
57	delete(remote, image)	×
58	}	×
59	result = append(result, v)	×
60	}
61	if len(remote) > 0 {	×
62	fmt.Fprintln(os.Stderr, suggestUpdateCmd(remote))	×
63	}	×
64	return result	×
65	}
66
67	func listRemoteImages(ctx context.Context, projectRef string) map[string]string {	×
68	linked := make(map[string]string, 4)	×
69	var wg sync.WaitGroup	×
70	wg.Add(1)	×
71	go func() {	×
72	defer wg.Done()	×
73	if version, err := tenant.GetDatabaseVersion(ctx, projectRef); err == nil {	×
74	linked[utils.Config.Db.Image] = version	×
75	}	×
76	}()
77	keys, err := tenant.GetApiKeys(ctx, projectRef)	×
78	if err != nil {	×
79	wg.Wait()	×
80	return linked	×
81	}	×
82	api := tenant.NewTenantAPI(ctx, projectRef, keys.Anon)	×
83	wg.Add(3)	×
84	go func() {	×
85	defer wg.Done()	×
86	if version, err := api.GetGotrueVersion(ctx); err == nil {	×
87	linked[utils.Config.Auth.Image] = version	×
88	}	×
89	}()
90	go func() {	×
91	defer wg.Done()	×
92	if version, err := api.GetPostgrestVersion(ctx); err == nil {	×
93	linked[utils.Config.Api.Image] = version	×
94	}	×
95	}()
96	go func() {	×
97	defer wg.Done()	×
98	if version, err := api.GetStorageVersion(ctx); err == nil {	×
99	linked[utils.Config.Storage.Image] = version	×
100	}	×
101	}()
102	wg.Wait()	×
103	return linked	×
104	}
105
106	func suggestUpdateCmd(serviceImages map[string]string) string {	×
107	cmd := fmt.Sprintln(utils.Yellow("WARNING:"), "You are running different service versions locally than your linked project:")	×
108	for k, v := range serviceImages {	×
109	cmd += fmt.Sprintf("%s => %s\n", k, v)	×
110	}	×
111	cmd += fmt.Sprintf("Run %s to update them.", utils.Aqua("supabase link"))	×
112	return cmd	×
113	}

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