diff --git a/internal/cmd/oidctrust/create.go b/internal/cmd/oidctrust/create.go new file mode 100644 index 00000000..561e37a0 --- /dev/null +++ b/internal/cmd/oidctrust/create.go @@ -0,0 +1,77 @@ +package oidctrust + +import ( + "fmt" + + "github.com/planetscale/cli/internal/cmdutil" + ps "github.com/planetscale/cli/internal/planetscale" + "github.com/planetscale/cli/internal/printer" + "github.com/spf13/cobra" +) + +func CreateCmd(ch *cmdutil.Helper) *cobra.Command { + var flags struct { + name string + provider string + maxTTL int + conditions []string + orgAccesses []string + databaseAccesses []string + allDatabasesAccesses []string + } + + cmd := &cobra.Command{ + Use: "create", + Short: "Create an OIDC trust", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, args []string) error { + conditions, err := parseConditions(flags.conditions) + if err != nil { + return err + } + accesses, err := parseAccesses(flags.orgAccesses, flags.databaseAccesses) + if err != nil { + return err + } + + client, err := ch.Client() + if err != nil { + return err + } + + end := ch.Printer.PrintProgress(fmt.Sprintf("Creating OIDC trust %s", printer.BoldBlue(flags.name))) + defer end() + + trust, err := client.OIDCTrusts.Create(cmd.Context(), &ps.CreateOIDCTrustRequest{ + Organization: ch.Config.Organization, + DisplayName: flags.name, + Provider: flags.provider, + MaxTTLSeconds: flags.maxTTL, + Conditions: conditions, + Accesses: accesses, + BulkDatabaseAccesses: flags.allDatabasesAccesses, + }) + if err != nil { + return cmdutil.HandleError(err) + } + + end() + + return ch.Printer.PrintResource(toOIDCTrust(trust)) + }, + } + + cmd.Flags().StringVar(&flags.name, "name", "", "The display name of the trust (required)") + cmd.Flags().StringVar(&flags.provider, "provider", "", "The identity provider; run `pscale oidc-trust providers` to list them (required)") + cmd.Flags().IntVar(&flags.maxTTL, "max-ttl", 0, "The maximum token lifetime in seconds (required)") + cmd.Flags().StringArrayVar(&flags.conditions, "condition", nil, "A claim the token must match, as claim=value; repeatable") + cmd.Flags().StringArrayVar(&flags.orgAccesses, "org-access", nil, "An organization access to grant; repeatable") + cmd.Flags().StringArrayVar(&flags.databaseAccesses, "database-access", nil, "A database access to grant, as database:access; repeatable") + cmd.Flags().StringArrayVar(&flags.allDatabasesAccesses, "all-databases-access", nil, "An access to grant on all databases; repeatable") + + cmd.MarkFlagRequired("name") // nolint:errcheck + cmd.MarkFlagRequired("provider") // nolint:errcheck + cmd.MarkFlagRequired("max-ttl") // nolint:errcheck + + return cmd +} diff --git a/internal/cmd/oidctrust/create_test.go b/internal/cmd/oidctrust/create_test.go new file mode 100644 index 00000000..80670333 --- /dev/null +++ b/internal/cmd/oidctrust/create_test.go @@ -0,0 +1,94 @@ +package oidctrust + +import ( + "bytes" + "context" + "testing" + + qt "github.com/frankban/quicktest" + "github.com/planetscale/cli/internal/cmdutil" + "github.com/planetscale/cli/internal/config" + "github.com/planetscale/cli/internal/mock" + ps "github.com/planetscale/cli/internal/planetscale" + "github.com/planetscale/cli/internal/printer" +) + +func TestParseConditionsAndAccesses(t *testing.T) { + c := qt.New(t) + + conds, err := parseConditions([]string{"repository=acme/app", "sub=a=b", "empty="}) + c.Assert(err, qt.IsNil) + c.Assert(conds, qt.DeepEquals, []ps.OIDCTrustConditionInput{ + {Claim: "repository", Value: "acme/app"}, + {Claim: "sub", Value: "a=b"}, + {Claim: "empty", Value: ""}, + }) + + for _, bad := range []string{"noequals", "=value"} { + _, err = parseConditions([]string{bad}) + c.Assert(err, qt.ErrorMatches, `invalid --condition ".*": expected claim=value`) + } + + accesses, err := parseAccesses(nil, nil) + c.Assert(err, qt.IsNil) + c.Assert(accesses, qt.DeepEquals, []ps.OIDCTrustAccessInput{}) + + accesses, err = parseAccesses([]string{"create_databases"}, []string{"mydb:connect_branch", "db:a:b"}) + c.Assert(err, qt.IsNil) + c.Assert(accesses, qt.DeepEquals, []ps.OIDCTrustAccessInput{ + {Access: "create_databases"}, + {Access: "connect_branch", Database: "mydb"}, + {Access: "a:b", Database: "db"}, + }) + + for _, bad := range []string{"nocolon", ":access", "db:"} { + _, err = parseAccesses(nil, []string{bad}) + c.Assert(err, qt.ErrorMatches, `invalid --database-access ".*": expected database:access`) + } +} + +func TestOIDCTrust_CreateCmd(t *testing.T) { + c := qt.New(t) + + svc := &mock.OIDCTrustsService{ + CreateFn: func(ctx context.Context, req *ps.CreateOIDCTrustRequest) (*ps.OIDCTrust, error) { + c.Assert(req, qt.DeepEquals, &ps.CreateOIDCTrustRequest{ + Organization: "planetscale", + DisplayName: "CI", + Provider: "github", + MaxTTLSeconds: 3600, + Conditions: []ps.OIDCTrustConditionInput{ + {Claim: "repository", Value: "acme/app"}, + {Claim: "ref", Value: "refs/heads/main"}, + }, + Accesses: []ps.OIDCTrustAccessInput{ + {Access: "create_databases"}, + {Access: "connect_branch", Database: "mydb"}, + }, + BulkDatabaseAccesses: []string{"read_branch"}, + }) + return &ps.OIDCTrust{ID: "trust-1"}, nil + }, + } + + var buf bytes.Buffer + format := printer.JSON + p := printer.NewPrinter(&format) + p.SetResourceOutput(&buf) + ch := &cmdutil.Helper{ + Printer: p, + Config: &config.Config{Organization: "planetscale"}, + Client: func() (*ps.Client, error) { return &ps.Client{OIDCTrusts: svc}, nil }, + } + + cmd := CreateCmd(ch) + cmd.SetArgs([]string{ + "--name", "CI", "--provider", "github", "--max-ttl", "3600", + "--condition", "repository=acme/app", "--condition", "ref=refs/heads/main", + "--org-access", "create_databases", + "--database-access", "mydb:connect_branch", + "--all-databases-access", "read_branch", + }) + c.Assert(cmd.Execute(), qt.IsNil) + c.Assert(svc.CreateFnInvoked, qt.IsTrue) +} diff --git a/internal/cmd/oidctrust/oidctrust.go b/internal/cmd/oidctrust/oidctrust.go index 6dcb72df..3e069ea3 100644 --- a/internal/cmd/oidctrust/oidctrust.go +++ b/internal/cmd/oidctrust/oidctrust.go @@ -22,6 +22,7 @@ func OIDCTrustCmd(ch *cmdutil.Helper) *cobra.Command { cmd.PersistentFlags().StringVar(&ch.Config.Organization, "org", ch.Config.Organization, "The organization for the current user") cmd.MarkPersistentFlagRequired("org") // nolint:errcheck + cmd.AddCommand(CreateCmd(ch)) cmd.AddCommand(ListCmd(ch)) cmd.AddCommand(ProvidersCmd(ch)) cmd.AddCommand(ShowCmd(ch)) @@ -81,3 +82,30 @@ func toOIDCTrust(t *ps.OIDCTrust) *OIDCTrust { orig: t, } } + +func parseConditions(values []string) ([]ps.OIDCTrustConditionInput, error) { + conditions := make([]ps.OIDCTrustConditionInput, 0, len(values)) + for _, v := range values { + claim, value, ok := strings.Cut(v, "=") + if !ok || claim == "" { + return nil, fmt.Errorf("invalid --condition %q: expected claim=value", v) + } + conditions = append(conditions, ps.OIDCTrustConditionInput{Claim: claim, Value: value}) + } + return conditions, nil +} + +func parseAccesses(orgAccesses, databaseAccesses []string) ([]ps.OIDCTrustAccessInput, error) { + accesses := make([]ps.OIDCTrustAccessInput, 0, len(orgAccesses)+len(databaseAccesses)) + for _, a := range orgAccesses { + accesses = append(accesses, ps.OIDCTrustAccessInput{Access: a}) + } + for _, v := range databaseAccesses { + database, access, ok := strings.Cut(v, ":") + if !ok || database == "" || access == "" { + return nil, fmt.Errorf("invalid --database-access %q: expected database:access", v) + } + accesses = append(accesses, ps.OIDCTrustAccessInput{Access: access, Database: database}) + } + return accesses, nil +} diff --git a/internal/mock/oidc_trust.go b/internal/mock/oidc_trust.go index cd3f4018..5c73617c 100644 --- a/internal/mock/oidc_trust.go +++ b/internal/mock/oidc_trust.go @@ -15,6 +15,9 @@ type OIDCTrustsService struct { GetFn func(context.Context, *ps.GetOIDCTrustRequest) (*ps.OIDCTrust, error) GetFnInvoked bool + + CreateFn func(context.Context, *ps.CreateOIDCTrustRequest) (*ps.OIDCTrust, error) + CreateFnInvoked bool } func (s *OIDCTrustsService) ListProviders(ctx context.Context, req *ps.ListOIDCTrustProvidersRequest) ([]*ps.OIDCTrustProvider, error) { @@ -31,3 +34,8 @@ func (s *OIDCTrustsService) Get(ctx context.Context, req *ps.GetOIDCTrustRequest s.GetFnInvoked = true return s.GetFn(ctx, req) } + +func (s *OIDCTrustsService) Create(ctx context.Context, req *ps.CreateOIDCTrustRequest) (*ps.OIDCTrust, error) { + s.CreateFnInvoked = true + return s.CreateFn(ctx, req) +} diff --git a/internal/planetscale/oidc_trusts.go b/internal/planetscale/oidc_trusts.go index 63e33ba0..05a2a3c5 100644 --- a/internal/planetscale/oidc_trusts.go +++ b/internal/planetscale/oidc_trusts.go @@ -15,6 +15,7 @@ type OIDCTrustsService interface { ListProviders(context.Context, *ListOIDCTrustProvidersRequest) ([]*OIDCTrustProvider, error) List(context.Context, *ListOIDCTrustsRequest, ...ListOption) ([]*OIDCTrust, error) Get(context.Context, *GetOIDCTrustRequest) (*OIDCTrust, error) + Create(context.Context, *CreateOIDCTrustRequest) (*OIDCTrust, error) } // OIDCTrust represents a trust between an organization and an identity provider. @@ -138,3 +139,49 @@ func oidcTrustsAPIPath(org string) string { func oidcTrustAPIPath(org, id string) string { return path.Join(oidcTrustsAPIPath(org), id) } + +// OIDCTrustConditionInput is a claim condition to set on a trust. +type OIDCTrustConditionInput struct { + Claim string `json:"claim"` + Value string `json:"value"` +} + +// OIDCTrustAccessInput is an access to grant. An empty Database grants the +// access on the organization. +type OIDCTrustAccessInput struct { + Access string `json:"access"` + Database string `json:"database,omitempty"` +} + +// CreateOIDCTrustRequest is the request for creating an OIDC trust. +type CreateOIDCTrustRequest struct { + Organization string `json:"-"` + DisplayName string `json:"display_name"` + Provider string `json:"provider"` + MaxTTLSeconds int `json:"max_ttl_seconds"` + Conditions []OIDCTrustConditionInput `json:"conditions"` + Accesses []OIDCTrustAccessInput `json:"accesses"` + BulkDatabaseAccesses []string `json:"bulk_database_accesses,omitempty"` +} + +func (s *oidcTrustsService) Create(ctx context.Context, createReq *CreateOIDCTrustRequest) (*OIDCTrust, error) { + body := *createReq + if body.Conditions == nil { + body.Conditions = []OIDCTrustConditionInput{} + } + if body.Accesses == nil { + body.Accesses = []OIDCTrustAccessInput{} + } + + req, err := s.client.newRequest(http.MethodPost, oidcTrustsAPIPath(createReq.Organization), &body) + if err != nil { + return nil, err + } + + trust := &OIDCTrust{} + if err := s.client.do(ctx, req, &trust); err != nil { + return nil, err + } + + return trust, nil +} diff --git a/internal/planetscale/oidc_trusts_test.go b/internal/planetscale/oidc_trusts_test.go index 0c94ce9f..695cd3c4 100644 --- a/internal/planetscale/oidc_trusts_test.go +++ b/internal/planetscale/oidc_trusts_test.go @@ -2,6 +2,8 @@ package planetscale import ( "context" + "encoding/json" + "io" "net/http" "net/http/httptest" "testing" @@ -85,3 +87,53 @@ func TestOIDCTrusts_Get(t *testing.T) { BulkDatabaseAccesses: []string{"read_branch"}, }) } + +func TestOIDCTrusts_Create(t *testing.T) { + c := qt.New(t) + + ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + c.Assert(r.Method, qt.Equals, http.MethodPost) + c.Assert(r.URL.String(), qt.Equals, "/v1/organizations/my-org/oidc-trusts") + body, err := io.ReadAll(r.Body) + c.Assert(err, qt.IsNil) + c.Assert(string(body), qt.JSONEquals, map[string]any{ + "display_name": "CI", + "provider": "github", + "max_ttl_seconds": 3600, + "conditions": []map[string]string{{"claim": "repository", "value": "acme/app"}}, + "accesses": []map[string]string{ + {"access": "create_databases"}, + {"access": "connect_branch", "database": "mydb"}, + }, + "bulk_database_accesses": []string{"read_branch"}, + }) + + w.WriteHeader(201) + _, err = w.Write([]byte(`{"id": "trust-1"}`)) + c.Assert(err, qt.IsNil) + })) + defer ts.Close() + + client, err := NewClient(WithBaseURL(ts.URL)) + c.Assert(err, qt.IsNil) + + trust, err := client.OIDCTrusts.Create(context.Background(), &CreateOIDCTrustRequest{ + Organization: testOrg, + DisplayName: "CI", + Provider: "github", + MaxTTLSeconds: 3600, + Conditions: []OIDCTrustConditionInput{{Claim: "repository", Value: "acme/app"}}, + Accesses: []OIDCTrustAccessInput{ + {Access: "create_databases"}, + {Access: "connect_branch", Database: "mydb"}, + }, + BulkDatabaseAccesses: []string{"read_branch"}, + }) + c.Assert(err, qt.IsNil) + c.Assert(trust.ID, qt.Equals, "trust-1") + + // Empty lists must encode as [], not null. + b, err := json.Marshal(&CreateOIDCTrustRequest{Conditions: []OIDCTrustConditionInput{}, Accesses: []OIDCTrustAccessInput{}}) + c.Assert(err, qt.IsNil) + c.Assert(string(b), qt.Contains, `"conditions":[],"accesses":[]`) +}