Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

chore: global sso for saas login (#19717)

ecmadaoa9ae9c4f8ea3
diff --git a/backend/api/v1/actuator_service.go b/backend/api/v1/actuator_service.go
index bd987936b7..689a2b9a6a 100644
--- a/backend/api/v1/actuator_service.go
+++ b/backend/api/v1/actuator_service.go
@@ -154,8 +154,8 @@ func (s *ActuatorService) SetupSample(
}
var defaultAccountRestriction = &v1pb.Restriction{
- DisallowSignup: false,
- DisallowPasswordSignin: false,
+ DisallowSignup: true,
+ DisallowPasswordSignin: true,
PasswordRestriction: &v1pb.WorkspaceProfileSetting_PasswordRestriction{
MinLength: 8,
},
@@ -241,7 +241,7 @@ func (s *ActuatorService) getUsedFeatures(ctx context.Context, workspaceID strin
var features []v1pb.PlanFeature
// idp
- idps, err := s.store.ListIdentityProviders(ctx, &store.FindIdentityProviderMessage{Workspace: workspaceID})
+ idps, err := s.store.ListIdentityProviders(ctx, &store.FindIdentityProviderMessage{Workspace: &workspaceID})
if err != nil {
return nil, errors.Wrapf(err, "failed to list identity providers")
}
diff --git a/backend/api/v1/auth_service.go b/backend/api/v1/auth_service.go
index 91ca57e3a8..4667eec6d7 100644
--- a/backend/api/v1/auth_service.go
+++ b/backend/api/v1/auth_service.go
@@ -488,6 +488,8 @@ func (s *AuthService) getOrCreateUserWithIDP(ctx context.Context, request *v1pb.
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("identity provider not found"))
}
+ // For workspace-scoped IDPs, use the IDP's workspace.
+ // For global IDPs (SaaS), workspace is resolved after authentication from user membership.
workspaceID := idp.Workspace
externalURL, err := utils.GetEffectiveExternalURL(ctx, s.store, s.profile, workspaceID)
if err != nil {
@@ -578,85 +580,116 @@ func (s *AuthService) getOrCreateUserWithIDP(ctx context.Context, request *v1pb.
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "invalid email %q", userInfo.Identifier))
}
}
- // If the email is still invalid, we will return an error.
- if err := validateEmailWithDomains(ctx, s.licenseService, s.store, workspaceID, email, false); err != nil {
- return nil, err
- }
user, err := s.store.GetUserByEmail(ctx, email)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to list users by email %s", email))
}
- if user != nil {
- if user.MemberDeleted {
- if err := userCountGuard(ctx, s.store, s.licenseService, workspaceID); err != nil {
+ // User login through global SSO, then we should auth-resolve the workspace id.
+ if user != nil && workspaceID == "" {
+ wsID, err := s.resolveWorkspaceForLogin(ctx, user)
+ if err != nil {
+ slog.Warn("failed to resolve workspace", slog.String("user", user.Email), log.BBError(err))
+ }
+ workspaceID = wsID
+ }
+ // First time login through SSO
+ if user == nil {
+ if workspaceID != "" {
+ if err := validateEmailWithDomains(ctx, s.licenseService, s.store, workspaceID, email, false); err != nil {
return nil, err
}
- // Undelete the user when login via SSO.
- user, err = s.store.UpdateUser(ctx, user, &store.UpdateUserMessage{Delete: &undeletePatch})
- if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to undelete user"))
+
+ // We will only block new create creation and still allow SSO login from existing users.
+ featurePlan := v1pb.PlanFeature_FEATURE_ENTERPRISE_SSO
+ if idp.Type == storepb.IdentityProviderType_OAUTH2 && googleGitHubDomains[idp.Domain] {
+ featurePlan = v1pb.PlanFeature_FEATURE_GOOGLE_AND_GITHUB_SSO
}
- }
- if userInfo.HasGroups {
- // Sync user groups with the identity provider.
- // The userInfo.Groups is the groups that the user belongs to in the identity provider.
- if err := s.syncUserGroups(ctx, user, workspaceID, userInfo.Groups); err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to sync user groups"))
+ if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, featurePlan); err != nil {
+ return nil, connect.NewError(connect.CodePermissionDenied, err)
+ }
+
+ if err := userCountGuard(ctx, s.store, s.licenseService, workspaceID); err != nil {
+ return nil, err
}
}
- return user, nil
- }
- // For expired license, we will only block new create creation and still allow SSO login from existing users.
- featurePlan := v1pb.PlanFeature_FEATURE_ENTERPRISE_SSO
- if idp.Type == storepb.IdentityProviderType_OAUTH2 && googleGitHubDomains[idp.Domain] {
- featurePlan = v1pb.PlanFeature_FEATURE_GOOGLE_AND_GITHUB_SSO
- }
- if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, featurePlan); err != nil {
- return nil, connect.NewError(connect.CodePermissionDenied, err)
- }
- // Create new user from identity provider.
- password, err := common.RandomString(20)
- if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to generate random password"))
- }
- passwordHash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
- if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to generate password hash"))
- }
- if err := userCountGuard(ctx, s.store, s.licenseService, workspaceID); err != nil {
- return nil, err
+ // Create new user from identity provider.
+ password, err := common.RandomString(20)
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to generate random password"))
+ }
+ passwordHash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to generate password hash"))
+ }
+
+ newUser, err := s.store.CreateUser(ctx, &store.UserMessage{
+ Name: userInfo.DisplayName,
+ Email: email,
+ Phone: userInfo.Phone,
+ Type: storepb.PrincipalType_END_USER,
+ PasswordHash: string(passwordHash),
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to create user"))
+ }
+
+ user = newUser
}
- newUser, err := s.store.CreateUser(ctx, &store.UserMessage{
- Name: userInfo.DisplayName,
- Email: email,
- Phone: userInfo.Phone,
- Type: storepb.PrincipalType_END_USER,
- PasswordHash: string(passwordHash),
- })
- if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to create user"))
+
+ if workspaceID == "" {
+ // Global IDP: create a new workspace for the user (same as Signup flow).
+ wsID, err := common.RandomString(16)
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to generate workspace ID"))
+ }
+ ws, err := s.store.CreateWorkspace(ctx, &store.WorkspaceMessage{
+ ResourceID: wsID,
+ Name: "Default workspace",
+ }, email)
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to create workspace"))
+ }
+ workspaceID = ws.ResourceID
+ } else {
+ // Workspace-scoped IDP: add user as member only if not already in the workspace.
+ ws, err := s.store.FindWorkspace(ctx, &store.FindWorkspaceMessage{
+ WorkspaceID: &workspaceID,
+ Email: email,
+ IncludeAllUser: !s.profile.SaaS,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to check workspace membership"))
+ }
+ if ws == nil {
+ if _, err := s.store.PatchWorkspaceIamPolicy(ctx, &store.PatchIamPolicyMessage{
+ Workspace: workspaceID,
+ Member: common.FormatUserEmail(email),
+ Roles: []string{common.FormatRole(store.WorkspaceMemberRole)},
+ }); err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to add user to workspace"))
+ }
+ }
}
- // Add the new user to the workspace IAM policy as a member.
- // The IDP is workspace-scoped, so authenticating through it grants workspace access.
- if _, err := s.store.PatchWorkspaceIamPolicy(ctx, &store.PatchIamPolicyMessage{
- Workspace: workspaceID,
- Member: common.FormatUserEmail(email),
- Roles: []string{common.FormatRole(store.WorkspaceMemberRole)},
- }); err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to add user to workspace"))
+ if user.MemberDeleted {
+ if err := userCountGuard(ctx, s.store, s.licenseService, workspaceID); err != nil {
+ return nil, err
+ }
+ // Undelete the user when login via SSO.
+ user, err = s.store.UpdateUser(ctx, user, &store.UpdateUserMessage{Delete: &undeletePatch})
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to undelete user"))
+ }
}
if userInfo.HasGroups {
- // Sync user groups with the identity provider.
- // The userInfo.Groups is the groups that the user belongs to in the identity provider.
- if err := s.syncUserGroups(ctx, newUser, workspaceID, userInfo.Groups); err != nil {
+ if err := s.syncUserGroups(ctx, user, workspaceID, userInfo.Groups); err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to sync user groups"))
}
}
- return newUser, nil
+ return user, nil
}
// countRecentLoginFailures counts the number of failed login attempts for a given email
diff --git a/backend/api/v1/idp_service.go b/backend/api/v1/idp_service.go
index 467e7c0f43..a1a4589b5e 100644
--- a/backend/api/v1/idp_service.go
+++ b/backend/api/v1/idp_service.go
@@ -54,15 +54,33 @@ func (s *IdentityProviderService) GetIdentityProvider(ctx context.Context, req *
// ListIdentityProviders lists all identity providers.
func (s *IdentityProviderService) ListIdentityProviders(ctx context.Context, _ *connect.Request[v1pb.ListIdentityProvidersRequest]) (*connect.Response[v1pb.ListIdentityProvidersResponse], error) {
// allow_without_credential: workspace may not be in context (login page).
- // In self-hosted (single workspace), fall back to store lookup.
+ // List global IDPs (workspace IS NULL) and workspace-scoped IDPs separately.
+ var identityProviders []*store.IdentityProviderMessage
+
+ // TODO(ed): how to let SaaS users get their workspace IDPs before login?
workspaceID := common.GetWorkspaceIDFromContext(ctx)
if workspaceID == "" && !s.profile.SaaS {
- workspaceID, _ = s.store.GetWorkspaceID(ctx)
+ defaultWorkspaceID, err := s.store.GetWorkspaceID(ctx)
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to find workspace id"))
+ }
+ workspaceID = defaultWorkspaceID
}
- identityProviders, err := s.store.ListIdentityProviders(ctx, &store.FindIdentityProviderMessage{Workspace: workspaceID})
- if err != nil {
- return nil, connect.NewError(connect.CodeInternal, err)
+
+ if workspaceID != "" {
+ wsIDPs, err := s.store.ListIdentityProviders(ctx, &store.FindIdentityProviderMessage{Workspace: &workspaceID})
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, err)
+ }
+ identityProviders = append(identityProviders, wsIDPs...)
+ } else {
+ globalIDPs, err := s.store.ListIdentityProviders(ctx, &store.FindIdentityProviderMessage{})
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, err)
+ }
+ identityProviders = append(identityProviders, globalIDPs...)
}
+
response := &v1pb.ListIdentityProvidersResponse{}
for _, identityProviderMessage := range identityProviders {
identityProvider := convertToIdentityProvider(identityProviderMessage)
@@ -135,8 +153,9 @@ func (s *IdentityProviderService) UpdateIdentityProvider(ctx context.Context, re
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
+ wsID := common.GetWorkspaceIDFromContext(ctx)
identityProviderMessage, err := s.store.GetIdentityProvider(ctx, &store.FindIdentityProviderMessage{
- Workspace: common.GetWorkspaceIDFromContext(ctx),
+ Workspace: &wsID,
ResourceID: &identityProviderID,
})
if err != nil {
@@ -154,7 +173,6 @@ func (s *IdentityProviderService) UpdateIdentityProvider(ctx context.Context, re
patch := &store.UpdateIdentityProviderMessage{
ResourceID: identityProviderMessage.ResourceID,
- Workspace: identityProviderMessage.Workspace,
}
for _, path := range req.Msg.UpdateMask.Paths {
switch path {
@@ -207,7 +225,7 @@ func (s *IdentityProviderService) DeleteIdentityProvider(ctx context.Context, re
return nil, err
}
- if err := s.store.DeleteIdentityProvider(ctx, identityProvider.Workspace, identityProvider.ResourceID); err != nil {
+ if err := s.store.DeleteIdentityProvider(ctx, identityProvider.ResourceID); err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
return connect.NewResponse(&emptypb.Empty{}), nil
@@ -394,8 +412,9 @@ func (s *IdentityProviderService) getIdentityProviderMessage(ctx context.Context
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
+ wsID := common.GetWorkspaceIDFromContext(ctx)
identityProvider, err := s.store.GetIdentityProvider(ctx, &store.FindIdentityProviderMessage{
- Workspace: common.GetWorkspaceIDFromContext(ctx),
+ Workspace: &wsID,
ResourceID: &identityProviderID,
})
if err != nil {
diff --git a/backend/api/v1/setting_service.go b/backend/api/v1/setting_service.go
index 0c0b292a98..ea1bf6e8e5 100644
--- a/backend/api/v1/setting_service.go
+++ b/backend/api/v1/setting_service.go
@@ -292,7 +292,8 @@ func (s *SettingService) UpdateSetting(ctx context.Context, request *connect.Req
return nil, connect.NewError(connect.CodePermissionDenied, err)
}
- identityProviders, err := s.store.ListIdentityProviders(ctx, &store.FindIdentityProviderMessage{Workspace: common.GetWorkspaceIDFromContext(ctx)})
+ settingWsID := common.GetWorkspaceIDFromContext(ctx)
+ identityProviders, err := s.store.ListIdentityProviders(ctx, &store.FindIdentityProviderMessage{Workspace: &settingWsID})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to list identity providers: %v", err))
}
diff --git a/backend/migrator/migration/3.17/0011##idp_nullable_workspace.sql b/backend/migrator/migration/3.17/0011##idp_nullable_workspace.sql
new file mode 100644
index 0000000000..ae6e55a59f
--- /dev/null
+++ b/backend/migrator/migration/3.17/0011##idp_nullable_workspace.sql
@@ -0,0 +1,3 @@
+-- Allow global IDPs (SaaS login) by making workspace nullable.
+-- NULL workspace = global IDP, non-NULL = workspace-scoped IDP.
+ALTER TABLE idp ALTER COLUMN workspace DROP NOT NULL;
diff --git a/backend/migrator/migration/LATEST.sql b/backend/migrator/migration/LATEST.sql
index f3c5c20e2e..b2b87f77f4 100644
--- a/backend/migrator/migration/LATEST.sql
+++ b/backend/migrator/migration/LATEST.sql
@@ -99,7 +99,8 @@ CREATE UNIQUE INDEX idx_policy_unique_workspace_resource ON policy(workspace, re
CREATE TABLE idp (
-- golbal unique
resource_id text NOT NULL PRIMARY KEY,
- workspace text NOT NULL REFERENCES workspace(resource_id),
+ -- NULL for global IDPs (SaaS login), non-NULL for workspace-scoped IDPs.
+ workspace text REFERENCES workspace(resource_id),
name text NOT NULL,
domain text NOT NULL,
type text NOT NULL CONSTRAINT idp_type_check CHECK (type IN ('OAUTH2', 'OIDC', 'LDAP')),
diff --git a/backend/migrator/migrator_test.go b/backend/migrator/migrator_test.go
index 7e14268ea0..e0b8e7ef6c 100644
--- a/backend/migrator/migrator_test.go
+++ b/backend/migrator/migrator_test.go
@@ -15,8 +15,8 @@ import (
func TestLatestVersion(t *testing.T) {
files, err := getSortedVersionedFiles()
require.NoError(t, err)
- require.Equal(t, semver.MustParse("3.17.10"), *files[len(files)-1].version)
- require.Equal(t, "migration/3.17/0010##setting_composite_pk.sql", files[len(files)-1].path)
+ require.Equal(t, semver.MustParse("3.17.11"), *files[len(files)-1].version)
+ require.Equal(t, "migration/3.17/0011##idp_nullable_workspace.sql", files[len(files)-1].path)
}
func TestVersionUnique(t *testing.T) {
diff --git a/backend/plugin/db/util/ssh.go b/backend/plugin/db/util/ssh.go
index 784df293b2..f5327208ad 100644
--- a/backend/plugin/db/util/ssh.go
+++ b/backend/plugin/db/util/ssh.go
@@ -31,12 +31,8 @@ func GetSSHClient(ds *storepb.DataSource) (*ssh.Client, error) {
// we will try to connect to the ssh-agent to get the private key.
if conn, err := net.Dial("unix", os.Getenv("SSH_AUTH_SOCK")); err == nil {
defer conn.Close()
- // Create a new instance of the ssh agent
agentClient := agent.NewClient(conn)
- // When the agentClient connection succeeded, add them as AuthMethod
- if agentClient != nil {
- sshConfig.Auth = append(sshConfig.Auth, ssh.PublicKeysCallback(agentClient.Signers))
- }
+ sshConfig.Auth = append(sshConfig.Auth, ssh.PublicKeysCallback(agentClient.Signers))
}
}
// When there's a non empty password add the password AuthMethod.
diff --git a/backend/store/idp.go b/backend/store/idp.go
index c105df52d2..9ddbef812b 100644
--- a/backend/store/idp.go
+++ b/backend/store/idp.go
@@ -15,11 +15,12 @@ import (
// IdentityProviderMessage is the message for identity provider.
type IdentityProviderMessage struct {
ResourceID string
- Workspace string
- Title string
- Domain string
- Type storepb.IdentityProviderType
- Config *storepb.IdentityProviderConfig
+ // Empty string for global IDPs (SaaS login), non-empty for workspace-scoped IDPs.
+ Workspace string
+ Title string
+ Domain string
+ Type storepb.IdentityProviderType
+ Config *storepb.IdentityProviderConfig
}
func getConfigBytes(config *storepb.IdentityProviderConfig) ([]byte, error) {
@@ -38,14 +39,17 @@ func getConfigBytes(config *storepb.IdentityProviderConfig) ([]byte, error) {
// FindIdentityProviderMessage is the message for finding identity providers.
type FindIdentityProviderMessage struct {
- Workspace string
+ // Workspace filters by workspace:
+ // - non-nil: query WHERE workspace = ? (workspace-scoped IDPs)
+ // - nil: query WHERE workspace IS NULL (global IDPs)
+ // Use separate calls to get both workspace-scoped and global IDPs.
+ Workspace *string
ResourceID *string
}
// UpdateIdentityProviderMessage is the message for updating an identity provider.
type UpdateIdentityProviderMessage struct {
ResourceID string
- Workspace string
Title *string
Domain *string
@@ -67,6 +71,12 @@ func (s *Store) CreateIdentityProvider(ctx context.Context, create *IdentityProv
return nil, errors.Wrap(err, "failed to marshal identity provider config")
}
+ // Use NULL for global IDPs (empty workspace).
+ var workspaceArg any
+ if create.Workspace != "" {
+ workspaceArg = create.Workspace
+ }
+
q := qb.Q().Space(`
INSERT INTO idp (
resource_id,
@@ -77,7 +87,7 @@ func (s *Store) CreateIdentityProvider(ctx context.Context, create *IdentityProv
config
)
VALUES (?, ?, ?, ?, ?, ?)
- `, create.ResourceID, create.Workspace, create.Title, create.Domain, create.Type.String(), configBytes)
+ `, create.ResourceID, workspaceArg, create.Title, create.Domain, create.Type.String(), configBytes)
query, args, err := q.ToSQL()
if err != nil {
@@ -91,7 +101,6 @@ func (s *Store) CreateIdentityProvider(ctx context.Context, create *IdentityProv
return identityProvider, nil
}
-// GetIdentityProvider gets an identity provider.
// GetIdentityProviderByID gets an identity provider by its globally unique resource ID without workspace filter.
// For use by login flow where workspace is not yet known — the workspace is resolved from the IDP entity.
func (s *Store) GetIdentityProviderByID(ctx context.Context, resourceID string) (*IdentityProviderMessage, error) {
@@ -107,16 +116,20 @@ func (s *Store) GetIdentityProviderByID(ctx context.Context, resourceID string)
}
var idp IdentityProviderMessage
+ var workspace sql.NullString
var idpType string
var idpConfig string
if err := s.GetDB().QueryRowContext(ctx, query, args...).Scan(
- &idp.ResourceID, &idp.Workspace, &idp.Title, &idp.Domain, &idpType, &idpConfig,
+ &idp.ResourceID, &workspace, &idp.Title, &idp.Domain, &idpType, &idpConfig,
); err != nil {
if err == sql.ErrNoRows {
return nil, nil
}
return nil, errors.Wrap(err, "failed to get identity provider")
}
+ if workspace.Valid {
+ idp.Workspace = workspace.String
+ }
idp.Type = convertIdentityProviderType(idpType)
idp.Config = convertIdentityProviderConfigString(idp.Type, idpConfig)
return &idp, nil
@@ -148,8 +161,14 @@ func (s *Store) ListIdentityProviders(ctx context.Context, find *FindIdentityPro
type,
config
FROM idp
- WHERE workspace = ?
- `, find.Workspace)
+ WHERE TRUE
+ `)
+
+ if v := find.Workspace; v != nil {
+ q.And("workspace = ?", *v)
+ } else {
+ q.And("workspace IS NULL")
+ }
if v := find.ResourceID; v != nil {
q.And("resource_id = ?", *v)
@@ -171,11 +190,12 @@ func (s *Store) ListIdentityProviders(ctx context.Context, find *FindIdentityPro
var identityProviderMessages []*IdentityProviderMessage
for rows.Next() {
var identityProviderMessage IdentityProviderMessage
+ var workspace sql.NullString
var identityProviderType string
var identityProviderConfig string
if err := rows.Scan(
&identityProviderMessage.ResourceID,
- &identityProviderMessage.Workspace,
+ &workspace,
&identityProviderMessage.Title,
&identityProviderMessage.Domain,
&identityProviderType,
@@ -183,6 +203,9 @@ func (s *Store) ListIdentityProviders(ctx context.Context, find *FindIdentityPro
); err != nil {
return nil, err
}
+ if workspace.Valid {
+ identityProviderMessage.Workspace = workspace.String
+ }
identityProviderMessage.Type = convertIdentityProviderType(identityProviderType)
identityProviderMessage.Config = convertIdentityProviderConfigString(identityProviderMessage.Type, identityProviderConfig)
identityProviderMessages = append(identityProviderMessages, &identityProviderMessage)
@@ -217,7 +240,7 @@ func (s *Store) UpdateIdentityProvider(ctx context.Context, patch *UpdateIdentit
q := qb.Q().Space(`
UPDATE idp
SET ?
- WHERE resource_id = ? AND workspace = ?
+ WHERE resource_id = ?
RETURNING
resource_id,
workspace,
@@ -225,7 +248,7 @@ func (s *Store) UpdateIdentityProvider(ctx context.Context, patch *UpdateIdentit
domain,
type,
config
- `, set, patch.ResourceID, patch.Workspace)
+ `, set, patch.ResourceID)
query, args, err := q.ToSQL()
if err != nil {
@@ -233,11 +256,12 @@ func (s *Store) UpdateIdentityProvider(ctx context.Context, patch *UpdateIdentit
}
identityProvider := &IdentityProviderMessage{}
+ var workspace sql.NullString
var identityProviderType string
var identityProviderConfig string
if err := s.GetDB().QueryRowContext(ctx, query, args...).Scan(
&identityProvider.ResourceID,
- &identityProvider.Workspace,
+ &workspace,
&identityProvider.Title,
&identityProvider.Domain,
&identityProviderType,
@@ -248,14 +272,17 @@ func (s *Store) UpdateIdentityProvider(ctx context.Context, patch *UpdateIdentit
}
return nil, err
}
+ if workspace.Valid {
+ identityProvider.Workspace = workspace.String
+ }
identityProvider.Type = convertIdentityProviderType(identityProviderType)
identityProvider.Config = convertIdentityProviderConfigString(identityProvider.Type, identityProviderConfig)
return identityProvider, nil
}
-func (s *Store) DeleteIdentityProvider(ctx context.Context, workspace string, resourceID string) error {
- q := qb.Q().Space("DELETE FROM idp WHERE resource_id = ? AND workspace = ?", resourceID, workspace)
+func (s *Store) DeleteIdentityProvider(ctx context.Context, resourceID string) error {
+ q := qb.Q().Space("DELETE FROM idp WHERE resource_id = ?", resourceID)
query, args, err := q.ToSQL()
if err != nil {
return errors.Wrapf(err, "failed to build sql")
diff --git a/backend/store/workspace.go b/backend/store/workspace.go
index b02244e156..ba7ec253fe 100644
--- a/backend/store/workspace.go
+++ b/backend/store/workspace.go
@@ -90,6 +90,7 @@ func (s *Store) CreateWorkspace(ctx context.Context, create *WorkspaceMessage, a
EnableMetricCollection: true,
DirectorySyncToken: uuid.New().String(),
DisallowSignup: true,
+ DisallowPasswordSignin: false,
PasswordRestriction: &storepb.WorkspaceProfileSetting_PasswordRestriction{MinLength: 8},
}},
{storepb.SettingName_ENVIRONMENT, &storepb.EnvironmentSetting{
diff --git a/frontend/src/components/GeneralSetting/AccountSetting.vue b/frontend/src/components/GeneralSetting/AccountSetting.vue
index 898de7bdfd..573b4fa4b3 100644
--- a/frontend/src/components/GeneralSetting/AccountSetting.vue
+++ b/frontend/src/components/GeneralSetting/AccountSetting.vue
@@ -42,8 +42,8 @@
/>
<NDivider />
- <div>
- <div class="mb-7 mt-4 lg:mt-0">
+ <div class="flex flex-col gap-y-7">
+ <div class="lg:mt-0">
<div class="flex items-center gap-x-2">
<PermissionGuardWrapper
v-slot="slotProps"
@@ -62,11 +62,11 @@
<FeatureBadge :feature="PlanFeature.FEATURE_TWO_FA" />
</div>
</div>
- <div class="mt-1 mb-3 text-sm text-gray-400">
+ <div class="mt-1 text-sm text-gray-400">
{{ $t("settings.general.workspace.require-2fa.description") }}
</div>
</div>
- <div class="mb-7 mt-4 lg:mt-0">
+ <div v-if="!isSaaSMode" class="lg:mt-0">
<div class="flex items-center gap-x-2">
<PermissionGuardWrapper
v-slot="slotProps"
@@ -109,7 +109,7 @@
/>
</div>
</div>
- <div class="mt-1 mb-3 text-sm text-gray-400">
+ <div class="mt-1 text-sm text-gray-400">
{{
$t(
"settings.general.workspace.disallow-password-signin.description"
@@ -118,6 +118,7 @@
</div>
</div>
</div>
+
<NDivider />
<TokenDurationSetting
diff --git a/frontend/src/views/auth/Signin.vue b/frontend/src/views/auth/Signin.vue
index c10b67f968..3180018d5a 100644
--- a/frontend/src/views/auth/Signin.vue
+++ b/frontend/src/views/auth/Signin.vue
@@ -1,9 +1,9 @@
<template>
<template v-if="initialized">
<div class="mx-auto w-full max-w-sm">
- <BytebaseLogo class="mx-auto" />
+ <BytebaseLogo class="mx-auto mb-8" />
- <div v-if="showSignInForm" class="mt-8">
+ <div v-if="showSignInForm">
<NCard>
<NTabs
class="card-tabs"