18484197182

Committed 14 Oct 2025 03:06AM UTC coverage: 54.597% (-0.09%) from 54.687%

Build # 18484197182

Build Type

Pull #4306

github

Committed by

web-flow

Commit Message

Merge 62a05d28d into 068afe697

Pull Request Pull Request #4306: chore: modernise golang code

Run Details

12 of 25 new or added lines in 14 files covered. (48.0%)

5 existing lines in 1 file now uncovered.

6390 of 11704 relevant lines covered (54.6%)

6.07 hits per line

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

54.67

/internal/sso/update/update.go

package update

import (
        "context"
        "net/http"
        "os"

        "github.com/go-errors/errors"
        "github.com/google/uuid"
        "github.com/spf13/afero"
        "github.com/supabase/cli/internal/sso/internal/render"
        "github.com/supabase/cli/internal/sso/internal/saml"
        "github.com/supabase/cli/internal/utils"
        "github.com/supabase/cli/pkg/api"
)

var Fs = afero.NewOsFs()

type RunParams struct {
        ProjectRef string
        ProviderID string
        Format     string

        MetadataFile      string
        MetadataURL       string
        SkipURLValidation bool
        AttributeMapping  string

        Domains       []string
        AddDomains    []string
        RemoveDomains []string
}

func Run(ctx context.Context, params RunParams) error {
        parsed, err := uuid.Parse(params.ProviderID)
        if err != nil {
                return errors.Errorf("failed to parse provider ID: %w", err)
        }
        getResp, err := utils.GetSupabase().V1GetASsoProviderWithResponse(ctx, params.ProjectRef, parsed)
        if err != nil {
                return errors.Errorf("failed to get sso provider: %w", err)
        }

        if getResp.JSON200 == nil {
                if getResp.StatusCode() == http.StatusNotFound {
                        return errors.Errorf("An identity provider with ID %q could not be found.", parsed)
                }

                return errors.New("unexpected error fetching identity provider: " + string(getResp.Body))
        }

        var body api.V1UpdateASsoProviderJSONRequestBody

        if params.MetadataFile != "" {
                data, err := saml.ReadMetadataFile(Fs, params.MetadataFile)
                if err != nil {
                        return err
                }

                body.MetadataXml = &data
        } else if params.MetadataURL != "" {
                if !params.SkipURLValidation {
                        if err := saml.ValidateMetadataURL(ctx, params.MetadataURL); err != nil {
                                return errors.Errorf("%w Use --skip-url-validation to suppress this error.", err)
                        }
                }

                body.MetadataUrl = &params.MetadataURL
        }

        if params.AttributeMapping != "" {
                body.AttributeMapping = &struct {
                        Keys map[string]struct {
                                Array   *bool     "json:\"array,omitempty\""
                                Default *any      "json:\"default,omitempty\""
                                Name    *string   "json:\"name,omitempty\""
                                Names   *[]string "json:\"names,omitempty\""
                        } "json:\"keys\""
                }{}
                if err := saml.ReadAttributeMappingFile(Fs, params.AttributeMapping, body.AttributeMapping); err != nil {
                        return err
                }
        }

        if len(params.Domains) != 0 {
                body.Domains = &params.Domains
        } else if params.AddDomains != nil || params.RemoveDomains != nil {
                domainsSet := make(map[string]bool)

                if getResp.JSON200.Domains != nil {
                        for _, domain := range *getResp.JSON200.Domains {
                                if domain.Domain != nil {
                                        domainsSet[*domain.Domain] = true
                                }
                        }
                }

                for _, rmDomain := range params.RemoveDomains {
                        delete(domainsSet, rmDomain)
                }

                for _, addDomain := range params.AddDomains {
                        domainsSet[addDomain] = true
                }

                domains := make([]string, 0)
                for domain := range domainsSet {
                        domains = append(domains, domain)
                }

                body.Domains = &domains
        }

        putResp, err := utils.GetSupabase().V1UpdateASsoProviderWithResponse(ctx, params.ProjectRef, parsed, body)
        if err != nil {
                return errors.Errorf("failed to update sso provider: %w", err)
        }

        if putResp.JSON200 == nil {
                return errors.New("unexpected error fetching identity provider: " + string(putResp.Body))
        }

        switch params.Format {
        case utils.OutputPretty:
                return render.SingleMarkdown(api.GetProviderResponse(*putResp.JSON200))
        case utils.OutputEnv:
                return nil
        default:
                return utils.EncodeOutput(params.Format, os.Stdout, putResp.JSON200)
        }
}

