code
stringlengths 22
3.95M
| docstring
stringlengths 20
17.8k
| func_name
stringlengths 1
472
| language
stringclasses 1
value | repo
stringlengths 6
57
| path
stringlengths 4
226
| url
stringlengths 43
277
| license
stringclasses 7
values |
|---|---|---|---|---|---|---|---|
func NewPostInviteRequest(server string, body PostInviteJSONRequestBody) (*http.Request, error) {
var bodyReader io.Reader
buf, err := json.Marshal(body)
if err != nil {
return nil, err
}
bodyReader = bytes.NewReader(buf)
return NewPostInviteRequestWithBody(server, "application/json", bodyReader)
}
|
NewPostInviteRequest calls the generic PostInvite builder with application/json body
|
NewPostInviteRequest
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func NewPostInviteRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) {
var err error
serverURL, err := url.Parse(server)
if err != nil {
return nil, err
}
operationPath := fmt.Sprintf("/invite")
if operationPath[0] == '/' {
operationPath = "." + operationPath
}
queryURL, err := serverURL.Parse(operationPath)
if err != nil {
return nil, err
}
req, err := http.NewRequest("POST", queryURL.String(), body)
if err != nil {
return nil, err
}
req.Header.Add("Content-Type", contentType)
return req, nil
}
|
NewPostInviteRequestWithBody generates requests for PostInvite with any type of body
|
NewPostInviteRequestWithBody
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func NewClientWithResponses(server string, opts ...ClientOption) (*ClientWithResponses, error) {
client, err := NewClient(server, opts...)
if err != nil {
return nil, err
}
return &ClientWithResponses{client}, nil
}
|
NewClientWithResponses creates a new ClientWithResponses, which wraps
Client with return type handling
|
NewClientWithResponses
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func (c *ClientWithResponses) PostAdminGenerateLinkWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostAdminGenerateLinkResponse, error) {
rsp, err := c.PostAdminGenerateLinkWithBody(ctx, contentType, body, reqEditors...)
if err != nil {
return nil, err
}
return ParsePostAdminGenerateLinkResponse(rsp)
}
|
PostAdminGenerateLinkWithBodyWithResponse request with arbitrary body returning *PostAdminGenerateLinkResponse
|
PostAdminGenerateLinkWithBodyWithResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func (c *ClientWithResponses) PostAdminSsoProvidersWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostAdminSsoProvidersResponse, error) {
rsp, err := c.PostAdminSsoProvidersWithBody(ctx, contentType, body, reqEditors...)
if err != nil {
return nil, err
}
return ParsePostAdminSsoProvidersResponse(rsp)
}
|
PostAdminSsoProvidersWithBodyWithResponse request with arbitrary body returning *PostAdminSsoProvidersResponse
|
PostAdminSsoProvidersWithBodyWithResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func (c *ClientWithResponses) PutAdminSsoProvidersSsoProviderIdWithBodyWithResponse(ctx context.Context, ssoProviderId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutAdminSsoProvidersSsoProviderIdResponse, error) {
rsp, err := c.PutAdminSsoProvidersSsoProviderIdWithBody(ctx, ssoProviderId, contentType, body, reqEditors...)
if err != nil {
return nil, err
}
return ParsePutAdminSsoProvidersSsoProviderIdResponse(rsp)
}
|
PutAdminSsoProvidersSsoProviderIdWithBodyWithResponse request with arbitrary body returning *PutAdminSsoProvidersSsoProviderIdResponse
|
PutAdminSsoProvidersSsoProviderIdWithBodyWithResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func (c *ClientWithResponses) PutAdminUsersUserIdWithBodyWithResponse(ctx context.Context, userId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutAdminUsersUserIdResponse, error) {
rsp, err := c.PutAdminUsersUserIdWithBody(ctx, userId, contentType, body, reqEditors...)
if err != nil {
return nil, err
}
return ParsePutAdminUsersUserIdResponse(rsp)
}
|
PutAdminUsersUserIdWithBodyWithResponse request with arbitrary body returning *PutAdminUsersUserIdResponse
|
PutAdminUsersUserIdWithBodyWithResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func (c *ClientWithResponses) PutAdminUsersUserIdFactorsFactorIdWithBodyWithResponse(ctx context.Context, userId openapi_types.UUID, factorId openapi_types.UUID, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutAdminUsersUserIdFactorsFactorIdResponse, error) {
rsp, err := c.PutAdminUsersUserIdFactorsFactorIdWithBody(ctx, userId, factorId, contentType, body, reqEditors...)
if err != nil {
return nil, err
}
return ParsePutAdminUsersUserIdFactorsFactorIdResponse(rsp)
}
|
PutAdminUsersUserIdFactorsFactorIdWithBodyWithResponse request with arbitrary body returning *PutAdminUsersUserIdFactorsFactorIdResponse
|
PutAdminUsersUserIdFactorsFactorIdWithBodyWithResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func (c *ClientWithResponses) PostInviteWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostInviteResponse, error) {
rsp, err := c.PostInviteWithBody(ctx, contentType, body, reqEditors...)
if err != nil {
return nil, err
}
return ParsePostInviteResponse(rsp)
}
|
PostInviteWithBodyWithResponse request with arbitrary body returning *PostInviteResponse
|
PostInviteWithBodyWithResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func ParseGetAdminAuditResponse(rsp *http.Response) (*GetAdminAuditResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &GetAdminAuditResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
var dest []struct {
CreatedAt *time.Time `json:"created_at,omitempty"`
Id *openapi_types.UUID `json:"id,omitempty"`
IpAddress *string `json:"ip_address,omitempty"`
Payload *struct {
// Action Usually one of these values:
// - login
// - logout
// - invite_accepted
// - user_signedup
// - user_invited
// - user_deleted
// - user_modified
// - user_recovery_requested
// - user_reauthenticate_requested
// - user_confirmation_requested
// - user_repeated_signup
// - user_updated_password
// - token_revoked
// - token_refreshed
// - generate_recovery_codes
// - factor_in_progress
// - factor_unenrolled
// - challenge_created
// - verification_attempted
// - factor_deleted
// - recovery_codes_deleted
// - factor_updated
// - mfa_code_login
Action *string `json:"action,omitempty"`
ActorId *string `json:"actor_id,omitempty"`
ActorName *string `json:"actor_name,omitempty"`
ActorUsername *string `json:"actor_username,omitempty"`
// ActorViaSso Whether the actor used a SSO protocol (like SAML 2.0 or OIDC) to authenticate.
ActorViaSso *bool `json:"actor_via_sso,omitempty"`
// LogType Usually one of these values:
// - account
// - team
// - token
// - user
// - factor
// - recovery_codes
LogType *string `json:"log_type,omitempty"`
Traits *map[string]interface{} `json:"traits,omitempty"`
} `json:"payload,omitempty"`
}
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON200 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
var dest UnauthorizedResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON401 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
var dest ForbiddenResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON403 = &dest
}
return response, nil
}
|
ParseGetAdminAuditResponse parses an HTTP response from a GetAdminAuditWithResponse call
|
ParseGetAdminAuditResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func ParsePostAdminGenerateLinkResponse(rsp *http.Response) (*PostAdminGenerateLinkResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &PostAdminGenerateLinkResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
var dest struct {
ActionLink *string `json:"action_link,omitempty"`
EmailOtp *string `json:"email_otp,omitempty"`
HashedToken *string `json:"hashed_token,omitempty"`
RedirectTo *string `json:"redirect_to,omitempty"`
VerificationType *string `json:"verification_type,omitempty"`
AdditionalProperties map[string]interface{} `json:"-"`
}
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON200 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
var dest BadRequestResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON400 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
var dest UnauthorizedResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON401 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
var dest ForbiddenResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON403 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
var dest ErrorSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON404 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 422:
var dest ErrorSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON422 = &dest
}
return response, nil
}
|
ParsePostAdminGenerateLinkResponse parses an HTTP response from a PostAdminGenerateLinkWithResponse call
|
ParsePostAdminGenerateLinkResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func ParseGetAdminSsoProvidersResponse(rsp *http.Response) (*GetAdminSsoProvidersResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &GetAdminSsoProvidersResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
var dest struct {
Items *[]SSOProviderSchema `json:"items,omitempty"`
}
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON200 = &dest
}
return response, nil
}
|
ParseGetAdminSsoProvidersResponse parses an HTTP response from a GetAdminSsoProvidersWithResponse call
|
ParseGetAdminSsoProvidersResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func ParsePostAdminSsoProvidersResponse(rsp *http.Response) (*PostAdminSsoProvidersResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &PostAdminSsoProvidersResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
var dest SSOProviderSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON200 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
var dest BadRequestResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON400 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
var dest UnauthorizedResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON401 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
var dest ForbiddenResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON403 = &dest
}
return response, nil
}
|
ParsePostAdminSsoProvidersResponse parses an HTTP response from a PostAdminSsoProvidersWithResponse call
|
ParsePostAdminSsoProvidersResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func ParseDeleteAdminSsoProvidersSsoProviderIdResponse(rsp *http.Response) (*DeleteAdminSsoProvidersSsoProviderIdResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &DeleteAdminSsoProvidersSsoProviderIdResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
var dest SSOProviderSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON200 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
var dest UnauthorizedResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON401 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
var dest ForbiddenResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON403 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
var dest ErrorSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON404 = &dest
}
return response, nil
}
|
ParseDeleteAdminSsoProvidersSsoProviderIdResponse parses an HTTP response from a DeleteAdminSsoProvidersSsoProviderIdWithResponse call
|
ParseDeleteAdminSsoProvidersSsoProviderIdResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func ParseGetAdminSsoProvidersSsoProviderIdResponse(rsp *http.Response) (*GetAdminSsoProvidersSsoProviderIdResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &GetAdminSsoProvidersSsoProviderIdResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
var dest SSOProviderSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON200 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
var dest UnauthorizedResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON401 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
var dest ForbiddenResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON403 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
var dest ErrorSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON404 = &dest
}
return response, nil
}
|
ParseGetAdminSsoProvidersSsoProviderIdResponse parses an HTTP response from a GetAdminSsoProvidersSsoProviderIdWithResponse call
|
ParseGetAdminSsoProvidersSsoProviderIdResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func ParsePutAdminSsoProvidersSsoProviderIdResponse(rsp *http.Response) (*PutAdminSsoProvidersSsoProviderIdResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &PutAdminSsoProvidersSsoProviderIdResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
var dest SSOProviderSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON200 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
var dest BadRequestResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON400 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
var dest UnauthorizedResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON401 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
var dest ForbiddenResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON403 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
var dest ErrorSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON404 = &dest
}
return response, nil
}
|
ParsePutAdminSsoProvidersSsoProviderIdResponse parses an HTTP response from a PutAdminSsoProvidersSsoProviderIdWithResponse call
|
ParsePutAdminSsoProvidersSsoProviderIdResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func ParseGetAdminUsersResponse(rsp *http.Response) (*GetAdminUsersResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &GetAdminUsersResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
var dest struct {
// Deprecated:
Aud *string `json:"aud,omitempty"`
Users *[]UserSchema `json:"users,omitempty"`
}
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON200 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
var dest UnauthorizedResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON401 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
var dest ForbiddenResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON403 = &dest
}
return response, nil
}
|
ParseGetAdminUsersResponse parses an HTTP response from a GetAdminUsersWithResponse call
|
ParseGetAdminUsersResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func ParseDeleteAdminUsersUserIdResponse(rsp *http.Response) (*DeleteAdminUsersUserIdResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &DeleteAdminUsersUserIdResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
var dest UserSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON200 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
var dest UnauthorizedResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON401 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
var dest ForbiddenResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON403 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
var dest ErrorSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON404 = &dest
}
return response, nil
}
|
ParseDeleteAdminUsersUserIdResponse parses an HTTP response from a DeleteAdminUsersUserIdWithResponse call
|
ParseDeleteAdminUsersUserIdResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func ParseGetAdminUsersUserIdResponse(rsp *http.Response) (*GetAdminUsersUserIdResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &GetAdminUsersUserIdResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
var dest UserSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON200 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
var dest UnauthorizedResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON401 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
var dest ForbiddenResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON403 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
var dest ErrorSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON404 = &dest
}
return response, nil
}
|
ParseGetAdminUsersUserIdResponse parses an HTTP response from a GetAdminUsersUserIdWithResponse call
|
ParseGetAdminUsersUserIdResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func ParsePutAdminUsersUserIdResponse(rsp *http.Response) (*PutAdminUsersUserIdResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &PutAdminUsersUserIdResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
var dest UserSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON200 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
var dest UnauthorizedResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON401 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
var dest ForbiddenResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON403 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
var dest ErrorSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON404 = &dest
}
return response, nil
}
|
ParsePutAdminUsersUserIdResponse parses an HTTP response from a PutAdminUsersUserIdWithResponse call
|
ParsePutAdminUsersUserIdResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func ParseGetAdminUsersUserIdFactorsResponse(rsp *http.Response) (*GetAdminUsersUserIdFactorsResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &GetAdminUsersUserIdFactorsResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
var dest []MFAFactorSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON200 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
var dest UnauthorizedResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON401 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
var dest ForbiddenResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON403 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
var dest ErrorSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON404 = &dest
}
return response, nil
}
|
ParseGetAdminUsersUserIdFactorsResponse parses an HTTP response from a GetAdminUsersUserIdFactorsWithResponse call
|
ParseGetAdminUsersUserIdFactorsResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func ParseDeleteAdminUsersUserIdFactorsFactorIdResponse(rsp *http.Response) (*DeleteAdminUsersUserIdFactorsFactorIdResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &DeleteAdminUsersUserIdFactorsFactorIdResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
var dest MFAFactorSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON200 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
var dest UnauthorizedResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON401 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
var dest ForbiddenResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON403 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
var dest ErrorSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON404 = &dest
}
return response, nil
}
|
ParseDeleteAdminUsersUserIdFactorsFactorIdResponse parses an HTTP response from a DeleteAdminUsersUserIdFactorsFactorIdWithResponse call
|
ParseDeleteAdminUsersUserIdFactorsFactorIdResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func ParsePutAdminUsersUserIdFactorsFactorIdResponse(rsp *http.Response) (*PutAdminUsersUserIdFactorsFactorIdResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &PutAdminUsersUserIdFactorsFactorIdResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
var dest MFAFactorSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON200 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401:
var dest UnauthorizedResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON401 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403:
var dest ForbiddenResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON403 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404:
var dest ErrorSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON404 = &dest
}
return response, nil
}
|
ParsePutAdminUsersUserIdFactorsFactorIdResponse parses an HTTP response from a PutAdminUsersUserIdFactorsFactorIdWithResponse call
|
ParsePutAdminUsersUserIdFactorsFactorIdResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func ParsePostInviteResponse(rsp *http.Response) (*PostInviteResponse, error) {
bodyBytes, err := io.ReadAll(rsp.Body)
defer func() { _ = rsp.Body.Close() }()
if err != nil {
return nil, err
}
response := &PostInviteResponse{
Body: bodyBytes,
HTTPResponse: rsp,
}
switch {
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200:
var dest UserSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON200 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
var dest BadRequestResponse
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON400 = &dest
case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 422:
var dest ErrorSchema
if err := json.Unmarshal(bodyBytes, &dest); err != nil {
return nil, err
}
response.JSON422 = &dest
}
return response, nil
}
|
ParsePostInviteResponse parses an HTTP response from a PostInviteWithResponse call
|
ParsePostInviteResponse
|
go
|
supabase/auth
|
client/admin/client.go
|
https://github.com/supabase/auth/blob/master/client/admin/client.go
|
MIT
|
func RootCommand() *cobra.Command {
rootCmd.AddCommand(&serveCmd, &migrateCmd, &versionCmd, adminCmd())
rootCmd.PersistentFlags().StringVarP(&configFile, "config", "c", "", "base configuration file to load")
rootCmd.PersistentFlags().StringVarP(&watchDir, "config-dir", "d", "", "directory containing a sorted list of config files to watch for changes")
return &rootCmd
}
|
RootCommand will setup and return the root command
|
RootCommand
|
go
|
supabase/auth
|
cmd/root_cmd.go
|
https://github.com/supabase/auth/blob/master/cmd/root_cmd.go
|
MIT
|
func (a *API) loadFactor(w http.ResponseWriter, r *http.Request) (context.Context, error) {
ctx := r.Context()
db := a.db.WithContext(ctx)
user := getUser(ctx)
factorID, err := uuid.FromString(chi.URLParam(r, "factor_id"))
if err != nil {
return nil, apierrors.NewNotFoundError(apierrors.ErrorCodeValidationFailed, "factor_id must be an UUID")
}
observability.LogEntrySetField(r, "factor_id", factorID)
factor, err := user.FindOwnedFactorByID(db, factorID)
if err != nil {
if models.IsNotFoundError(err) {
return nil, apierrors.NewNotFoundError(apierrors.ErrorCodeMFAFactorNotFound, "Factor not found")
}
return nil, apierrors.NewInternalServerError("Database error loading factor").WithInternalError(err)
}
return withFactor(ctx, factor), nil
}
|
Use only after requireAuthentication, so that there is a valid user
|
loadFactor
|
go
|
supabase/auth
|
internal/api/admin.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin.go
|
MIT
|
func (a *API) adminUsers(w http.ResponseWriter, r *http.Request) error {
ctx := r.Context()
db := a.db.WithContext(ctx)
aud := a.requestAud(ctx, r)
pageParams, err := paginate(r)
if err != nil {
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "Bad Pagination Parameters: %v", err).WithInternalError(err)
}
sortParams, err := sort(r, map[string]bool{models.CreatedAt: true}, []models.SortField{{Name: models.CreatedAt, Dir: models.Descending}})
if err != nil {
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "Bad Sort Parameters: %v", err)
}
filter := r.URL.Query().Get("filter")
users, err := models.FindUsersInAudience(db, aud, pageParams, sortParams, filter)
if err != nil {
return apierrors.NewInternalServerError("Database error finding users").WithInternalError(err)
}
addPaginationHeaders(w, r, pageParams)
return sendJSON(w, http.StatusOK, AdminListUsersResponse{
Users: users,
Aud: aud,
})
}
|
adminUsers responds with a list of all users in a given audience
|
adminUsers
|
go
|
supabase/auth
|
internal/api/admin.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin.go
|
MIT
|
func (a *API) adminUserGet(w http.ResponseWriter, r *http.Request) error {
user := getUser(r.Context())
return sendJSON(w, http.StatusOK, user)
}
|
adminUserGet returns information about a single user
|
adminUserGet
|
go
|
supabase/auth
|
internal/api/admin.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin.go
|
MIT
|
func (a *API) adminUserCreate(w http.ResponseWriter, r *http.Request) error {
ctx := r.Context()
db := a.db.WithContext(ctx)
config := a.config
adminUser := getAdminUser(ctx)
params, err := a.getAdminParams(r)
if err != nil {
return err
}
aud := a.requestAud(ctx, r)
if params.Aud != "" {
aud = params.Aud
}
if params.Email == "" && params.Phone == "" {
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "Cannot create a user without either an email or phone")
}
var providers []string
if params.Email != "" {
params.Email, err = a.validateEmail(params.Email)
if err != nil {
return err
}
if user, err := models.IsDuplicatedEmail(db, params.Email, aud, nil); err != nil {
return apierrors.NewInternalServerError("Database error checking email").WithInternalError(err)
} else if user != nil {
return apierrors.NewUnprocessableEntityError(apierrors.ErrorCodeEmailExists, DuplicateEmailMsg)
}
providers = append(providers, "email")
}
if params.Phone != "" {
params.Phone, err = validatePhone(params.Phone)
if err != nil {
return err
}
if exists, err := models.IsDuplicatedPhone(db, params.Phone, aud); err != nil {
return apierrors.NewInternalServerError("Database error checking phone").WithInternalError(err)
} else if exists {
return apierrors.NewUnprocessableEntityError(apierrors.ErrorCodePhoneExists, "Phone number already registered by another user")
}
providers = append(providers, "phone")
}
if params.Password != nil && params.PasswordHash != "" {
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "Only a password or a password hash should be provided")
}
if (params.Password == nil || *params.Password == "") && params.PasswordHash == "" {
password, err := password.Generate(64, 10, 0, false, true)
if err != nil {
return apierrors.NewInternalServerError("Error generating password").WithInternalError(err)
}
params.Password = &password
}
var user *models.User
if params.PasswordHash != "" {
user, err = models.NewUserWithPasswordHash(params.Phone, params.Email, params.PasswordHash, aud, params.UserMetaData)
} else {
user, err = models.NewUser(params.Phone, params.Email, *params.Password, aud, params.UserMetaData)
}
if err != nil {
if errors.Is(err, bcrypt.ErrPasswordTooLong) {
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, err.Error())
}
return apierrors.NewInternalServerError("Error creating user").WithInternalError(err)
}
if params.Id != "" {
customId, err := uuid.FromString(params.Id)
if err != nil {
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "ID must conform to the uuid v4 format")
}
if customId == uuid.Nil {
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "ID cannot be a nil uuid")
}
user.ID = customId
}
user.AppMetaData = map[string]interface{}{
// TODO: Deprecate "provider" field
// default to the first provider in the providers slice
"provider": providers[0],
"providers": providers,
}
var banDuration *time.Duration
if params.BanDuration != "" {
duration := time.Duration(0)
if params.BanDuration != "none" {
duration, err = time.ParseDuration(params.BanDuration)
if err != nil {
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "invalid format for ban duration: %v", err)
}
}
banDuration = &duration
}
err = db.Transaction(func(tx *storage.Connection) error {
if terr := tx.Create(user); terr != nil {
return terr
}
var identities []models.Identity
if user.GetEmail() != "" {
identity, terr := a.createNewIdentity(tx, user, "email", structs.Map(provider.Claims{
Subject: user.ID.String(),
Email: user.GetEmail(),
}))
if terr != nil {
return terr
}
identities = append(identities, *identity)
}
if user.GetPhone() != "" {
identity, terr := a.createNewIdentity(tx, user, "phone", structs.Map(provider.Claims{
Subject: user.ID.String(),
Phone: user.GetPhone(),
}))
if terr != nil {
return terr
}
identities = append(identities, *identity)
}
user.Identities = identities
if terr := models.NewAuditLogEntry(r, tx, adminUser, models.UserSignedUpAction, "", map[string]interface{}{
"user_id": user.ID,
"user_email": user.Email,
"user_phone": user.Phone,
}); terr != nil {
return terr
}
role := config.JWT.DefaultGroupName
if params.Role != "" {
role = params.Role
}
if terr := user.SetRole(tx, role); terr != nil {
return terr
}
if params.AppMetaData != nil {
if terr := user.UpdateAppMetaData(tx, params.AppMetaData); terr != nil {
return terr
}
}
if params.EmailConfirm {
if terr := user.Confirm(tx); terr != nil {
return terr
}
}
if params.PhoneConfirm {
if terr := user.ConfirmPhone(tx); terr != nil {
return terr
}
}
if banDuration != nil {
if terr := user.Ban(tx, *banDuration); terr != nil {
return terr
}
}
return nil
})
if err != nil {
return apierrors.NewInternalServerError("Database error creating new user").WithInternalError(err)
}
return sendJSON(w, http.StatusOK, user)
}
|
adminUserCreate creates a new user based on the provided data
|
adminUserCreate
|
go
|
supabase/auth
|
internal/api/admin.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin.go
|
MIT
|
func (ts *AdminTestSuite) TestAdminUsersUnauthorized() {
req := httptest.NewRequest(http.MethodGet, "/admin/users", nil)
w := httptest.NewRecorder()
ts.API.handler.ServeHTTP(w, req)
assert.Equal(ts.T(), http.StatusUnauthorized, w.Code)
}
|
TestAdminUsersUnauthorized tests API /admin/users route without authentication
|
TestAdminUsersUnauthorized
|
go
|
supabase/auth
|
internal/api/admin_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin_test.go
|
MIT
|
func (ts *AdminTestSuite) TestAdminUsers() {
// Setup request
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodGet, "/admin/users", nil)
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", ts.token))
ts.API.handler.ServeHTTP(w, req)
require.Equal(ts.T(), http.StatusOK, w.Code)
assert.Equal(ts.T(), "</admin/users?page=0>; rel=\"last\"", w.Header().Get("Link"))
assert.Equal(ts.T(), "0", w.Header().Get("X-Total-Count"))
}
|
TestAdminUsers tests API /admin/users route
|
TestAdminUsers
|
go
|
supabase/auth
|
internal/api/admin_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin_test.go
|
MIT
|
func (ts *AdminTestSuite) TestAdminUsers_Pagination() {
u, err := models.NewUser("12345678", "[email protected]", "test", ts.Config.JWT.Aud, nil)
require.NoError(ts.T(), err, "Error making new user")
require.NoError(ts.T(), ts.API.db.Create(u), "Error creating user")
u, err = models.NewUser("987654321", "[email protected]", "test", ts.Config.JWT.Aud, nil)
require.NoError(ts.T(), err, "Error making new user")
require.NoError(ts.T(), ts.API.db.Create(u), "Error creating user")
// Setup request
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodGet, "/admin/users?per_page=1", nil)
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", ts.token))
ts.API.handler.ServeHTTP(w, req)
require.Equal(ts.T(), http.StatusOK, w.Code)
assert.Equal(ts.T(), "</admin/users?page=2&per_page=1>; rel=\"next\", </admin/users?page=2&per_page=1>; rel=\"last\"", w.Header().Get("Link"))
assert.Equal(ts.T(), "2", w.Header().Get("X-Total-Count"))
data := make(map[string]interface{})
require.NoError(ts.T(), json.NewDecoder(w.Body).Decode(&data))
for _, user := range data["users"].([]interface{}) {
assert.NotEmpty(ts.T(), user)
}
}
|
TestAdminUsers tests API /admin/users route
|
TestAdminUsers_Pagination
|
go
|
supabase/auth
|
internal/api/admin_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin_test.go
|
MIT
|
func (ts *AdminTestSuite) TestAdminUsers_SortAsc() {
u, err := models.NewUser("", "[email protected]", "test", ts.Config.JWT.Aud, nil)
u.CreatedAt = time.Now().Add(-time.Minute)
require.NoError(ts.T(), err, "Error making new user")
require.NoError(ts.T(), ts.API.db.Create(u), "Error creating user")
u, err = models.NewUser("", "[email protected]", "test", ts.Config.JWT.Aud, nil)
u.CreatedAt = time.Now()
require.NoError(ts.T(), err, "Error making new user")
require.NoError(ts.T(), ts.API.db.Create(u), "Error creating user")
// Setup request
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodGet, "/admin/users", nil)
qv := req.URL.Query()
qv.Set("sort", "created_at asc")
req.URL.RawQuery = qv.Encode()
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", ts.token))
ts.API.handler.ServeHTTP(w, req)
require.Equal(ts.T(), http.StatusOK, w.Code)
data := struct {
Users []*models.User `json:"users"`
Aud string `json:"aud"`
}{}
require.NoError(ts.T(), json.NewDecoder(w.Body).Decode(&data))
require.Len(ts.T(), data.Users, 2)
assert.Equal(ts.T(), "[email protected]", data.Users[0].GetEmail())
assert.Equal(ts.T(), "[email protected]", data.Users[1].GetEmail())
}
|
TestAdminUsers tests API /admin/users route
|
TestAdminUsers_SortAsc
|
go
|
supabase/auth
|
internal/api/admin_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin_test.go
|
MIT
|
func (ts *AdminTestSuite) TestAdminUsers_SortDesc() {
u, err := models.NewUser("12345678", "[email protected]", "test", ts.Config.JWT.Aud, nil)
u.CreatedAt = time.Now().Add(-time.Minute)
require.NoError(ts.T(), err, "Error making new user")
require.NoError(ts.T(), ts.API.db.Create(u), "Error creating user")
u, err = models.NewUser("987654321", "[email protected]", "test", ts.Config.JWT.Aud, nil)
u.CreatedAt = time.Now()
require.NoError(ts.T(), err, "Error making new user")
require.NoError(ts.T(), ts.API.db.Create(u), "Error creating user")
// Setup request
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodGet, "/admin/users", nil)
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", ts.token))
ts.API.handler.ServeHTTP(w, req)
require.Equal(ts.T(), http.StatusOK, w.Code)
data := struct {
Users []*models.User `json:"users"`
Aud string `json:"aud"`
}{}
require.NoError(ts.T(), json.NewDecoder(w.Body).Decode(&data))
require.Len(ts.T(), data.Users, 2)
assert.Equal(ts.T(), "[email protected]", data.Users[0].GetEmail())
assert.Equal(ts.T(), "[email protected]", data.Users[1].GetEmail())
}
|
TestAdminUsers tests API /admin/users route
|
TestAdminUsers_SortDesc
|
go
|
supabase/auth
|
internal/api/admin_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin_test.go
|
MIT
|
func (ts *AdminTestSuite) TestAdminUsers_FilterEmail() {
u, err := models.NewUser("", "[email protected]", "test", ts.Config.JWT.Aud, nil)
require.NoError(ts.T(), err, "Error making new user")
require.NoError(ts.T(), ts.API.db.Create(u), "Error creating user")
// Setup request
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodGet, "/admin/users?filter=test1", nil)
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", ts.token))
ts.API.handler.ServeHTTP(w, req)
require.Equal(ts.T(), http.StatusOK, w.Code)
data := struct {
Users []*models.User `json:"users"`
Aud string `json:"aud"`
}{}
require.NoError(ts.T(), json.NewDecoder(w.Body).Decode(&data))
require.Len(ts.T(), data.Users, 1)
assert.Equal(ts.T(), "[email protected]", data.Users[0].GetEmail())
}
|
TestAdminUsers tests API /admin/users route
|
TestAdminUsers_FilterEmail
|
go
|
supabase/auth
|
internal/api/admin_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin_test.go
|
MIT
|
func (ts *AdminTestSuite) TestAdminUsers_FilterName() {
u, err := models.NewUser("", "[email protected]", "test", ts.Config.JWT.Aud, map[string]interface{}{"full_name": "Test User"})
require.NoError(ts.T(), err, "Error making new user")
require.NoError(ts.T(), ts.API.db.Create(u), "Error creating user")
u, err = models.NewUser("", "[email protected]", "test", ts.Config.JWT.Aud, nil)
require.NoError(ts.T(), err, "Error making new user")
require.NoError(ts.T(), ts.API.db.Create(u), "Error creating user")
// Setup request
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodGet, "/admin/users?filter=User", nil)
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", ts.token))
ts.API.handler.ServeHTTP(w, req)
require.Equal(ts.T(), http.StatusOK, w.Code)
data := struct {
Users []*models.User `json:"users"`
Aud string `json:"aud"`
}{}
require.NoError(ts.T(), json.NewDecoder(w.Body).Decode(&data))
require.Len(ts.T(), data.Users, 1)
assert.Equal(ts.T(), "[email protected]", data.Users[0].GetEmail())
}
|
TestAdminUsers tests API /admin/users route
|
TestAdminUsers_FilterName
|
go
|
supabase/auth
|
internal/api/admin_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin_test.go
|
MIT
|
func (ts *AdminTestSuite) TestAdminUserCreate() {
cases := []struct {
desc string
params map[string]interface{}
expected map[string]interface{}
}{
{
desc: "Only phone",
params: map[string]interface{}{
"phone": "123456789",
"password": "test1",
},
expected: map[string]interface{}{
"email": "",
"phone": "123456789",
"isAuthenticated": true,
"provider": "phone",
"providers": []string{"phone"},
"password": "test1",
},
},
{
desc: "With password",
params: map[string]interface{}{
"email": "[email protected]",
"phone": "123456789",
"password": "test1",
},
expected: map[string]interface{}{
"email": "[email protected]",
"phone": "123456789",
"isAuthenticated": true,
"provider": "email",
"providers": []string{"email", "phone"},
"password": "test1",
},
},
{
desc: "Without password",
params: map[string]interface{}{
"email": "[email protected]",
"phone": "",
},
expected: map[string]interface{}{
"email": "[email protected]",
"phone": "",
"isAuthenticated": false,
"provider": "email",
"providers": []string{"email"},
},
},
{
desc: "With empty string password",
params: map[string]interface{}{
"email": "[email protected]",
"phone": "",
"password": "",
},
expected: map[string]interface{}{
"email": "[email protected]",
"phone": "",
"isAuthenticated": false,
"provider": "email",
"providers": []string{"email"},
"password": "",
},
},
{
desc: "Ban created user",
params: map[string]interface{}{
"email": "[email protected]",
"phone": "",
"password": "test1",
"ban_duration": "24h",
},
expected: map[string]interface{}{
"email": "[email protected]",
"phone": "",
"isAuthenticated": true,
"provider": "email",
"providers": []string{"email"},
"password": "test1",
},
},
{
desc: "With password hash",
params: map[string]interface{}{
"email": "[email protected]",
"password_hash": "$2y$10$SXEz2HeT8PUIGQXo9yeUIem8KzNxgG0d7o/.eGj2rj8KbRgAuRVlq",
},
expected: map[string]interface{}{
"email": "[email protected]",
"phone": "",
"isAuthenticated": true,
"provider": "email",
"providers": []string{"email"},
"password": "test",
},
},
{
desc: "With custom id",
params: map[string]interface{}{
"id": "fc56ab41-2010-4870-a9b9-767c1dc573fb",
"email": "[email protected]",
"password": "test",
},
expected: map[string]interface{}{
"id": "fc56ab41-2010-4870-a9b9-767c1dc573fb",
"email": "[email protected]",
"phone": "",
"isAuthenticated": true,
"provider": "email",
"providers": []string{"email"},
"password": "test",
},
},
}
for _, c := range cases {
ts.Run(c.desc, func() {
var buffer bytes.Buffer
require.NoError(ts.T(), json.NewEncoder(&buffer).Encode(c.params))
// Setup request
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodPost, "/admin/users", &buffer)
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", ts.token))
ts.Config.External.Phone.Enabled = true
ts.API.handler.ServeHTTP(w, req)
require.Equal(ts.T(), http.StatusOK, w.Code)
data := models.User{}
require.NoError(ts.T(), json.NewDecoder(w.Body).Decode(&data))
assert.Equal(ts.T(), c.expected["email"], data.GetEmail())
assert.Equal(ts.T(), c.expected["phone"], data.GetPhone())
assert.Equal(ts.T(), c.expected["provider"], data.AppMetaData["provider"])
assert.ElementsMatch(ts.T(), c.expected["providers"], data.AppMetaData["providers"])
u, err := models.FindUserByID(ts.API.db, data.ID)
require.NoError(ts.T(), err)
// verify that the corresponding identities were created
require.NotEmpty(ts.T(), u.Identities)
for _, identity := range u.Identities {
require.Equal(ts.T(), u.ID, identity.UserID)
if identity.Provider == "email" {
require.Equal(ts.T(), c.expected["email"], identity.IdentityData["email"])
}
if identity.Provider == "phone" {
require.Equal(ts.T(), c.expected["phone"], identity.IdentityData["phone"])
}
}
if _, ok := c.expected["password"]; ok {
expectedPassword := fmt.Sprintf("%v", c.expected["password"])
isAuthenticated, _, err := u.Authenticate(context.Background(), ts.API.db, expectedPassword, ts.API.config.Security.DBEncryption.DecryptionKeys, ts.API.config.Security.DBEncryption.Encrypt, ts.API.config.Security.DBEncryption.EncryptionKeyID)
require.NoError(ts.T(), err)
require.Equal(ts.T(), c.expected["isAuthenticated"], isAuthenticated)
}
if id, ok := c.expected["id"]; ok {
uid, err := uuid.FromString(id.(string))
require.NoError(ts.T(), err)
require.Equal(ts.T(), uid, data.ID)
}
// remove created user after each case
require.NoError(ts.T(), ts.API.db.Destroy(u))
})
}
}
|
TestAdminUserCreate tests API /admin/user route (POST)
|
TestAdminUserCreate
|
go
|
supabase/auth
|
internal/api/admin_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin_test.go
|
MIT
|
func (ts *AdminTestSuite) TestAdminUserGet() {
u, err := models.NewUser("12345678", "[email protected]", "test", ts.Config.JWT.Aud, map[string]interface{}{"full_name": "Test Get User"})
require.NoError(ts.T(), err, "Error making new user")
require.NoError(ts.T(), ts.API.db.Create(u), "Error creating user")
// Setup request
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/admin/users/%s", u.ID), nil)
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", ts.token))
ts.API.handler.ServeHTTP(w, req)
require.Equal(ts.T(), http.StatusOK, w.Code)
data := make(map[string]interface{})
require.NoError(ts.T(), json.NewDecoder(w.Body).Decode(&data))
assert.Equal(ts.T(), data["email"], "[email protected]")
assert.NotNil(ts.T(), data["app_metadata"])
assert.NotNil(ts.T(), data["user_metadata"])
md := data["user_metadata"].(map[string]interface{})
assert.Len(ts.T(), md, 1)
assert.Equal(ts.T(), "Test Get User", md["full_name"])
}
|
TestAdminUserGet tests API /admin/user route (GET)
|
TestAdminUserGet
|
go
|
supabase/auth
|
internal/api/admin_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin_test.go
|
MIT
|
func (ts *AdminTestSuite) TestAdminUserUpdate() {
u, err := models.NewUser("12345678", "[email protected]", "test", ts.Config.JWT.Aud, nil)
require.NoError(ts.T(), err, "Error making new user")
require.NoError(ts.T(), ts.API.db.Create(u), "Error creating user")
var buffer bytes.Buffer
newEmail := "[email protected]"
newPhone := "234567890"
require.NoError(ts.T(), json.NewEncoder(&buffer).Encode(map[string]interface{}{
"role": "testing",
"app_metadata": map[string]interface{}{
"roles": []string{"writer", "editor"},
},
"user_metadata": map[string]interface{}{
"name": "David",
},
"ban_duration": "24h",
"email": newEmail,
"phone": newPhone,
}))
// Setup request
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodPut, fmt.Sprintf("/admin/users/%s", u.ID), &buffer)
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", ts.token))
ts.API.handler.ServeHTTP(w, req)
require.Equal(ts.T(), http.StatusOK, w.Code)
data := models.User{}
require.NoError(ts.T(), json.NewDecoder(w.Body).Decode(&data))
assert.Equal(ts.T(), "testing", data.Role)
assert.NotNil(ts.T(), data.UserMetaData)
assert.Equal(ts.T(), "David", data.UserMetaData["name"])
assert.Equal(ts.T(), newEmail, data.GetEmail())
assert.Equal(ts.T(), newPhone, data.GetPhone())
assert.NotNil(ts.T(), data.AppMetaData)
assert.Len(ts.T(), data.AppMetaData["roles"], 2)
assert.Contains(ts.T(), data.AppMetaData["roles"], "writer")
assert.Contains(ts.T(), data.AppMetaData["roles"], "editor")
assert.NotNil(ts.T(), data.BannedUntil)
u, err = models.FindUserByID(ts.API.db, data.ID)
require.NoError(ts.T(), err)
// check if the corresponding identities were successfully created
require.NotEmpty(ts.T(), u.Identities)
for _, identity := range u.Identities {
// for email & phone identities, the providerId is the same as the userId
require.Equal(ts.T(), u.ID.String(), identity.ProviderID)
require.Equal(ts.T(), u.ID, identity.UserID)
if identity.Provider == "email" {
require.Equal(ts.T(), newEmail, identity.IdentityData["email"])
}
if identity.Provider == "phone" {
require.Equal(ts.T(), newPhone, identity.IdentityData["phone"])
}
}
}
|
TestAdminUserUpdate tests API /admin/user route (UPDATE)
|
TestAdminUserUpdate
|
go
|
supabase/auth
|
internal/api/admin_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin_test.go
|
MIT
|
func (ts *AdminTestSuite) TestAdminUserDelete() {
type expected struct {
code int
err error
}
signupParams := &SignupParams{
Email: "[email protected]",
Password: "test",
Data: map[string]interface{}{"name": "test"},
Provider: "email",
Aud: ts.Config.JWT.Aud,
}
cases := []struct {
desc string
body map[string]interface{}
isSoftDelete string
isSSOUser bool
expected expected
}{
{
desc: "Test admin delete user (default)",
isSoftDelete: "",
isSSOUser: false,
expected: expected{code: http.StatusOK, err: models.UserNotFoundError{}},
body: nil,
},
{
desc: "Test admin delete user (hard deletion)",
isSoftDelete: "?is_soft_delete=false",
isSSOUser: false,
expected: expected{code: http.StatusOK, err: models.UserNotFoundError{}},
body: map[string]interface{}{
"should_soft_delete": false,
},
},
{
desc: "Test admin delete user (soft deletion)",
isSoftDelete: "?is_soft_delete=true",
isSSOUser: false,
expected: expected{code: http.StatusOK, err: models.UserNotFoundError{}},
body: map[string]interface{}{
"should_soft_delete": true,
},
},
{
desc: "Test admin delete user (soft deletion & sso user)",
isSoftDelete: "?is_soft_delete=true",
isSSOUser: true,
expected: expected{code: http.StatusOK, err: nil},
body: map[string]interface{}{
"should_soft_delete": true,
},
},
}
for _, c := range cases {
ts.Run(c.desc, func() {
var buffer bytes.Buffer
require.NoError(ts.T(), json.NewEncoder(&buffer).Encode(c.body))
u, err := signupParams.ToUserModel(false /* <- isSSOUser */)
require.NoError(ts.T(), err)
u, err = ts.API.signupNewUser(ts.API.db, u)
require.NoError(ts.T(), err)
// Setup request
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodDelete, fmt.Sprintf("/admin/users/%s", u.ID), &buffer)
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", ts.token))
ts.API.handler.ServeHTTP(w, req)
require.Equal(ts.T(), c.expected.code, w.Code)
if c.isSSOUser {
u, err = models.FindUserByID(ts.API.db, u.ID)
require.NotNil(ts.T(), u)
} else {
_, err = models.FindUserByEmailAndAudience(ts.API.db, signupParams.Email, ts.Config.JWT.Aud)
}
require.Equal(ts.T(), c.expected.err, err)
})
}
}
|
TestAdminUserDelete tests API /admin/users route (DELETE)
|
TestAdminUserDelete
|
go
|
supabase/auth
|
internal/api/admin_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin_test.go
|
MIT
|
func (ts *AdminTestSuite) TestAdminUserDeleteFactor() {
u, err := models.NewUser("123456789", "[email protected]", "test", ts.Config.JWT.Aud, nil)
require.NoError(ts.T(), err, "Error making new user")
require.NoError(ts.T(), ts.API.db.Create(u), "Error creating user")
f := models.NewTOTPFactor(u, "testSimpleName")
require.NoError(ts.T(), f.UpdateStatus(ts.API.db, models.FactorStateVerified))
require.NoError(ts.T(), f.SetSecret("secretkey", ts.Config.Security.DBEncryption.Encrypt, ts.Config.Security.DBEncryption.EncryptionKeyID, ts.Config.Security.DBEncryption.EncryptionKey))
require.NoError(ts.T(), ts.API.db.Create(f), "Error saving new test factor")
// Setup request
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodDelete, fmt.Sprintf("/admin/users/%s/factors/%s/", u.ID, f.ID), nil)
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", ts.token))
ts.API.handler.ServeHTTP(w, req)
require.Equal(ts.T(), http.StatusOK, w.Code)
_, err = models.FindFactorByFactorID(ts.API.db, f.ID)
require.EqualError(ts.T(), err, models.FactorNotFoundError{}.Error())
}
|
TestAdminUserDeleteFactor tests API /admin/users/<user_id>/factors/<factor_id>/
|
TestAdminUserDeleteFactor
|
go
|
supabase/auth
|
internal/api/admin_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin_test.go
|
MIT
|
func (ts *AdminTestSuite) TestAdminUserGetFactors() {
u, err := models.NewUser("123456789", "[email protected]", "test", ts.Config.JWT.Aud, nil)
require.NoError(ts.T(), err, "Error making new user")
require.NoError(ts.T(), ts.API.db.Create(u), "Error creating user")
f := models.NewTOTPFactor(u, "testSimpleName")
require.NoError(ts.T(), f.SetSecret("secretkey", ts.Config.Security.DBEncryption.Encrypt, ts.Config.Security.DBEncryption.EncryptionKeyID, ts.Config.Security.DBEncryption.EncryptionKey))
require.NoError(ts.T(), ts.API.db.Create(f), "Error saving new test factor")
// Setup request
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/admin/users/%s/factors/", u.ID), nil)
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", ts.token))
ts.API.handler.ServeHTTP(w, req)
require.Equal(ts.T(), http.StatusOK, w.Code)
getFactorsResp := []*models.Factor{}
require.NoError(ts.T(), json.NewDecoder(w.Body).Decode(&getFactorsResp))
require.Equal(ts.T(), getFactorsResp[0].Secret, "")
}
|
TestAdminUserGetFactor tests API /admin/user/<user_id>/factors/
|
TestAdminUserGetFactors
|
go
|
supabase/auth
|
internal/api/admin_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/admin_test.go
|
MIT
|
func NewAPIWithVersion(globalConfig *conf.GlobalConfiguration, db *storage.Connection, version string, opt ...Option) *API {
api := &API{config: globalConfig, db: db, version: version}
for _, o := range opt {
o.apply(api)
}
if api.limiterOpts == nil {
api.limiterOpts = NewLimiterOptions(globalConfig)
}
if api.hooksMgr == nil {
httpDr := hookshttp.New()
pgfuncDr := hookspgfunc.New(db)
api.hooksMgr = v0hooks.NewManager(globalConfig, httpDr, pgfuncDr)
}
if api.config.Password.HIBP.Enabled {
httpClient := &http.Client{
// all HIBP API requests should finish quickly to avoid
// unnecessary slowdowns
Timeout: 5 * time.Second,
}
api.hibpClient = &hibp.PwnedClient{
UserAgent: api.config.Password.HIBP.UserAgent,
HTTP: httpClient,
}
if api.config.Password.HIBP.Bloom.Enabled {
cache := utilities.NewHIBPBloomCache(api.config.Password.HIBP.Bloom.Items, api.config.Password.HIBP.Bloom.FalsePositives)
api.hibpClient.Cache = cache
logrus.Infof("Pwned passwords cache is %.2f KB", float64(cache.Cap())/(8*1024.0))
}
}
api.deprecationNotices()
xffmw, _ := xff.Default()
logger := observability.NewStructuredLogger(logrus.StandardLogger(), globalConfig)
r := newRouter()
r.UseBypass(observability.AddRequestID(globalConfig))
r.UseBypass(logger)
r.UseBypass(xffmw.Handler)
r.UseBypass(recoverer)
if globalConfig.API.MaxRequestDuration > 0 {
r.UseBypass(timeoutMiddleware(globalConfig.API.MaxRequestDuration))
}
// request tracing should be added only when tracing or metrics is enabled
if globalConfig.Tracing.Enabled || globalConfig.Metrics.Enabled {
r.UseBypass(observability.RequestTracing())
}
if globalConfig.DB.CleanupEnabled {
cleanup := models.NewCleanup(globalConfig)
r.UseBypass(api.databaseCleanup(cleanup))
}
r.Get("/health", api.HealthCheck)
r.Get("/.well-known/jwks.json", api.Jwks)
r.Route("/callback", func(r *router) {
r.Use(api.isValidExternalHost)
r.Use(api.loadFlowState)
r.Get("/", api.ExternalProviderCallback)
r.Post("/", api.ExternalProviderCallback)
})
r.Route("/", func(r *router) {
r.Use(api.isValidExternalHost)
r.Get("/settings", api.Settings)
r.Get("/authorize", api.ExternalProviderRedirect)
r.With(api.requireAdminCredentials).Post("/invite", api.Invite)
r.With(api.verifyCaptcha).Route("/signup", func(r *router) {
// rate limit per hour
limitAnonymousSignIns := api.limiterOpts.AnonymousSignIns
limitSignups := api.limiterOpts.Signups
r.Post("/", func(w http.ResponseWriter, r *http.Request) error {
params := &SignupParams{}
if err := retrieveRequestParams(r, params); err != nil {
return err
}
if params.Email == "" && params.Phone == "" {
if !api.config.External.AnonymousUsers.Enabled {
return apierrors.NewUnprocessableEntityError(apierrors.ErrorCodeAnonymousProviderDisabled, "Anonymous sign-ins are disabled")
}
if _, err := api.limitHandler(limitAnonymousSignIns)(w, r); err != nil {
return err
}
return api.SignupAnonymously(w, r)
}
// apply ip-based rate limiting on otps
if _, err := api.limitHandler(limitSignups)(w, r); err != nil {
return err
}
return api.Signup(w, r)
})
})
r.With(api.limitHandler(api.limiterOpts.Recover)).
With(api.verifyCaptcha).With(api.requireEmailProvider).Post("/recover", api.Recover)
r.With(api.limitHandler(api.limiterOpts.Resend)).
With(api.verifyCaptcha).Post("/resend", api.Resend)
r.With(api.limitHandler(api.limiterOpts.MagicLink)).
With(api.verifyCaptcha).Post("/magiclink", api.MagicLink)
r.With(api.limitHandler(api.limiterOpts.Otp)).
With(api.verifyCaptcha).Post("/otp", api.Otp)
// rate limiting applied in handler
r.With(api.verifyCaptcha).Post("/token", api.Token)
r.With(api.limitHandler(api.limiterOpts.Verify)).Route("/verify", func(r *router) {
r.Get("/", api.Verify)
r.Post("/", api.Verify)
})
r.With(api.requireAuthentication).Post("/logout", api.Logout)
r.With(api.requireAuthentication).Route("/reauthenticate", func(r *router) {
r.Get("/", api.Reauthenticate)
})
r.With(api.requireAuthentication).Route("/user", func(r *router) {
r.Get("/", api.UserGet)
r.With(api.limitHandler(api.limiterOpts.User)).Put("/", api.UserUpdate)
r.Route("/identities", func(r *router) {
r.Use(api.requireManualLinkingEnabled)
r.Get("/authorize", api.LinkIdentity)
r.Delete("/{identity_id}", api.DeleteIdentity)
})
})
r.With(api.requireAuthentication).Route("/factors", func(r *router) {
r.Use(api.requireNotAnonymous)
r.Post("/", api.EnrollFactor)
r.Route("/{factor_id}", func(r *router) {
r.Use(api.loadFactor)
r.With(api.limitHandler(api.limiterOpts.FactorVerify)).
Post("/verify", api.VerifyFactor)
r.With(api.limitHandler(api.limiterOpts.FactorChallenge)).
Post("/challenge", api.ChallengeFactor)
r.Delete("/", api.UnenrollFactor)
})
})
r.Route("/sso", func(r *router) {
r.Use(api.requireSAMLEnabled)
r.With(api.limitHandler(api.limiterOpts.SSO)).
With(api.verifyCaptcha).Post("/", api.SingleSignOn)
r.Route("/saml", func(r *router) {
r.Get("/metadata", api.SAMLMetadata)
r.With(api.limitHandler(api.limiterOpts.SAMLAssertion)).
Post("/acs", api.SamlAcs)
})
})
r.Route("/admin", func(r *router) {
r.Use(api.requireAdminCredentials)
r.Route("/audit", func(r *router) {
r.Get("/", api.adminAuditLog)
})
r.Route("/users", func(r *router) {
r.Get("/", api.adminUsers)
r.Post("/", api.adminUserCreate)
r.Route("/{user_id}", func(r *router) {
r.Use(api.loadUser)
r.Route("/factors", func(r *router) {
r.Get("/", api.adminUserGetFactors)
r.Route("/{factor_id}", func(r *router) {
r.Use(api.loadFactor)
r.Delete("/", api.adminUserDeleteFactor)
r.Put("/", api.adminUserUpdateFactor)
})
})
r.Get("/", api.adminUserGet)
r.Put("/", api.adminUserUpdate)
r.Delete("/", api.adminUserDelete)
})
})
r.Post("/generate_link", api.adminGenerateLink)
r.Route("/sso", func(r *router) {
r.Route("/providers", func(r *router) {
r.Get("/", api.adminSSOProvidersList)
r.Post("/", api.adminSSOProvidersCreate)
r.Route("/{idp_id}", func(r *router) {
r.Use(api.loadSSOProvider)
r.Get("/", api.adminSSOProvidersGet)
r.Put("/", api.adminSSOProvidersUpdate)
r.Delete("/", api.adminSSOProvidersDelete)
})
})
})
})
})
corsHandler := cors.New(cors.Options{
AllowedMethods: []string{http.MethodGet, http.MethodPost, http.MethodPut, http.MethodDelete},
AllowedHeaders: globalConfig.CORS.AllAllowedHeaders([]string{"Accept", "Authorization", "Content-Type", "X-Client-IP", "X-Client-Info", audHeaderName, useCookieHeader, APIVersionHeaderName}),
ExposedHeaders: []string{"X-Total-Count", "Link", APIVersionHeaderName},
AllowCredentials: true,
})
api.handler = corsHandler.Handler(r)
return api
}
|
NewAPIWithVersion creates a new REST API using the specified version
|
NewAPIWithVersion
|
go
|
supabase/auth
|
internal/api/api.go
|
https://github.com/supabase/auth/blob/master/internal/api/api.go
|
MIT
|
func (a *API) HealthCheck(w http.ResponseWriter, r *http.Request) error {
return sendJSON(w, http.StatusOK, HealthCheckResponse{
Version: a.version,
Name: "GoTrue",
Description: "GoTrue is a user registration and authentication API",
})
}
|
HealthCheck endpoint indicates if the gotrue api service is available
|
HealthCheck
|
go
|
supabase/auth
|
internal/api/api.go
|
https://github.com/supabase/auth/blob/master/internal/api/api.go
|
MIT
|
func (a *API) Mailer() mailer.Mailer {
config := a.config
return mailer.NewMailer(config)
}
|
Mailer returns NewMailer with the current tenant config
|
Mailer
|
go
|
supabase/auth
|
internal/api/api.go
|
https://github.com/supabase/auth/blob/master/internal/api/api.go
|
MIT
|
func (a *API) ServeHTTP(w http.ResponseWriter, r *http.Request) {
a.handler.ServeHTTP(w, r)
}
|
ServeHTTP implements the http.Handler interface by passing the request along
to its underlying Handler.
|
ServeHTTP
|
go
|
supabase/auth
|
internal/api/api.go
|
https://github.com/supabase/auth/blob/master/internal/api/api.go
|
MIT
|
func setupAPIForTest() (*API, *conf.GlobalConfiguration, error) {
return setupAPIForTestWithCallback(nil)
}
|
setupAPIForTest creates a new API to run tests with.
Using this function allows us to keep track of the database connection
and cleaning up data between tests.
|
setupAPIForTest
|
go
|
supabase/auth
|
internal/api/api_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/api_test.go
|
MIT
|
func (a *API) requireAuthentication(w http.ResponseWriter, r *http.Request) (context.Context, error) {
token, err := a.extractBearerToken(r)
if err != nil {
return nil, err
}
ctx, err := a.parseJWTClaims(token, r)
if err != nil {
return ctx, err
}
ctx, err = a.maybeLoadUserOrSession(ctx)
if err != nil {
return ctx, err
}
return ctx, err
}
|
requireAuthentication checks incoming requests for tokens presented using the Authorization header
|
requireAuthentication
|
go
|
supabase/auth
|
internal/api/auth.go
|
https://github.com/supabase/auth/blob/master/internal/api/auth.go
|
MIT
|
func withToken(ctx context.Context, token *jwt.Token) context.Context {
return context.WithValue(ctx, tokenKey, token)
}
|
withToken adds the JWT token to the context.
|
withToken
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func getToken(ctx context.Context) *jwt.Token {
obj := ctx.Value(tokenKey)
if obj == nil {
return nil
}
return obj.(*jwt.Token)
}
|
getToken reads the JWT token from the context.
|
getToken
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func withUser(ctx context.Context, u *models.User) context.Context {
return context.WithValue(ctx, userKey, u)
}
|
withUser adds the user to the context.
|
withUser
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func withTargetUser(ctx context.Context, u *models.User) context.Context {
return context.WithValue(ctx, targetUserKey, u)
}
|
withTargetUser adds the target user for linking to the context.
|
withTargetUser
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func withFactor(ctx context.Context, f *models.Factor) context.Context {
return context.WithValue(ctx, factorKey, f)
}
|
with Factor adds the factor id to the context.
|
withFactor
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func getUser(ctx context.Context) *models.User {
if ctx == nil {
return nil
}
obj := ctx.Value(userKey)
if obj == nil {
return nil
}
return obj.(*models.User)
}
|
getUser reads the user from the context.
|
getUser
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func getTargetUser(ctx context.Context) *models.User {
if ctx == nil {
return nil
}
obj := ctx.Value(targetUserKey)
if obj == nil {
return nil
}
return obj.(*models.User)
}
|
getTargetUser reads the user from the context.
|
getTargetUser
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func getFactor(ctx context.Context) *models.Factor {
obj := ctx.Value(factorKey)
if obj == nil {
return nil
}
return obj.(*models.Factor)
}
|
getFactor reads the factor id from the context
|
getFactor
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func withSession(ctx context.Context, s *models.Session) context.Context {
return context.WithValue(ctx, sessionKey, s)
}
|
withSession adds the session to the context.
|
withSession
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func getSession(ctx context.Context) *models.Session {
if ctx == nil {
return nil
}
obj := ctx.Value(sessionKey)
if obj == nil {
return nil
}
return obj.(*models.Session)
}
|
getSession reads the session from the context.
|
getSession
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func withSignature(ctx context.Context, id string) context.Context {
return context.WithValue(ctx, signatureKey, id)
}
|
withSignature adds the provided request ID to the context.
|
withSignature
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func withExternalProviderType(ctx context.Context, id string) context.Context {
return context.WithValue(ctx, externalProviderTypeKey, id)
}
|
withExternalProviderType adds the provided request ID to the context.
|
withExternalProviderType
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func getExternalProviderType(ctx context.Context) string {
obj := ctx.Value(externalProviderTypeKey)
if obj == nil {
return ""
}
return obj.(string)
}
|
getExternalProviderType reads the request ID from the context.
|
getExternalProviderType
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func withAdminUser(ctx context.Context, u *models.User) context.Context {
return context.WithValue(ctx, adminUserKey, u)
}
|
withAdminUser adds the admin user to the context.
|
withAdminUser
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func getAdminUser(ctx context.Context) *models.User {
obj := ctx.Value(adminUserKey)
if obj == nil {
return nil
}
return obj.(*models.User)
}
|
getAdminUser reads the admin user from the context.
|
getAdminUser
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func withRequestToken(ctx context.Context, token string) context.Context {
return context.WithValue(ctx, oauthTokenKey, token)
}
|
withRequestToken adds the request token to the context
|
withRequestToken
|
go
|
supabase/auth
|
internal/api/context.go
|
https://github.com/supabase/auth/blob/master/internal/api/context.go
|
MIT
|
func recoverer(next http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
defer func() {
if rvr := recover(); rvr != nil {
logEntry := observability.GetLogEntry(r)
if logEntry != nil {
logEntry.Panic(rvr, debug.Stack())
} else {
fmt.Fprintf(os.Stderr, "Panic: %+v\n", rvr)
debug.PrintStack()
}
se := &HTTPError{
HTTPStatus: http.StatusInternalServerError,
Message: http.StatusText(http.StatusInternalServerError),
}
HandleResponseError(se, w, r)
}
}()
next.ServeHTTP(w, r)
}
return http.HandlerFunc(fn)
}
|
Recoverer is a middleware that recovers from panics, logs the panic (and a
backtrace), and returns a HTTP 500 (Internal Server Error) status if
possible. Recoverer prints a request ID if one is provided.
|
recoverer
|
go
|
supabase/auth
|
internal/api/errors.go
|
https://github.com/supabase/auth/blob/master/internal/api/errors.go
|
MIT
|
func (a *API) ExternalProviderRedirect(w http.ResponseWriter, r *http.Request) error {
rurl, err := a.GetExternalProviderRedirectURL(w, r, nil)
if err != nil {
return err
}
http.Redirect(w, r, rurl, http.StatusFound)
return nil
}
|
ExternalProviderRedirect redirects the request to the oauth provider
|
ExternalProviderRedirect
|
go
|
supabase/auth
|
internal/api/external.go
|
https://github.com/supabase/auth/blob/master/internal/api/external.go
|
MIT
|
func (a *API) GetExternalProviderRedirectURL(w http.ResponseWriter, r *http.Request, linkingTargetUser *models.User) (string, error) {
ctx := r.Context()
db := a.db.WithContext(ctx)
config := a.config
query := r.URL.Query()
providerType := query.Get("provider")
scopes := query.Get("scopes")
codeChallenge := query.Get("code_challenge")
codeChallengeMethod := query.Get("code_challenge_method")
p, err := a.Provider(ctx, providerType, scopes)
if err != nil {
return "", apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "Unsupported provider: %+v", err).WithInternalError(err)
}
inviteToken := query.Get("invite_token")
if inviteToken != "" {
_, userErr := models.FindUserByConfirmationToken(db, inviteToken)
if userErr != nil {
if models.IsNotFoundError(userErr) {
return "", apierrors.NewNotFoundError(apierrors.ErrorCodeUserNotFound, "User identified by token not found")
}
return "", apierrors.NewInternalServerError("Database error finding user").WithInternalError(userErr)
}
}
redirectURL := utilities.GetReferrer(r, config)
log := observability.GetLogEntry(r).Entry
log.WithField("provider", providerType).Info("Redirecting to external provider")
if err := validatePKCEParams(codeChallengeMethod, codeChallenge); err != nil {
return "", err
}
flowType := getFlowFromChallenge(codeChallenge)
flowStateID := ""
if isPKCEFlow(flowType) {
flowState, err := generateFlowState(a.db, providerType, models.OAuth, codeChallengeMethod, codeChallenge, nil)
if err != nil {
return "", err
}
flowStateID = flowState.ID.String()
}
claims := ExternalProviderClaims{
AuthMicroserviceClaims: AuthMicroserviceClaims{
RegisteredClaims: jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(time.Now().Add(5 * time.Minute)),
},
SiteURL: config.SiteURL,
InstanceID: uuid.Nil.String(),
},
Provider: providerType,
InviteToken: inviteToken,
Referrer: redirectURL,
FlowStateID: flowStateID,
}
if linkingTargetUser != nil {
// this means that the user is performing manual linking
claims.LinkingTargetID = linkingTargetUser.ID.String()
}
tokenString, err := signJwt(&config.JWT, claims)
if err != nil {
return "", apierrors.NewInternalServerError("Error creating state").WithInternalError(err)
}
authUrlParams := make([]oauth2.AuthCodeOption, 0)
query.Del("scopes")
query.Del("provider")
query.Del("code_challenge")
query.Del("code_challenge_method")
for key := range query {
if key == "workos_provider" {
// See https://workos.com/docs/reference/sso/authorize/get
authUrlParams = append(authUrlParams, oauth2.SetAuthURLParam("provider", query.Get(key)))
} else {
authUrlParams = append(authUrlParams, oauth2.SetAuthURLParam(key, query.Get(key)))
}
}
authURL := p.AuthCodeURL(tokenString, authUrlParams...)
return authURL, nil
}
|
GetExternalProviderRedirectURL returns the URL to start the oauth flow with the corresponding oauth provider
|
GetExternalProviderRedirectURL
|
go
|
supabase/auth
|
internal/api/external.go
|
https://github.com/supabase/auth/blob/master/internal/api/external.go
|
MIT
|
func (a *API) ExternalProviderCallback(w http.ResponseWriter, r *http.Request) error {
rurl := a.getExternalRedirectURL(r)
u, err := url.Parse(rurl)
if err != nil {
return err
}
redirectErrors(a.internalExternalProviderCallback, w, r, u)
return nil
}
|
ExternalProviderCallback handles the callback endpoint in the external oauth provider flow
|
ExternalProviderCallback
|
go
|
supabase/auth
|
internal/api/external.go
|
https://github.com/supabase/auth/blob/master/internal/api/external.go
|
MIT
|
func (a *API) Provider(ctx context.Context, name string, scopes string) (provider.Provider, error) {
config := a.config
name = strings.ToLower(name)
switch name {
case "apple":
return provider.NewAppleProvider(ctx, config.External.Apple)
case "azure":
return provider.NewAzureProvider(config.External.Azure, scopes)
case "bitbucket":
return provider.NewBitbucketProvider(config.External.Bitbucket)
case "discord":
return provider.NewDiscordProvider(config.External.Discord, scopes)
case "facebook":
return provider.NewFacebookProvider(config.External.Facebook, scopes)
case "figma":
return provider.NewFigmaProvider(config.External.Figma, scopes)
case "fly":
return provider.NewFlyProvider(config.External.Fly, scopes)
case "github":
return provider.NewGithubProvider(config.External.Github, scopes)
case "gitlab":
return provider.NewGitlabProvider(config.External.Gitlab, scopes)
case "google":
return provider.NewGoogleProvider(ctx, config.External.Google, scopes)
case "kakao":
return provider.NewKakaoProvider(config.External.Kakao, scopes)
case "keycloak":
return provider.NewKeycloakProvider(config.External.Keycloak, scopes)
case "linkedin":
return provider.NewLinkedinProvider(config.External.Linkedin, scopes)
case "linkedin_oidc":
return provider.NewLinkedinOIDCProvider(config.External.LinkedinOIDC, scopes)
case "notion":
return provider.NewNotionProvider(config.External.Notion)
case "spotify":
return provider.NewSpotifyProvider(config.External.Spotify, scopes)
case "slack":
return provider.NewSlackProvider(config.External.Slack, scopes)
case "slack_oidc":
return provider.NewSlackOIDCProvider(config.External.SlackOIDC, scopes)
case "twitch":
return provider.NewTwitchProvider(config.External.Twitch, scopes)
case "twitter":
return provider.NewTwitterProvider(config.External.Twitter, scopes)
case "vercel_marketplace":
return provider.NewVercelMarketplaceProvider(config.External.VercelMarketplace, scopes)
case "workos":
return provider.NewWorkOSProvider(config.External.WorkOS)
case "zoom":
return provider.NewZoomProvider(config.External.Zoom)
default:
return nil, fmt.Errorf("Provider %s could not be found", name)
}
}
|
Provider returns a Provider interface for the given name.
|
Provider
|
go
|
supabase/auth
|
internal/api/external.go
|
https://github.com/supabase/auth/blob/master/internal/api/external.go
|
MIT
|
func (a *API) loadFlowState(w http.ResponseWriter, r *http.Request) (context.Context, error) {
ctx := r.Context()
oauthToken := r.URL.Query().Get("oauth_token")
if oauthToken != "" {
ctx = withRequestToken(ctx, oauthToken)
}
oauthVerifier := r.URL.Query().Get("oauth_verifier")
if oauthVerifier != "" {
ctx = withOAuthVerifier(ctx, oauthVerifier)
}
var err error
ctx, err = a.loadExternalState(ctx, r)
if err != nil {
u, uerr := url.ParseRequestURI(a.config.SiteURL)
if uerr != nil {
return ctx, apierrors.NewInternalServerError("site url is improperly formatted").WithInternalError(uerr)
}
q := getErrorQueryString(err, utilities.GetRequestID(ctx), observability.GetLogEntry(r).Entry, u.Query())
u.RawQuery = q.Encode()
http.Redirect(w, r, u.String(), http.StatusSeeOther)
}
return ctx, err
}
|
loadFlowState parses the `state` query parameter as a JWS payload,
extracting the provider requested
|
loadFlowState
|
go
|
supabase/auth
|
internal/api/external_oauth.go
|
https://github.com/supabase/auth/blob/master/internal/api/external_oauth.go
|
MIT
|
func (a *API) OAuthProvider(ctx context.Context, name string) (provider.OAuthProvider, error) {
providerCandidate, err := a.Provider(ctx, name, "")
if err != nil {
return nil, err
}
switch p := providerCandidate.(type) {
case provider.OAuthProvider:
return p, nil
default:
return nil, fmt.Errorf("Provider %v cannot be used for OAuth", name)
}
}
|
OAuthProvider returns the corresponding oauth provider as an OAuthProvider interface
|
OAuthProvider
|
go
|
supabase/auth
|
internal/api/external_oauth.go
|
https://github.com/supabase/auth/blob/master/internal/api/external_oauth.go
|
MIT
|
func (ts *ExternalTestSuite) TestSignupExternalUnsupported() {
req := httptest.NewRequest(http.MethodGet, "http://localhost/authorize?provider=external", nil)
w := httptest.NewRecorder()
ts.API.handler.ServeHTTP(w, req)
ts.Equal(w.Code, http.StatusBadRequest)
}
|
TestSignupExternalUnsupported tests API /authorize for an unsupported external provider
|
TestSignupExternalUnsupported
|
go
|
supabase/auth
|
internal/api/external_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/external_test.go
|
MIT
|
func retrieveRequestParams[A RequestParams](r *http.Request, params *A) error {
body, err := utilities.GetBodyBytes(r)
if err != nil {
return apierrors.NewInternalServerError("Could not read body into byte slice").WithInternalError(err)
}
if err := json.Unmarshal(body, params); err != nil {
return apierrors.NewBadRequestError(apierrors.ErrorCodeBadJSON, "Could not parse request body as JSON: %v", err)
}
return nil
}
|
retrieveRequestParams is a generic method that unmarshals the request body into the params struct provided
|
retrieveRequestParams
|
go
|
supabase/auth
|
internal/api/helpers.go
|
https://github.com/supabase/auth/blob/master/internal/api/helpers.go
|
MIT
|
func (a *API) Invite(w http.ResponseWriter, r *http.Request) error {
ctx := r.Context()
db := a.db.WithContext(ctx)
adminUser := getAdminUser(ctx)
params := &InviteParams{}
if err := retrieveRequestParams(r, params); err != nil {
return err
}
var err error
params.Email, err = a.validateEmail(params.Email)
if err != nil {
return err
}
aud := a.requestAud(ctx, r)
user, err := models.FindUserByEmailAndAudience(db, params.Email, aud)
if err != nil && !models.IsNotFoundError(err) {
return apierrors.NewInternalServerError("Database error finding user").WithInternalError(err)
}
isCreate := user == nil
isConfirmed := user != nil && user.IsConfirmed()
if isCreate {
signupParams := SignupParams{
Email: params.Email,
Data: params.Data,
Aud: aud,
Provider: "email",
}
// because params above sets no password, this method
// is not computationally hard so it can be used within
// a database transaction
user, err = signupParams.ToUserModel(false /* <- isSSOUser */)
if err != nil {
return err
}
if err := a.triggerBeforeUserCreated(r, db, user); err != nil {
return err
}
}
err = db.Transaction(func(tx *storage.Connection) error {
if !isCreate {
if isConfirmed {
return apierrors.NewUnprocessableEntityError(apierrors.ErrorCodeEmailExists, DuplicateEmailMsg)
}
} else {
user, err = a.signupNewUser(tx, user)
if err != nil {
return err
}
identity, err := a.createNewIdentity(tx, user, "email", structs.Map(provider.Claims{
Subject: user.ID.String(),
Email: user.GetEmail(),
}))
if err != nil {
return err
}
user.Identities = []models.Identity{*identity}
}
if terr := models.NewAuditLogEntry(r, tx, adminUser, models.UserInvitedAction, "", map[string]interface{}{
"user_id": user.ID,
"user_email": user.Email,
}); terr != nil {
return terr
}
if err := a.sendInvite(r, tx, user); err != nil {
return err
}
return nil
})
if err != nil {
return err
}
return sendJSON(w, http.StatusOK, user)
}
|
Invite is the endpoint for inviting a new user
|
Invite
|
go
|
supabase/auth
|
internal/api/invite.go
|
https://github.com/supabase/auth/blob/master/internal/api/invite.go
|
MIT
|
func (a *API) Logout(w http.ResponseWriter, r *http.Request) error {
ctx := r.Context()
db := a.db.WithContext(ctx)
scope := LogoutGlobal
if r.URL.Query() != nil {
switch r.URL.Query().Get("scope") {
case "", "global":
scope = LogoutGlobal
case "local":
scope = LogoutLocal
case "others":
scope = LogoutOthers
default:
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, fmt.Sprintf("Unsupported logout scope %q", r.URL.Query().Get("scope")))
}
}
s := getSession(ctx)
u := getUser(ctx)
err := db.Transaction(func(tx *storage.Connection) error {
if terr := models.NewAuditLogEntry(r, tx, u, models.LogoutAction, "", nil); terr != nil {
return terr
}
if s == nil {
logrus.Infof("user has an empty session_id claim: %s", u.ID)
} else {
//exhaustive:ignore Default case is handled below.
switch scope {
case LogoutLocal:
return models.LogoutSession(tx, s.ID)
case LogoutOthers:
return models.LogoutAllExceptMe(tx, s.ID, u.ID)
}
}
// default mode, log out everywhere
return models.Logout(tx, u.ID)
})
if err != nil {
return apierrors.NewInternalServerError("Error logging out user").WithInternalError(err)
}
w.WriteHeader(http.StatusNoContent)
return nil
}
|
Logout is the endpoint for logging out a user and thereby revoking any refresh tokens
|
Logout
|
go
|
supabase/auth
|
internal/api/logout.go
|
https://github.com/supabase/auth/blob/master/internal/api/logout.go
|
MIT
|
func (a *API) sendEmailChange(r *http.Request, tx *storage.Connection, u *models.User, email string, flowType models.FlowType) error {
config := a.config
otpLength := config.Mailer.OtpLength
if err := validateSentWithinFrequencyLimit(u.EmailChangeSentAt, config.SMTP.MaxFrequency); err != nil {
return err
}
otpNew := crypto.GenerateOtp(otpLength)
u.EmailChange = email
token := crypto.GenerateTokenHash(u.EmailChange, otpNew)
u.EmailChangeTokenNew = addFlowPrefixToToken(token, flowType)
otpCurrent := ""
if config.Mailer.SecureEmailChangeEnabled && u.GetEmail() != "" {
otpCurrent = crypto.GenerateOtp(otpLength)
currentToken := crypto.GenerateTokenHash(u.GetEmail(), otpCurrent)
u.EmailChangeTokenCurrent = addFlowPrefixToToken(currentToken, flowType)
}
u.EmailChangeConfirmStatus = zeroConfirmation
now := time.Now()
if err := a.sendEmail(r, tx, u, mail.EmailChangeVerification, otpCurrent, otpNew, u.EmailChangeTokenNew); err != nil {
if errors.Is(err, EmailRateLimitExceeded) {
return apierrors.NewTooManyRequestsError(apierrors.ErrorCodeOverEmailSendRateLimit, EmailRateLimitExceeded.Error())
} else if herr, ok := err.(*HTTPError); ok {
return herr
}
return apierrors.NewInternalServerError("Error sending email change email").WithInternalError(err)
}
u.EmailChangeSentAt = &now
if err := tx.UpdateOnly(
u,
"email_change_token_current",
"email_change_token_new",
"email_change",
"email_change_sent_at",
"email_change_confirm_status",
); err != nil {
return apierrors.NewInternalServerError("Error sending email change email").WithInternalError(errors.Wrap(err, "Database error updating user for email change"))
}
if u.EmailChangeTokenCurrent != "" {
if err := models.CreateOneTimeToken(tx, u.ID, u.GetEmail(), u.EmailChangeTokenCurrent, models.EmailChangeTokenCurrent); err != nil {
return apierrors.NewInternalServerError("Error sending email change email").WithInternalError(errors.Wrap(err, "Database error creating email change token current"))
}
}
if u.EmailChangeTokenNew != "" {
if err := models.CreateOneTimeToken(tx, u.ID, u.EmailChange, u.EmailChangeTokenNew, models.EmailChangeTokenNew); err != nil {
return apierrors.NewInternalServerError("Error sending email change email").WithInternalError(errors.Wrap(err, "Database error creating email change token new"))
}
}
return nil
}
|
sendEmailChange sends out an email change token to the new email.
|
sendEmailChange
|
go
|
supabase/auth
|
internal/api/mail.go
|
https://github.com/supabase/auth/blob/master/internal/api/mail.go
|
MIT
|
func (ts *MFATestSuite) TestMFAFollowedByPasswordSignIn() {
ts.Config.Security.RefreshTokenRotationEnabled = true
resp := performTestSignupAndVerify(ts, ts.TestEmail, ts.TestPassword, true /* <- requireStatusOK */)
accessTokenResp := &AccessTokenResponse{}
require.NoError(ts.T(), json.NewDecoder(resp.Body).Decode(&accessTokenResp))
var buffer bytes.Buffer
require.NoError(ts.T(), json.NewEncoder(&buffer).Encode(map[string]interface{}{
"email": ts.TestEmail,
"password": ts.TestPassword,
}))
req := httptest.NewRequest(http.MethodPost, "http://localhost/token?grant_type=password", &buffer)
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
ts.API.handler.ServeHTTP(w, req)
require.Equal(ts.T(), http.StatusOK, w.Code)
data := &AccessTokenResponse{}
require.NoError(ts.T(), json.NewDecoder(w.Body).Decode(&data))
ctx, err := ts.API.parseJWTClaims(data.Token, req)
require.NoError(ts.T(), err)
ctx, err = ts.API.maybeLoadUserOrSession(ctx)
require.NoError(ts.T(), err)
require.Equal(ts.T(), models.AAL1.String(), getSession(ctx).GetAAL())
session, err := models.FindSessionByUserID(ts.API.db, accessTokenResp.User.ID)
require.NoError(ts.T(), err)
require.True(ts.T(), session.IsAAL2())
}
|
Performing MFA Verification followed by a sign in should return an AAL1 session and an AAL2 session
|
TestMFAFollowedByPasswordSignIn
|
go
|
supabase/auth
|
internal/api/mfa_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/mfa_test.go
|
MIT
|
func (a *API) Otp(w http.ResponseWriter, r *http.Request) error {
params := &OtpParams{
CreateUser: true,
}
if params.Data == nil {
params.Data = make(map[string]interface{})
}
if err := retrieveRequestParams(r, params); err != nil {
return err
}
if err := params.Validate(); err != nil {
return err
}
if params.Data == nil {
params.Data = make(map[string]interface{})
}
if ok, err := a.shouldCreateUser(r, params); !ok {
return apierrors.NewUnprocessableEntityError(apierrors.ErrorCodeOTPDisabled, "Signups not allowed for otp")
} else if err != nil {
return err
}
if params.Email != "" {
return a.MagicLink(w, r)
} else if params.Phone != "" {
return a.SmsOtp(w, r)
}
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "One of email or phone must be set")
}
|
Otp returns the MagicLink or SmsOtp handler based on the request body params
|
Otp
|
go
|
supabase/auth
|
internal/api/otp.go
|
https://github.com/supabase/auth/blob/master/internal/api/otp.go
|
MIT
|
func (a *API) SmsOtp(w http.ResponseWriter, r *http.Request) error {
ctx := r.Context()
db := a.db.WithContext(ctx)
config := a.config
if !config.External.Phone.Enabled {
return apierrors.NewBadRequestError(apierrors.ErrorCodePhoneProviderDisabled, "Unsupported phone provider")
}
var err error
params := &SmsParams{}
if err := retrieveRequestParams(r, params); err != nil {
return err
}
// For backwards compatibility, we default to SMS if params Channel is not specified
if params.Phone != "" && params.Channel == "" {
params.Channel = sms_provider.SMSProvider
}
if err := params.Validate(config); err != nil {
return err
}
var isNewUser bool
aud := a.requestAud(ctx, r)
user, err := models.FindUserByPhoneAndAudience(db, params.Phone, aud)
if err != nil {
if models.IsNotFoundError(err) {
isNewUser = true
} else {
return apierrors.NewInternalServerError("Database error finding user").WithInternalError(err)
}
}
if user != nil {
isNewUser = !user.IsPhoneConfirmed()
}
if isNewUser {
// User either doesn't exist or hasn't completed the signup process.
// Sign them up with temporary password.
password, err := password.Generate(64, 10, 1, false, true)
if err != nil {
return apierrors.NewInternalServerError("error creating user").WithInternalError(err)
}
signUpParams := &SignupParams{
Phone: params.Phone,
Password: password,
Data: params.Data,
Channel: params.Channel,
}
newBodyContent, err := json.Marshal(signUpParams)
if err != nil {
// SignupParams must be marshallable
panic(err)
}
r.Body = io.NopCloser(bytes.NewReader(newBodyContent))
fakeResponse := &responseStub{}
if config.Sms.Autoconfirm {
// signups are autoconfirmed, send otp after signup
if err := a.Signup(fakeResponse, r); err != nil {
return err
}
signUpParams := &SignupParams{
Phone: params.Phone,
Channel: params.Channel,
}
newBodyContent, err := json.Marshal(signUpParams)
if err != nil {
// SignupParams must be marshallable
panic(err)
}
r.Body = io.NopCloser(bytes.NewReader(newBodyContent))
return a.SmsOtp(w, r)
}
if err := a.Signup(fakeResponse, r); err != nil {
return err
}
return sendJSON(w, http.StatusOK, make(map[string]string))
}
messageID := ""
err = db.Transaction(func(tx *storage.Connection) error {
if err := models.NewAuditLogEntry(r, tx, user, models.UserRecoveryRequestedAction, "", map[string]interface{}{
"channel": params.Channel,
}); err != nil {
return err
}
mID, serr := a.sendPhoneConfirmation(r, tx, user, params.Phone, phoneConfirmationOtp, params.Channel)
if serr != nil {
return serr
}
messageID = mID
return nil
})
if err != nil {
return err
}
return sendJSON(w, http.StatusOK, SmsOtpResponse{
MessageID: messageID,
})
}
|
SmsOtp sends the user an otp via sms
|
SmsOtp
|
go
|
supabase/auth
|
internal/api/otp.go
|
https://github.com/supabase/auth/blob/master/internal/api/otp.go
|
MIT
|
func validateE164Format(phone string) bool {
return e164Format.MatchString(phone)
}
|
validateE164Format checks if phone number follows the E.164 format
|
validateE164Format
|
go
|
supabase/auth
|
internal/api/phone.go
|
https://github.com/supabase/auth/blob/master/internal/api/phone.go
|
MIT
|
func formatPhoneNumber(phone string) string {
return strings.ReplaceAll(strings.TrimPrefix(phone, "+"), " ", "")
}
|
formatPhoneNumber removes "+" and whitespaces in a phone number
|
formatPhoneNumber
|
go
|
supabase/auth
|
internal/api/phone.go
|
https://github.com/supabase/auth/blob/master/internal/api/phone.go
|
MIT
|
func (a *API) sendPhoneConfirmation(r *http.Request, tx *storage.Connection, user *models.User, phone, otpType string, channel string) (string, error) {
config := a.config
var token *string
var sentAt *time.Time
includeFields := []string{}
switch otpType {
case phoneChangeVerification:
token = &user.PhoneChangeToken
sentAt = user.PhoneChangeSentAt
user.PhoneChange = phone
includeFields = append(includeFields, "phone_change", "phone_change_token", "phone_change_sent_at")
case phoneConfirmationOtp:
token = &user.ConfirmationToken
sentAt = user.ConfirmationSentAt
includeFields = append(includeFields, "confirmation_token", "confirmation_sent_at")
case phoneReauthenticationOtp:
token = &user.ReauthenticationToken
sentAt = user.ReauthenticationSentAt
includeFields = append(includeFields, "reauthentication_token", "reauthentication_sent_at")
default:
return "", apierrors.NewInternalServerError("invalid otp type")
}
// intentionally keeping this before the test OTP, so that the behavior
// of regular and test OTPs is similar
if sentAt != nil && !sentAt.Add(config.Sms.MaxFrequency).Before(time.Now()) {
return "", apierrors.NewTooManyRequestsError(apierrors.ErrorCodeOverSMSSendRateLimit, generateFrequencyLimitErrorMessage(sentAt, config.Sms.MaxFrequency))
}
now := time.Now()
var otp, messageID string
if testOTP, ok := config.Sms.GetTestOTP(phone, now); ok {
otp = testOTP
messageID = "test-otp"
}
// not using test OTPs
if otp == "" {
// TODO(km): Deprecate this behaviour - rate limits should still be applied to autoconfirm
if !config.Sms.Autoconfirm {
// apply rate limiting before the sms is sent out
if ok := a.limiterOpts.Phone.Allow(); !ok {
return "", apierrors.NewTooManyRequestsError(apierrors.ErrorCodeOverSMSSendRateLimit, "SMS rate limit exceeded")
}
}
otp = crypto.GenerateOtp(config.Sms.OtpLength)
if config.Hook.SendSMS.Enabled {
input := v0hooks.SendSMSInput{
User: user,
SMS: v0hooks.SMS{
OTP: otp,
},
}
output := v0hooks.SendSMSOutput{}
err := a.hooksMgr.InvokeHook(tx, r, &input, &output)
if err != nil {
return "", err
}
} else {
smsProvider, err := sms_provider.GetSmsProvider(*config)
if err != nil {
return "", apierrors.NewInternalServerError("Unable to get SMS provider").WithInternalError(err)
}
message, err := generateSMSFromTemplate(config.Sms.SMSTemplate, otp)
if err != nil {
return "", apierrors.NewInternalServerError("error generating sms template").WithInternalError(err)
}
messageID, err := smsProvider.SendMessage(phone, message, channel, otp)
if err != nil {
return messageID, apierrors.NewUnprocessableEntityError(apierrors.ErrorCodeSMSSendFailed, "Error sending %s OTP to provider: %v", otpType, err)
}
}
}
*token = crypto.GenerateTokenHash(phone, otp)
switch otpType {
case phoneConfirmationOtp:
user.ConfirmationSentAt = &now
case phoneChangeVerification:
user.PhoneChangeSentAt = &now
case phoneReauthenticationOtp:
user.ReauthenticationSentAt = &now
}
if err := tx.UpdateOnly(user, includeFields...); err != nil {
return messageID, errors.Wrap(err, "Database error updating user for phone")
}
var ottErr error
switch otpType {
case phoneConfirmationOtp:
if err := models.CreateOneTimeToken(tx, user.ID, user.GetPhone(), user.ConfirmationToken, models.ConfirmationToken); err != nil {
ottErr = errors.Wrap(err, "Database error creating confirmation token for phone")
}
case phoneChangeVerification:
if err := models.CreateOneTimeToken(tx, user.ID, user.PhoneChange, user.PhoneChangeToken, models.PhoneChangeToken); err != nil {
ottErr = errors.Wrap(err, "Database error creating phone change token")
}
case phoneReauthenticationOtp:
if err := models.CreateOneTimeToken(tx, user.ID, user.GetPhone(), user.ReauthenticationToken, models.ReauthenticationToken); err != nil {
ottErr = errors.Wrap(err, "Database error creating reauthentication token for phone")
}
}
if ottErr != nil {
return messageID, apierrors.NewInternalServerError("error creating one time token").WithInternalError(ottErr)
}
return messageID, nil
}
|
sendPhoneConfirmation sends an otp to the user's phone number
|
sendPhoneConfirmation
|
go
|
supabase/auth
|
internal/api/phone.go
|
https://github.com/supabase/auth/blob/master/internal/api/phone.go
|
MIT
|
func generateFlowState(tx *storage.Connection, providerType string, authenticationMethod models.AuthenticationMethod, codeChallengeMethodParam string, codeChallenge string, userID *uuid.UUID) (*models.FlowState, error) {
codeChallengeMethod, err := models.ParseCodeChallengeMethod(codeChallengeMethodParam)
if err != nil {
return nil, err
}
flowState := models.NewFlowState(providerType, codeChallenge, codeChallengeMethod, authenticationMethod, userID)
if err := tx.Create(flowState); err != nil {
return nil, err
}
return flowState, nil
}
|
Should only be used with Auth Code of PKCE Flows
|
generateFlowState
|
go
|
supabase/auth
|
internal/api/pkce.go
|
https://github.com/supabase/auth/blob/master/internal/api/pkce.go
|
MIT
|
func (a *API) Reauthenticate(w http.ResponseWriter, r *http.Request) error {
ctx := r.Context()
db := a.db.WithContext(ctx)
user := getUser(ctx)
email, phone := user.GetEmail(), user.GetPhone()
if email == "" && phone == "" {
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "Reauthentication requires the user to have an email or a phone number")
}
if email != "" {
if !user.IsConfirmed() {
return apierrors.NewUnprocessableEntityError(apierrors.ErrorCodeEmailNotConfirmed, "Please verify your email first.")
}
} else if phone != "" {
if !user.IsPhoneConfirmed() {
return apierrors.NewUnprocessableEntityError(apierrors.ErrorCodePhoneNotConfirmed, "Please verify your phone first.")
}
}
messageID := ""
err := db.Transaction(func(tx *storage.Connection) error {
if terr := models.NewAuditLogEntry(r, tx, user, models.UserReauthenticateAction, "", nil); terr != nil {
return terr
}
if email != "" {
return a.sendReauthenticationOtp(r, tx, user)
} else if phone != "" {
mID, err := a.sendPhoneConfirmation(r, tx, user, phone, phoneReauthenticationOtp, sms_provider.SMSProvider)
if err != nil {
return err
}
messageID = mID
}
return nil
})
if err != nil {
return err
}
ret := map[string]any{}
if messageID != "" {
ret["message_id"] = messageID
}
return sendJSON(w, http.StatusOK, ret)
}
|
Reauthenticate sends a reauthentication otp to either the user's email or phone
|
Reauthenticate
|
go
|
supabase/auth
|
internal/api/reauthenticate.go
|
https://github.com/supabase/auth/blob/master/internal/api/reauthenticate.go
|
MIT
|
func (a *API) verifyReauthentication(nonce string, tx *storage.Connection, config *conf.GlobalConfiguration, user *models.User) error {
if user.ReauthenticationToken == "" || user.ReauthenticationSentAt == nil {
return apierrors.NewUnprocessableEntityError(apierrors.ErrorCodeReauthenticationNotValid, InvalidNonceMessage)
}
var isValid bool
if user.GetEmail() != "" {
tokenHash := crypto.GenerateTokenHash(user.GetEmail(), nonce)
isValid = isOtpValid(tokenHash, user.ReauthenticationToken, user.ReauthenticationSentAt, config.Mailer.OtpExp)
} else if user.GetPhone() != "" {
if config.Sms.IsTwilioVerifyProvider() {
smsProvider, _ := sms_provider.GetSmsProvider(*config)
if err := smsProvider.(*sms_provider.TwilioVerifyProvider).VerifyOTP(string(user.Phone), nonce); err != nil {
return apierrors.NewForbiddenError(apierrors.ErrorCodeOTPExpired, "Token has expired or is invalid").WithInternalError(err)
}
return nil
} else {
tokenHash := crypto.GenerateTokenHash(user.GetPhone(), nonce)
isValid = isOtpValid(tokenHash, user.ReauthenticationToken, user.ReauthenticationSentAt, config.Sms.OtpExp)
}
} else {
return apierrors.NewUnprocessableEntityError(apierrors.ErrorCodeReauthenticationNotValid, "Reauthentication requires an email or a phone number")
}
if !isValid {
return apierrors.NewUnprocessableEntityError(apierrors.ErrorCodeReauthenticationNotValid, InvalidNonceMessage)
}
if err := user.ConfirmReauthentication(tx); err != nil {
return apierrors.NewInternalServerError("Error during reauthentication").WithInternalError(err)
}
return nil
}
|
verifyReauthentication checks if the nonce provided is valid
|
verifyReauthentication
|
go
|
supabase/auth
|
internal/api/reauthenticate.go
|
https://github.com/supabase/auth/blob/master/internal/api/reauthenticate.go
|
MIT
|
func (a *API) getSAMLServiceProvider(identityProvider *saml.EntityDescriptor, idpInitiated bool) *saml.ServiceProvider {
var externalURL *url.URL
if a.config.SAML.ExternalURL != "" {
url, err := url.ParseRequestURI(a.config.SAML.ExternalURL)
if err != nil {
// this should not fail as a.config should have been validated using #Validate()
panic(err)
}
externalURL = url
} else {
url, err := url.ParseRequestURI(a.config.API.ExternalURL)
if err != nil {
// this should not fail as a.config should have been validated using #Validate()
panic(err)
}
externalURL = url
}
if !strings.HasSuffix(externalURL.Path, "/") {
externalURL.Path += "/"
}
externalURL.Path += "sso/"
provider := samlsp.DefaultServiceProvider(samlsp.Options{
URL: *externalURL,
Key: a.config.SAML.RSAPrivateKey,
Certificate: a.config.SAML.Certificate,
SignRequest: true,
AllowIDPInitiated: idpInitiated,
IDPMetadata: identityProvider,
})
provider.AuthnNameIDFormat = saml.PersistentNameIDFormat
return &provider
}
|
getSAMLServiceProvider generates a new service provider object with the
(optionally) provided descriptor (metadata) for the identity provider.
|
getSAMLServiceProvider
|
go
|
supabase/auth
|
internal/api/saml.go
|
https://github.com/supabase/auth/blob/master/internal/api/saml.go
|
MIT
|
func (a *API) SAMLMetadata(w http.ResponseWriter, r *http.Request) error {
serviceProvider := a.getSAMLServiceProvider(nil, true)
metadata := serviceProvider.Metadata()
if r.FormValue("download") == "true" {
// 5 year expiration, comparable to what GSuite does
metadata.ValidUntil = time.Now().UTC().AddDate(5, 0, 0)
}
for i := range metadata.SPSSODescriptors {
// we set this to false since the IdP initiated flow can only
// sign the Assertion, and not the full Request
// unfortunately this is hardcoded in the crewjam library if
// signatures (instead of encryption) are supported
// https://github.com/crewjam/saml/blob/v0.4.8/service_provider.go#L217
metadata.SPSSODescriptors[i].AuthnRequestsSigned = nil
// advertize the requested NameID formats (either persistent or email address)
metadata.SPSSODescriptors[i].NameIDFormats = []saml.NameIDFormat{
saml.EmailAddressNameIDFormat,
saml.PersistentNameIDFormat,
}
}
for i := range metadata.SPSSODescriptors {
spd := &metadata.SPSSODescriptors[i]
var keyDescriptors []saml.KeyDescriptor
for _, kd := range spd.KeyDescriptors {
// only advertize key as usable for encryption if allowed
if kd.Use == "signing" || (a.config.SAML.AllowEncryptedAssertions && kd.Use == "encryption") {
keyDescriptors = append(keyDescriptors, kd)
}
}
spd.KeyDescriptors = keyDescriptors
}
metadataXML, err := xml.Marshal(metadata)
if err != nil {
return err
}
w.Header().Set("Content-Type", "application/xml")
w.Header().Set("Cache-Control", "public, max-age=600") // cache at CDN for 10 minutes
if r.FormValue("download") == "true" {
w.Header().Set("Content-Disposition", "attachment; filename=\"metadata.xml\"")
}
_, err = w.Write(metadataXML)
return err
}
|
SAMLMetadata serves GoTrue's SAML Service Provider metadata file.
|
SAMLMetadata
|
go
|
supabase/auth
|
internal/api/saml.go
|
https://github.com/supabase/auth/blob/master/internal/api/saml.go
|
MIT
|
func (a *API) handleSamlAcs(w http.ResponseWriter, r *http.Request) error {
ctx := r.Context()
db := a.db.WithContext(ctx)
config := a.config
log := observability.GetLogEntry(r).Entry
relayStateValue := r.FormValue("RelayState")
relayStateUUID := uuid.FromStringOrNil(relayStateValue)
relayStateURL, _ := url.ParseRequestURI(relayStateValue)
entityId := ""
initiatedBy := ""
redirectTo := ""
var requestIds []string
var flowState *models.FlowState
if relayStateUUID != uuid.Nil {
// relay state is a valid UUID, therefore this is likely a SP initiated flow
relayState, err := models.FindSAMLRelayStateByID(db, relayStateUUID)
if models.IsNotFoundError(err) {
return apierrors.NewNotFoundError(apierrors.ErrorCodeSAMLRelayStateNotFound, "SAML RelayState does not exist, try logging in again?")
} else if err != nil {
return err
}
if time.Since(relayState.CreatedAt) >= a.config.SAML.RelayStateValidityPeriod {
if err := a.samlDestroyRelayState(ctx, relayState); err != nil {
return apierrors.NewInternalServerError("SAML RelayState has expired and destroying it failed. Try logging in again?").WithInternalError(err)
}
return apierrors.NewUnprocessableEntityError(apierrors.ErrorCodeSAMLRelayStateExpired, "SAML RelayState has expired. Try logging in again?")
}
// TODO: add abuse detection to bind the RelayState UUID with a
// HTTP-Only cookie
ssoProvider, err := models.FindSSOProviderByID(db, relayState.SSOProviderID)
if err != nil {
return apierrors.NewInternalServerError("Unable to find SSO Provider from SAML RelayState")
}
initiatedBy = "sp"
entityId = ssoProvider.SAMLProvider.EntityID
redirectTo = relayState.RedirectTo
requestIds = append(requestIds, relayState.RequestID)
if relayState.FlowState != nil {
flowState = relayState.FlowState
}
if err := a.samlDestroyRelayState(ctx, relayState); err != nil {
return err
}
} else if relayStateValue == "" || relayStateURL != nil {
// RelayState may be a URL in which case it's the URL where the
// IdP is telling us to redirect the user to
if r.FormValue("SAMLart") != "" {
// SAML Artifact responses are possible only when
// RelayState can be used to identify the Identity
// Provider.
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "SAML Artifact response can only be used with SP initiated flow")
}
samlResponse := r.FormValue("SAMLResponse")
if samlResponse == "" {
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "SAMLResponse is missing")
}
responseXML, err := base64.StdEncoding.DecodeString(samlResponse)
if err != nil {
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "SAMLResponse is not a valid Base64 string")
}
var peekResponse saml.Response
err = xml.Unmarshal(responseXML, &peekResponse)
if err != nil {
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "SAMLResponse is not a valid XML SAML assertion").WithInternalError(err)
}
initiatedBy = "idp"
entityId = peekResponse.Issuer.Value
redirectTo = relayStateValue
} else {
// RelayState can't be identified, so SAML flow can't continue
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "SAML RelayState is not a valid UUID or URL")
}
ssoProvider, err := models.FindSAMLProviderByEntityID(db, entityId)
if models.IsNotFoundError(err) {
return apierrors.NewNotFoundError(apierrors.ErrorCodeSAMLIdPNotFound, "A SAML connection has not been established with this Identity Provider")
} else if err != nil {
return err
}
idpMetadata, err := ssoProvider.SAMLProvider.EntityDescriptor()
if err != nil {
return err
}
samlMetadataModified := false
if ssoProvider.SAMLProvider.MetadataURL == nil {
if !idpMetadata.ValidUntil.IsZero() && time.Until(idpMetadata.ValidUntil) <= (30*24*60)*time.Second {
logentry := log.WithField("sso_provider_id", ssoProvider.ID.String())
logentry = logentry.WithField("expires_in", time.Until(idpMetadata.ValidUntil).String())
logentry = logentry.WithField("valid_until", idpMetadata.ValidUntil)
logentry = logentry.WithField("saml_entity_id", ssoProvider.SAMLProvider.EntityID)
logentry.Warn("SAML Metadata for identity provider will expire soon! Update its metadata_xml!")
}
} else if *ssoProvider.SAMLProvider.MetadataURL != "" && IsSAMLMetadataStale(idpMetadata, ssoProvider.SAMLProvider) {
rawMetadata, err := fetchSAMLMetadata(ctx, *ssoProvider.SAMLProvider.MetadataURL)
if err != nil {
// Fail silently but raise warning and continue with existing metadata
logentry := log.WithField("sso_provider_id", ssoProvider.ID.String())
logentry = logentry.WithField("expires_in", time.Until(idpMetadata.ValidUntil).String())
logentry = logentry.WithField("valid_until", idpMetadata.ValidUntil)
logentry = logentry.WithError(err)
logentry.Warn("SAML Metadata could not be retrieved, continuing with existing metadata")
} else {
ssoProvider.SAMLProvider.MetadataXML = string(rawMetadata)
samlMetadataModified = true
}
}
serviceProvider := a.getSAMLServiceProvider(idpMetadata, initiatedBy == "idp")
spAssertion, err := serviceProvider.ParseResponse(r, requestIds)
if err != nil {
if ire, ok := err.(*saml.InvalidResponseError); ok {
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "SAML Assertion is not valid %s", ire.Response).WithInternalError(ire.PrivateErr)
}
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, "SAML Assertion is not valid").WithInternalError(err)
}
assertion := SAMLAssertion{
spAssertion,
}
userID := assertion.UserID()
if userID == "" {
return apierrors.NewBadRequestError(apierrors.ErrorCodeSAMLAssertionNoUserID, "SAML Assertion did not contain a persistent Subject Identifier attribute or Subject NameID uniquely identifying this user")
}
claims := assertion.Process(ssoProvider.SAMLProvider.AttributeMapping)
email, ok := claims["email"].(string)
if !ok || email == "" {
// mapping does not identify the email attribute, try to figure it out
email = assertion.Email()
}
if email == "" {
return apierrors.NewBadRequestError(apierrors.ErrorCodeSAMLAssertionNoEmail, "SAML Assertion does not contain an email address")
} else {
claims["email"] = email
}
jsonClaims, err := json.Marshal(claims)
if err != nil {
return apierrors.NewInternalServerError("Mapped claims from provider could not be serialized into JSON").WithInternalError(err)
}
providerClaims := &provider.Claims{}
if err := json.Unmarshal(jsonClaims, providerClaims); err != nil {
return apierrors.NewInternalServerError("Mapped claims from provider could not be deserialized from JSON").WithInternalError(err)
}
providerClaims.Subject = userID
providerClaims.Issuer = ssoProvider.SAMLProvider.EntityID
providerClaims.Email = email
providerClaims.EmailVerified = true
providerClaimsMap := structs.Map(providerClaims)
// remove all of the parsed claims, so that the rest can go into CustomClaims
for key := range providerClaimsMap {
delete(claims, key)
}
providerClaims.CustomClaims = claims
var userProvidedData provider.UserProvidedData
userProvidedData.Emails = append(userProvidedData.Emails, provider.Email{
Email: email,
Verified: true,
Primary: true,
})
// userProvidedData.Provider.Type = "saml"
// userProvidedData.Provider.ID = ssoProvider.ID.String()
// userProvidedData.Provider.SAMLEntityID = ssoProvider.SAMLProvider.EntityID
// userProvidedData.Provider.SAMLInitiatedBy = initiatedBy
userProvidedData.Metadata = providerClaims
// TODO: below
// refreshTokenParams.SSOProviderID = ssoProvider.ID
// refreshTokenParams.InitiatedByProvider = initiatedBy == "idp"
// refreshTokenParams.NotBefore = assertion.NotBefore()
// refreshTokenParams.NotAfter = assertion.NotAfter()
notAfter := assertion.NotAfter()
var grantParams models.GrantParams
grantParams.FillGrantParams(r)
if !notAfter.IsZero() {
grantParams.SessionNotAfter = ¬After
}
var token *AccessTokenResponse
if samlMetadataModified {
if err := db.UpdateColumns(&ssoProvider.SAMLProvider, "metadata_xml", "updated_at"); err != nil {
return err
}
}
providerType := "sso:" + ssoProvider.ID.String()
if err := a.triggerBeforeUserCreatedExternal(
r, db, &userProvidedData, providerType); err != nil {
return err
}
if err := db.Transaction(func(tx *storage.Connection) error {
var terr error
var user *models.User
// accounts potentially created via SAML can contain non-unique email addresses in the auth.users table
if user, terr = a.createAccountFromExternalIdentity(tx, r, &userProvidedData, providerType); terr != nil {
return terr
}
if flowState != nil {
// This means that the callback is using PKCE
flowState.UserID = &(user.ID)
if terr := tx.Update(flowState); terr != nil {
return terr
}
}
token, terr = a.issueRefreshToken(r, tx, user, models.SSOSAML, grantParams)
if terr != nil {
return apierrors.NewInternalServerError("Unable to issue refresh token from SAML Assertion").WithInternalError(terr)
}
return nil
}); err != nil {
return err
}
if !utilities.IsRedirectURLValid(config, redirectTo) {
redirectTo = config.SiteURL
}
if flowState != nil {
// This means that the callback is using PKCE
// Set the flowState.AuthCode to the query param here
redirectTo, err = a.prepPKCERedirectURL(redirectTo, flowState.AuthCode)
if err != nil {
return err
}
http.Redirect(w, r, redirectTo, http.StatusFound)
return nil
}
http.Redirect(w, r, token.AsRedirectURL(redirectTo, url.Values{}), http.StatusFound)
return nil
}
|
handleSamlAcs implements the main Assertion Consumer Service endpoint behavior.
|
handleSamlAcs
|
go
|
supabase/auth
|
internal/api/samlacs.go
|
https://github.com/supabase/auth/blob/master/internal/api/samlacs.go
|
MIT
|
func (a *SAMLAssertion) Attribute(name string) []saml.AttributeValue {
var values []saml.AttributeValue
for _, stmt := range a.AttributeStatements {
for _, attr := range stmt.Attributes {
if strings.EqualFold(attr.Name, name) || strings.EqualFold(attr.FriendlyName, name) {
values = append(values, attr.Values...)
}
}
}
return values
}
|
Attribute returns the first matching attribute value in the attribute
statements where name equals the official SAML attribute Name or
FriendlyName. Returns nil if such an attribute can't be found.
|
Attribute
|
go
|
supabase/auth
|
internal/api/samlassertion.go
|
https://github.com/supabase/auth/blob/master/internal/api/samlassertion.go
|
MIT
|
func (a *SAMLAssertion) UserID() string {
// First we look up the SAMLSubjectIDAttributeName in the attribute
// section of the assertion, as this is the preferred way to
// persistently identify users in SAML 2.0.
// See: https://docs.oasis-open.org/security/saml-subject-id-attr/v1.0/cs01/saml-subject-id-attr-v1.0-cs01.html#_Toc536097226
values := a.Attribute(SAMLSubjectIDAttributeName)
if len(values) > 0 {
return values[0].Value
}
// Otherwise, fall back to the SubjectID value.
subjectID, isPersistent := a.SubjectID()
if !isPersistent {
return ""
}
return subjectID
}
|
UserID returns the best choice for a persistent user identifier on the
Identity Provider side. Don't assume the format of the string returned, as
it's Identity Provider specific.
|
UserID
|
go
|
supabase/auth
|
internal/api/samlassertion.go
|
https://github.com/supabase/auth/blob/master/internal/api/samlassertion.go
|
MIT
|
func (a *SAMLAssertion) SubjectID() (string, bool) {
if a.Subject == nil {
return "", false
}
if a.Subject.NameID == nil {
return "", false
}
if a.Subject.NameID.Value == "" {
return "", false
}
if a.Subject.NameID.Format == string(saml.EmailAddressNameIDFormat) {
return strings.ToLower(strings.TrimSpace(a.Subject.NameID.Value)), true
}
// all other NameID formats are regarded as persistent
isPersistent := a.Subject.NameID.Format != string(saml.TransientNameIDFormat)
return a.Subject.NameID.Value, isPersistent
}
|
SubjectID returns the user identifier in present in the Subject section of
the SAML assertion. Note that this way of identifying the Subject is
generally superseded by the SAMLSubjectIDAttributeName assertion attribute;
tho must be present in all assertions. It can have a few formats, of which
the most important are: saml.EmailAddressNameIDFormat (meaning the user ID
is an email address), saml.PersistentNameIDFormat (the user ID is an opaque
string that does not change with each assertion, e.g. UUID),
saml.TransientNameIDFormat (the user ID changes with each assertion -- can't
be used to identify a user). The boolean returned identifies if the user ID
is persistent. If it's an email address, it's lowercased just in case.
|
SubjectID
|
go
|
supabase/auth
|
internal/api/samlassertion.go
|
https://github.com/supabase/auth/blob/master/internal/api/samlassertion.go
|
MIT
|
func (a *SAMLAssertion) Email() string {
attributeNames := []string{
"urn:oid:0.9.2342.19200300.100.1.3",
"http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress",
"http://schemas.xmlsoap.org/claims/EmailAddress",
"mail",
"Mail",
"email",
}
for _, name := range attributeNames {
for _, attr := range a.Attribute(name) {
if attr.Value != "" {
return attr.Value
}
}
}
if a.Subject.NameID.Format == string(saml.EmailAddressNameIDFormat) {
return a.Subject.NameID.Value
}
return ""
}
|
Email returns the best guess for an email address.
|
Email
|
go
|
supabase/auth
|
internal/api/samlassertion.go
|
https://github.com/supabase/auth/blob/master/internal/api/samlassertion.go
|
MIT
|
func (a *SAMLAssertion) Process(mapping models.SAMLAttributeMapping) map[string]interface{} {
ret := make(map[string]interface{})
for key, mapper := range mapping.Keys {
names := []string{}
if mapper.Name != "" {
names = append(names, mapper.Name)
}
names = append(names, mapper.Names...)
setKey := false
for _, name := range names {
for _, attr := range a.Attribute(name) {
if attr.Value != "" {
setKey = true
if mapper.Array {
if ret[key] == nil {
ret[key] = []string{}
}
ret[key] = append(ret[key].([]string), attr.Value)
} else {
ret[key] = attr.Value
break
}
}
}
if setKey {
break
}
}
if !setKey && mapper.Default != nil {
ret[key] = mapper.Default
}
}
return ret
}
|
Process processes this assertion according to the SAMLAttributeMapping. Never returns nil.
|
Process
|
go
|
supabase/auth
|
internal/api/samlassertion.go
|
https://github.com/supabase/auth/blob/master/internal/api/samlassertion.go
|
MIT
|
func (a *SAMLAssertion) NotBefore() time.Time {
if a.Conditions != nil && !a.Conditions.NotBefore.IsZero() {
return a.Conditions.NotBefore.UTC()
}
return time.Time{}
}
|
NotBefore extracts the time before which this assertion should not be
considered.
|
NotBefore
|
go
|
supabase/auth
|
internal/api/samlassertion.go
|
https://github.com/supabase/auth/blob/master/internal/api/samlassertion.go
|
MIT
|
func (a *SAMLAssertion) NotAfter() time.Time {
var notOnOrAfter time.Time
for _, statement := range a.AuthnStatements {
if statement.SessionNotOnOrAfter == nil {
continue
}
notOnOrAfter = *statement.SessionNotOnOrAfter
if !notOnOrAfter.IsZero() {
break
}
}
return notOnOrAfter
}
|
NotAfter extracts the time at which or after this assertion should not be
considered.
|
NotAfter
|
go
|
supabase/auth
|
internal/api/samlassertion.go
|
https://github.com/supabase/auth/blob/master/internal/api/samlassertion.go
|
MIT
|
func (a *API) Signup(w http.ResponseWriter, r *http.Request) error {
ctx := r.Context()
config := a.config
db := a.db.WithContext(ctx)
if config.DisableSignup {
return apierrors.NewUnprocessableEntityError(apierrors.ErrorCodeSignupDisabled, "Signups not allowed for this instance")
}
params := &SignupParams{}
if err := retrieveRequestParams(r, params); err != nil {
return err
}
params.ConfigureDefaults()
if err := a.validateSignupParams(ctx, params); err != nil {
return err
}
var err error
flowType := getFlowFromChallenge(params.CodeChallenge)
var user *models.User
var grantParams models.GrantParams
grantParams.FillGrantParams(r)
params.Aud = a.requestAud(ctx, r)
switch params.Provider {
case "email":
if !config.External.Email.Enabled {
return apierrors.NewBadRequestError(apierrors.ErrorCodeEmailProviderDisabled, "Email signups are disabled")
}
params.Email, err = a.validateEmail(params.Email)
if err != nil {
return err
}
user, err = models.IsDuplicatedEmail(db, params.Email, params.Aud, nil)
case "phone":
if !config.External.Phone.Enabled {
return apierrors.NewBadRequestError(apierrors.ErrorCodePhoneProviderDisabled, "Phone signups are disabled")
}
params.Phone, err = validatePhone(params.Phone)
if err != nil {
return err
}
user, err = models.FindUserByPhoneAndAudience(db, params.Phone, params.Aud)
default:
msg := ""
if config.External.Email.Enabled && config.External.Phone.Enabled {
msg = "Sign up only available with email or phone provider"
} else if config.External.Email.Enabled {
msg = "Sign up only available with email provider"
} else if config.External.Phone.Enabled {
msg = "Sign up only available with phone provider"
} else {
msg = "Sign up with this provider not possible"
}
return apierrors.NewBadRequestError(apierrors.ErrorCodeValidationFailed, msg)
}
if err != nil && !models.IsNotFoundError(err) {
return apierrors.NewInternalServerError("Database error finding user").WithInternalError(err)
}
var signupUser *models.User
if user == nil {
// always call this outside of a database transaction as this method
// can be computationally hard and block due to password hashing
signupUser, err = params.ToUserModel(false /* <- isSSOUser */)
if err != nil {
return err
}
if err := a.triggerBeforeUserCreated(r, db, signupUser); err != nil {
return err
}
}
err = db.Transaction(func(tx *storage.Connection) error {
var terr error
if user != nil {
if (params.Provider == "email" && user.IsConfirmed()) || (params.Provider == "phone" && user.IsPhoneConfirmed()) {
return UserExistsError
}
// do not update the user because we can't be sure of their claimed identity
} else {
user, terr = a.signupNewUser(tx, signupUser)
if terr != nil {
return terr
}
}
identity, terr := models.FindIdentityByIdAndProvider(tx, user.ID.String(), params.Provider)
if terr != nil {
if !models.IsNotFoundError(terr) {
return terr
}
identityData := structs.Map(provider.Claims{
Subject: user.ID.String(),
Email: user.GetEmail(),
})
for k, v := range params.Data {
if _, ok := identityData[k]; !ok {
identityData[k] = v
}
}
identity, terr = a.createNewIdentity(tx, user, params.Provider, identityData)
if terr != nil {
return terr
}
if terr := user.RemoveUnconfirmedIdentities(tx, identity); terr != nil {
return terr
}
}
user.Identities = []models.Identity{*identity}
if params.Provider == "email" && !user.IsConfirmed() {
if config.Mailer.Autoconfirm {
if terr = models.NewAuditLogEntry(r, tx, user, models.UserSignedUpAction, "", map[string]interface{}{
"provider": params.Provider,
}); terr != nil {
return terr
}
if terr = user.Confirm(tx); terr != nil {
return apierrors.NewInternalServerError("Database error updating user").WithInternalError(terr)
}
} else {
if terr = models.NewAuditLogEntry(r, tx, user, models.UserConfirmationRequestedAction, "", map[string]interface{}{
"provider": params.Provider,
}); terr != nil {
return terr
}
if isPKCEFlow(flowType) {
_, terr := generateFlowState(tx, params.Provider, models.EmailSignup, params.CodeChallengeMethod, params.CodeChallenge, &user.ID)
if terr != nil {
return terr
}
}
if terr = a.sendConfirmation(r, tx, user, flowType); terr != nil {
return terr
}
}
} else if params.Provider == "phone" && !user.IsPhoneConfirmed() {
if config.Sms.Autoconfirm {
if terr = models.NewAuditLogEntry(r, tx, user, models.UserSignedUpAction, "", map[string]interface{}{
"provider": params.Provider,
"channel": params.Channel,
}); terr != nil {
return terr
}
if terr = user.ConfirmPhone(tx); terr != nil {
return apierrors.NewInternalServerError("Database error updating user").WithInternalError(terr)
}
} else {
if terr = models.NewAuditLogEntry(r, tx, user, models.UserConfirmationRequestedAction, "", map[string]interface{}{
"provider": params.Provider,
}); terr != nil {
return terr
}
if _, terr := a.sendPhoneConfirmation(r, tx, user, params.Phone, phoneConfirmationOtp, params.Channel); terr != nil {
return terr
}
}
}
return nil
})
if err != nil {
if errors.Is(err, UserExistsError) {
err = db.Transaction(func(tx *storage.Connection) error {
if terr := models.NewAuditLogEntry(r, tx, user, models.UserRepeatedSignUpAction, "", map[string]interface{}{
"provider": params.Provider,
}); terr != nil {
return terr
}
return nil
})
if err != nil {
return err
}
if config.Mailer.Autoconfirm || config.Sms.Autoconfirm {
return apierrors.NewUnprocessableEntityError(apierrors.ErrorCodeUserAlreadyExists, "User already registered")
}
sanitizedUser, err := sanitizeUser(user, params)
if err != nil {
return err
}
return sendJSON(w, http.StatusOK, sanitizedUser)
}
return err
}
// handles case where Mailer.Autoconfirm is true or Phone.Autoconfirm is true
if user.IsConfirmed() || user.IsPhoneConfirmed() {
var token *AccessTokenResponse
err = db.Transaction(func(tx *storage.Connection) error {
var terr error
if terr = models.NewAuditLogEntry(r, tx, user, models.LoginAction, "", map[string]interface{}{
"provider": params.Provider,
}); terr != nil {
return terr
}
token, terr = a.issueRefreshToken(r, tx, user, models.PasswordGrant, grantParams)
if terr != nil {
return terr
}
return nil
})
if err != nil {
return err
}
metering.RecordLogin("password", user.ID)
return sendJSON(w, http.StatusOK, token)
}
if user.HasBeenInvited() {
// Remove sensitive fields
user.UserMetaData = map[string]interface{}{}
user.Identities = []models.Identity{}
}
return sendJSON(w, http.StatusOK, user)
}
|
Signup is the endpoint for registering a new user
|
Signup
|
go
|
supabase/auth
|
internal/api/signup.go
|
https://github.com/supabase/auth/blob/master/internal/api/signup.go
|
MIT
|
func sanitizeUser(u *models.User, params *SignupParams) (*models.User, error) {
now := time.Now()
u.ID = uuid.Must(uuid.NewV4())
u.Role, u.EmailChange = "", ""
u.CreatedAt, u.UpdatedAt, u.ConfirmationSentAt = now, now, &now
u.LastSignInAt, u.ConfirmedAt, u.EmailChangeSentAt, u.EmailConfirmedAt, u.PhoneConfirmedAt = nil, nil, nil, nil, nil
u.Identities = make([]models.Identity, 0)
u.UserMetaData = params.Data
u.Aud = params.Aud
// sanitize app_metadata
u.AppMetaData = map[string]interface{}{
"provider": params.Provider,
"providers": []string{params.Provider},
}
// sanitize param fields
switch params.Provider {
case "email":
u.Phone = ""
case "phone":
u.Email = ""
default:
u.Phone, u.Email = "", ""
}
return u, nil
}
|
sanitizeUser removes all user sensitive information from the user object
Should be used whenever we want to prevent information about whether a user is registered or not from leaking
|
sanitizeUser
|
go
|
supabase/auth
|
internal/api/signup.go
|
https://github.com/supabase/auth/blob/master/internal/api/signup.go
|
MIT
|
func (ts *SignupTestSuite) TestSignupTwice() {
// Request body
var buffer bytes.Buffer
encode := func() {
require.NoError(ts.T(), json.NewEncoder(&buffer).Encode(map[string]interface{}{
"email": "[email protected]",
"password": "test123",
"data": map[string]interface{}{
"a": 1,
},
}))
}
encode()
// Setup request
req := httptest.NewRequest(http.MethodPost, "http://localhost/signup", &buffer)
req.Header.Set("Content-Type", "application/json")
// Setup response recorder
w := httptest.NewRecorder()
y := httptest.NewRecorder()
ts.API.handler.ServeHTTP(y, req)
u, err := models.FindUserByEmailAndAudience(ts.API.db, "[email protected]", ts.Config.JWT.Aud)
if err == nil {
require.NoError(ts.T(), u.Confirm(ts.API.db))
}
encode()
ts.API.handler.ServeHTTP(w, req)
data := models.User{}
require.NoError(ts.T(), json.NewDecoder(w.Body).Decode(&data))
require.Equal(ts.T(), http.StatusOK, w.Code)
assert.NotEqual(ts.T(), u.ID, data.ID)
assert.Equal(ts.T(), "[email protected]", data.GetEmail())
assert.Equal(ts.T(), ts.Config.JWT.Aud, data.Aud)
assert.Equal(ts.T(), 1.0, data.UserMetaData["a"])
assert.Equal(ts.T(), "email", data.AppMetaData["provider"])
assert.Equal(ts.T(), []interface{}{"email"}, data.AppMetaData["providers"])
}
|
TestSignupTwice checks to make sure the same email cannot be registered twice
|
TestSignupTwice
|
go
|
supabase/auth
|
internal/api/signup_test.go
|
https://github.com/supabase/auth/blob/master/internal/api/signup_test.go
|
MIT
|
func (a *API) SingleSignOn(w http.ResponseWriter, r *http.Request) error {
ctx := r.Context()
db := a.db.WithContext(ctx)
params := &SingleSignOnParams{}
if err := retrieveRequestParams(r, params); err != nil {
return err
}
var err error
hasProviderID := false
if hasProviderID, err = params.validate(); err != nil {
return err
}
codeChallengeMethod := params.CodeChallengeMethod
codeChallenge := params.CodeChallenge
if err := validatePKCEParams(codeChallengeMethod, codeChallenge); err != nil {
return err
}
flowType := getFlowFromChallenge(params.CodeChallenge)
var flowStateID *uuid.UUID
flowStateID = nil
if isPKCEFlow(flowType) {
flowState, err := generateFlowState(db, models.SSOSAML.String(), models.SSOSAML, codeChallengeMethod, codeChallenge, nil)
if err != nil {
return err
}
flowStateID = &flowState.ID
}
var ssoProvider *models.SSOProvider
if hasProviderID {
ssoProvider, err = models.FindSSOProviderByID(db, params.ProviderID)
if models.IsNotFoundError(err) {
return apierrors.NewNotFoundError(apierrors.ErrorCodeSSOProviderNotFound, "No such SSO provider")
} else if err != nil {
return apierrors.NewInternalServerError("Unable to find SSO provider by ID").WithInternalError(err)
}
} else {
ssoProvider, err = models.FindSSOProviderByDomain(db, params.Domain)
if models.IsNotFoundError(err) {
return apierrors.NewNotFoundError(apierrors.ErrorCodeSSOProviderNotFound, "No SSO provider assigned for this domain")
} else if err != nil {
return apierrors.NewInternalServerError("Unable to find SSO provider by domain").WithInternalError(err)
}
}
entityDescriptor, err := ssoProvider.SAMLProvider.EntityDescriptor()
if err != nil {
return apierrors.NewInternalServerError("Error parsing SAML Metadata for SAML provider").WithInternalError(err)
}
serviceProvider := a.getSAMLServiceProvider(entityDescriptor, false /* <- idpInitiated */)
authnRequest, err := serviceProvider.MakeAuthenticationRequest(
serviceProvider.GetSSOBindingLocation(saml.HTTPRedirectBinding),
saml.HTTPRedirectBinding,
saml.HTTPPostBinding,
)
if err != nil {
return apierrors.NewInternalServerError("Error creating SAML Authentication Request").WithInternalError(err)
}
// Some IdPs do not support the use of the `persistent` NameID format,
// and require a different format to be sent to work.
if ssoProvider.SAMLProvider.NameIDFormat != nil {
authnRequest.NameIDPolicy.Format = ssoProvider.SAMLProvider.NameIDFormat
}
relayState := models.SAMLRelayState{
SSOProviderID: ssoProvider.ID,
RequestID: authnRequest.ID,
RedirectTo: params.RedirectTo,
FlowStateID: flowStateID,
}
if err := db.Transaction(func(tx *storage.Connection) error {
if terr := tx.Create(&relayState); terr != nil {
return apierrors.NewInternalServerError("Error creating SAML relay state from sign up").WithInternalError(err)
}
return nil
}); err != nil {
return err
}
ssoRedirectURL, err := authnRequest.Redirect(relayState.ID.String(), serviceProvider)
if err != nil {
return apierrors.NewInternalServerError("Error creating SAML authentication request redirect URL").WithInternalError(err)
}
skipHTTPRedirect := false
if params.SkipHTTPRedirect != nil {
skipHTTPRedirect = *params.SkipHTTPRedirect
}
if skipHTTPRedirect {
return sendJSON(w, http.StatusOK, SingleSignOnResponse{
URL: ssoRedirectURL.String(),
})
}
http.Redirect(w, r, ssoRedirectURL.String(), http.StatusSeeOther)
return nil
}
|
SingleSignOn handles the single-sign-on flow for a provided SSO domain or provider.
|
SingleSignOn
|
go
|
supabase/auth
|
internal/api/sso.go
|
https://github.com/supabase/auth/blob/master/internal/api/sso.go
|
MIT
|
func (a *API) loadSSOProvider(w http.ResponseWriter, r *http.Request) (context.Context, error) {
ctx := r.Context()
db := a.db.WithContext(ctx)
idpParam := chi.URLParam(r, "idp_id")
idpID, err := uuid.FromString(idpParam)
if err != nil {
// idpParam is not UUIDv4
return nil, apierrors.NewNotFoundError(apierrors.ErrorCodeSSOProviderNotFound, "SSO Identity Provider not found")
}
// idpParam is a UUIDv4
provider, err := models.FindSSOProviderByID(db, idpID)
if err != nil {
if models.IsNotFoundError(err) {
return nil, apierrors.NewNotFoundError(apierrors.ErrorCodeSSOProviderNotFound, "SSO Identity Provider not found")
} else {
return nil, apierrors.NewInternalServerError("Database error finding SSO Identity Provider").WithInternalError(err)
}
}
observability.LogEntrySetField(r, "sso_provider_id", provider.ID.String())
return withSSOProvider(r.Context(), provider), nil
}
|
loadSSOProvider looks for an idp_id parameter in the URL route and loads the SSO provider
with that ID (or resource ID) and adds it to the context.
|
loadSSOProvider
|
go
|
supabase/auth
|
internal/api/ssoadmin.go
|
https://github.com/supabase/auth/blob/master/internal/api/ssoadmin.go
|
MIT
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.