19625601168

Committed 24 Nov 2025 06:38AM UTC coverage: 55.069% (-0.04%) from 55.108%

Build # 19625601168

Build Type

Pull #4477

github

Committed by

web-flow

Commit Message

Merge c380f11c5 into 4a90b4fce

Pull Request Pull Request #4477: feat: add `--name-id-format` flag to `sso add` and `sso update`

Run Details

10 of 21 new or added lines in 4 files covered. (47.62%)

5 existing lines in 1 file now uncovered.

6540 of 11876 relevant lines covered (55.07%)

6.26 hits per line

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

53.85

/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"
        "github.com/supabase/cli/pkg/cast"
)

var Fs = afero.NewOsFs()

type RunParams struct {
        ProjectRef string
        ProviderID string
        Format     string

        MetadataFile      string
        MetadataURL       string
        SkipURLValidation bool
        AttributeMapping  string
        NameIDFormat      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
        }

        if params.NameIDFormat != "" {
                body.NameIdFormat = cast.Ptr(api.UpdateProviderBodyNameIdFormat(params.NameIDFormat))
        }

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

supabase / cli / 19625601168

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