1	package update
2
3	import (
4	"context"
5	"net/http"
6	"os"
7
8	"github.com/go-errors/errors"
9	"github.com/google/uuid"
10	"github.com/spf13/afero"
11	"github.com/supabase/cli/internal/sso/internal/render"
12	"github.com/supabase/cli/internal/sso/internal/saml"
13	"github.com/supabase/cli/internal/utils"
14	"github.com/supabase/cli/pkg/api"
15	)
16
17	var Fs = afero.NewOsFs()
18
19	type RunParams struct {
20	ProjectRef string
21	ProviderID string
22	Format string
23
24	MetadataFile string
25	MetadataURL string
26	SkipURLValidation bool
27	AttributeMapping string
28
29	Domains []string
30	AddDomains []string
31	RemoveDomains []string
32	}
33
34	func Run(ctx context.Context, params RunParams) error {	3✔
35	parsed, err := uuid.Parse(params.ProviderID)	3✔
36	if err != nil {	3✔
37	return errors.Errorf("failed to parse provider ID: %w", err)	×
38	}	×
39	getResp, err := utils.GetSupabase().V1GetASsoProviderWithResponse(ctx, params.ProjectRef, parsed)	3✔
40	if err != nil {	3✔
41	return errors.Errorf("failed to get sso provider: %w", err)	×
42	}	×
43
44	if getResp.JSON200 == nil {	4✔
45	if getResp.StatusCode() == http.StatusNotFound {	2✔
46	return errors.Errorf("An identity provider with ID %q could not be found.", parsed)	1✔
47	}	1✔
48
49	return errors.New("unexpected error fetching identity provider: " + string(getResp.Body))	×
50	}
51
52	var body api.V1UpdateASsoProviderJSONRequestBody	2✔
53		2✔
54	if params.MetadataFile != "" {	2✔
55	data, err := saml.ReadMetadataFile(Fs, params.MetadataFile)	×
56	if err != nil {	×
57	return err	×
58	}	×
59
60	body.MetadataXml = &data	×
61	} else if params.MetadataURL != "" {	2✔
62	if !params.SkipURLValidation {	×
63	if err := saml.ValidateMetadataURL(ctx, params.MetadataURL); err != nil {	×
64	return errors.Errorf("%w Use --skip-url-validation to suppress this error.", err)	×
65	}	×
66	}
67
68	body.MetadataUrl = &params.MetadataURL	×
69	}
70
71	if params.AttributeMapping != "" {	2✔
72	body.AttributeMapping = &struct {	×
73	Keys map[string]struct {	×
NEW 74	Array *bool "json:\"array,omitempty\""	×
NEW 75	Default *any "json:\"default,omitempty\""	×
NEW 76	Name *string "json:\"name,omitempty\""	×
NEW 77	Names *[]string "json:\"names,omitempty\""	×
78	} "json:\"keys\""	×
79	}{}	×
80	if err := saml.ReadAttributeMappingFile(Fs, params.AttributeMapping, body.AttributeMapping); err != nil {	×
81	return err	×
82	}	×
83	}
84
85	if len(params.Domains) != 0 {	3✔
86	body.Domains = &params.Domains	1✔
87	} else if params.AddDomains != nil \|\| params.RemoveDomains != nil {	3✔
88	domainsSet := make(map[string]bool)	1✔
89		1✔
90	if getResp.JSON200.Domains != nil {	2✔
91	for _, domain := range *getResp.JSON200.Domains {	2✔
92	if domain.Domain != nil {	2✔
93	domainsSet[*domain.Domain] = true	1✔
94	}	1✔
95	}
96	}
97
98	for _, rmDomain := range params.RemoveDomains {	2✔
99	delete(domainsSet, rmDomain)	1✔
100	}	1✔
101
102	for _, addDomain := range params.AddDomains {	2✔
103	domainsSet[addDomain] = true	1✔
104	}	1✔
105
106	domains := make([]string, 0)	1✔
107	for domain := range domainsSet {	2✔
108	domains = append(domains, domain)	1✔
109	}	1✔
110
111	body.Domains = &domains	1✔
112	}
113
114	putResp, err := utils.GetSupabase().V1UpdateASsoProviderWithResponse(ctx, params.ProjectRef, parsed, body)	2✔
115	if err != nil {	2✔
116	return errors.Errorf("failed to update sso provider: %w", err)	×
117	}	×
118
119	if putResp.JSON200 == nil {	2✔
120	return errors.New("unexpected error fetching identity provider: " + string(putResp.Body))	×
121	}	×
122
123	switch params.Format {	2✔
124	case utils.OutputPretty:	2✔
125	return render.SingleMarkdown(api.GetProviderResponse(*putResp.JSON200))	2✔
126	case utils.OutputEnv:	×
127	return nil	×
128	default:	×
129	return utils.EncodeOutput(params.Format, os.Stdout, putResp.JSON200)	×
130	}
131	}

supabase / cli / 18484197182

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