Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
package v1
import (
"context"
"log/slog"
"regexp"
"slices"
"strings"
"time"
"connectrpc.com/connect"
"github.com/pkg/errors"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/types/known/anypb"
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/common/log"
"github.com/bytebase/bytebase/backend/common/permission"
"github.com/bytebase/bytebase/backend/component/config"
"github.com/bytebase/bytebase/backend/component/iam"
"github.com/bytebase/bytebase/backend/enterprise"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
"github.com/bytebase/bytebase/backend/generated-go/v1/v1connect"
"github.com/bytebase/bytebase/backend/plugin/mailer"
"github.com/bytebase/bytebase/backend/plugin/webhook/dingtalk"
"github.com/bytebase/bytebase/backend/plugin/webhook/feishu"
"github.com/bytebase/bytebase/backend/plugin/webhook/lark"
"github.com/bytebase/bytebase/backend/plugin/webhook/slack"
"github.com/bytebase/bytebase/backend/plugin/webhook/teams"
"github.com/bytebase/bytebase/backend/plugin/webhook/wecom"
"github.com/bytebase/bytebase/backend/store"
)
// SettingService implements the setting service.
type SettingService struct {
v1connect.UnimplementedSettingServiceHandler
store *store.Store
profile *config.Profile
licenseService *enterprise.LicenseService
iamManager *iam.Manager
}
// NewSettingService creates a new setting service.
func NewSettingService(
store *store.Store,
profile *config.Profile,
licenseService *enterprise.LicenseService,
iamManager *iam.Manager,
) *SettingService {
return &SettingService{
store: store,
profile: profile,
licenseService: licenseService,
iamManager: iamManager,
}
}
// ListSettings lists all settings.
func (s *SettingService) ListSettings(ctx context.Context, _ *connect.Request[v1pb.ListSettingsRequest]) (*connect.Response[v1pb.ListSettingsResponse], error) {
settings, err := s.store.ListSettings(ctx, &store.FindSettingMessage{Workspace: common.GetWorkspaceIDFromContext(ctx)})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to list settings: %v", err))
}
response := &v1pb.ListSettingsResponse{}
for _, setting := range settings {
if s.isSettingDisallowed(setting.Name) {
continue
}
settingMessage, err := convertToSettingMessage(setting)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert setting message: %v", err))
}
response.Settings = append(response.Settings, settingMessage)
}
return connect.NewResponse(response), nil
}
// GetSetting gets the setting by name.
func (s *SettingService) GetSetting(ctx context.Context, request *connect.Request[v1pb.GetSettingRequest]) (*connect.Response[v1pb.Setting], error) {
settingName, err := common.GetSettingName(request.Msg.Name)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("setting name is invalid: %v", err))
}
if settingName == "" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("setting name is empty"))
}
storeSettingName, err := convertStringToSettingName(settingName)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid setting name: %v", err))
}
if s.isSettingDisallowed(storeSettingName) {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("setting is not available"))
}
var perm permission.Permission
switch storeSettingName {
case storepb.SettingName_ENVIRONMENT:
perm = permission.EnvironmentSettingsGet
case storepb.SettingName_WORKSPACE_PROFILE:
perm = permission.WorkspaceProfileSettingsGet
default:
perm = permission.SettingsGet
}
if err := s.checkSettingPermission(ctx, request, perm); err != nil {
return nil, err
}
setting, err := s.store.GetSetting(ctx, common.GetWorkspaceIDFromContext(ctx), storeSettingName)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get setting: %v", err))
}
if setting == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("setting %s not found", settingName))
}
// Only return whitelisted setting.
settingMessage, err := convertToSettingMessage(setting)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert setting message: %v", err))
}
if mcpSession(ctx) {
stripMaskingSalts(settingMessage)
}
return connect.NewResponse(settingMessage), nil
}
// stripMaskingSalts blanks the MD5 salt of every semantic type in the setting.
// The salt keeps MD5-masked values from being enumerated offline, so an MCP
// session never receives it. The console still does: its semantic-type editor
// writes the whole setting back, and the read stays as it is until updates carry
// the stored salt forward (BOT-78).
func stripMaskingSalts(setting *v1pb.Setting) {
for _, semanticType := range setting.GetValue().GetSemanticType().GetTypes() {
if md5 := semanticType.GetAlgorithm().GetMd5Mask(); md5 != nil {
md5.Salt = ""
}
}
}
// SetSetting set the setting by name.
func (s *SettingService) UpdateSetting(ctx context.Context, request *connect.Request[v1pb.UpdateSettingRequest]) (*connect.Response[v1pb.Setting], error) {
user, ok := GetUserFromContext(ctx)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("user not found"))
}
settingName, err := common.GetSettingName(request.Msg.Setting.Name)
if err != nil {
return nil, err
}
if settingName == "" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("setting name is empty"))
}
storeSettingName, err := convertStringToSettingName(settingName)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid setting name: %v", err))
}
if s.isSettingDisallowed(storeSettingName) {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("setting is not available"))
}
if s.profile.IsFeatureUnavailable(settingName) {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("feature %s is unavailable in current mode", settingName))
}
var perm permission.Permission
switch storeSettingName {
case storepb.SettingName_ENVIRONMENT:
perm = permission.EnvironmentSettingsSet
case storepb.SettingName_WORKSPACE_PROFILE:
perm = permission.WorkspaceProfileSettingsSet
default:
perm = permission.SettingsSet
}
if err := s.checkSettingPermission(ctx, request, perm); err != nil {
return nil, err
}
workspaceID := common.GetWorkspaceIDFromContext(ctx)
existedSetting, err := s.store.GetSetting(ctx, workspaceID, storeSettingName)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find setting %s with error: %v", settingName, err))
}
if existedSetting == nil && !request.Msg.AllowMissing {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("setting %s not found", settingName))
}
// audit log.
if setServiceData, ok := getSetServiceDataFromContext(ctx); ok && existedSetting != nil {
v1pbSetting, err := convertToSettingMessage(existedSetting)
if err != nil {
slog.Warn("audit: failed to convert to v1.Setting", log.BBError(err))
}
p, err := anypb.New(v1pbSetting)
if err != nil {
slog.Warn("audit: failed to convert to anypb.Any", log.BBError(err))
}
setServiceData(p)
}
var storeSettingValue proto.Message
var resetClassification bool
switch storeSettingName {
case storepb.SettingName_MCP:
if request.Msg.UpdateMask == nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("update mask is required"))
}
payload := request.Msg.Setting.Value.GetMcp()
if payload == nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("mcp setting is required"))
}
// Built from the request alone because capability is the only field. A
// second field needs a merge onto the stored row, or saving one erases
// the other.
mcpSetting := &storepb.MCPSetting{}
for _, path := range request.Msg.UpdateMask.Paths {
switch path {
case "value.mcp.capability":
mcpSetting.Capability = convertToStoreMCPCapability(payload.Capability)
default:
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid update mask path %q", path))
}
}
if err := validateMCPCapability(mcpSetting.GetCapability()); err != nil {
return nil, err
}
storeSettingValue = mcpSetting
case storepb.SettingName_WORKSPACE_PROFILE:
return s.updateWorkspaceProfileSetting(ctx, request, workspaceID)
case storepb.SettingName_WORKSPACE_APPROVAL:
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_APPROVAL_WORKFLOW); err != nil {
return nil, connect.NewError(connect.CodePermissionDenied, err)
}
payload := &storepb.WorkspaceApprovalSetting{}
for _, rule := range request.Msg.Setting.Value.GetWorkspaceApproval().Rules {
if rule.Source == v1pb.WorkspaceApprovalSetting_Rule_Source(3) {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("EXPORT_DATA approval source is removed from the API"))
}
// Validate the condition.
if _, err := common.ConvertUnparsedApproval(rule.Condition); err != nil {
return nil, err
}
conditionExpr := ""
if rule.Condition != nil {
conditionExpr = rule.Condition.Expression
}
if err := common.ValidateApprovalExprForSource(conditionExpr, storepb.WorkspaceApprovalSetting_Rule_Source(rule.Source)); err != nil {
return nil, err
}
if err := validateApprovalTemplate(rule.Template); err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid approval template: %v, err: %v", rule.Template, err))
}
flow := convertApprovalFlow(rule.Template.Flow)
payload.Rules = append(payload.Rules, &storepb.WorkspaceApprovalSetting_Rule{
Condition: rule.Condition,
Source: storepb.WorkspaceApprovalSetting_Rule_Source(rule.Source),
Template: &storepb.ApprovalTemplate{
Flow: flow,
Title: rule.Template.Title,
Description: rule.Template.Description,
},
})
}
storeSettingValue = payload
case storepb.SettingName_APP_IM:
return s.updateAppIMSetting(ctx, request, workspaceID, user)
case storepb.SettingName_DATA_CLASSIFICATION:
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_DATA_CLASSIFICATION); err != nil {
return nil, connect.NewError(connect.CodePermissionDenied, err)
}
payload := convertDataClassificationSetting(request.Msg.Setting.Value.GetDataClassification())
// it's a temporary solution to limit only 1 classification config before we support manage it in the UX.
if len(payload.Configs) > 1 {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("only support define 1 classification config for now"))
}
if len(payload.Configs) == 1 {
config := payload.Configs[0]
if len(config.Classification) == 0 {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("missing classification map"))
}
if len(config.Levels) == 0 {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("levels must not be empty"))
}
// Validate that level numbers are unique and consecutive starting from 1.
seen := make(map[int32]bool, len(config.Levels))
for _, level := range config.Levels {
if seen[level.Level] {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("duplicate level number: %d", level.Level))
}
seen[level.Level] = true
}
for i := 1; i <= len(config.Levels); i++ {
if !seen[int32(i)] {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("levels must be consecutive integers starting from 1, missing level %d", i))
}
}
// Validate that classification level references are valid.
for id, c := range config.Classification {
if c.Level != nil && (*c.Level < 1 || *c.Level > int32(len(config.Levels))) {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("classification %q references invalid level %d", id, *c.Level))
}
}
}
resetClassification = true
storeSettingValue = payload
case storepb.SettingName_SEMANTIC_TYPES:
storeSemanticTypeSetting := convertSemanticTypeSetting(request.Msg.Setting.Value.GetSemanticType())
idMap := make(map[string]bool)
for _, tp := range storeSemanticTypeSetting.Types {
if tp.Title == "" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("category title cannot be empty: %s", tp.Id))
}
if idMap[tp.Id] {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("duplicate semantic type id: %s", tp.Id))
}
m, ok := tp.GetAlgorithm().GetMask().(*storepb.Algorithm_InnerOuterMask_)
if ok && m.InnerOuterMask != nil {
if m.InnerOuterMask.Type == storepb.Algorithm_InnerOuterMask_MASK_TYPE_UNSPECIFIED {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("inner outer mask type has to be specified"))
}
}
idMap[tp.Id] = true
}
storeSettingValue = storeSemanticTypeSetting
case storepb.SettingName_AI:
return s.updateAISetting(ctx, request, workspaceID)
case storepb.SettingName_EXPORT:
return s.updateExportSetting(ctx, request, workspaceID)
case storepb.SettingName_ENVIRONMENT:
if serr := s.validateEnvironments(ctx, workspaceID, request.Msg.Setting.Value.GetEnvironment().GetEnvironments()); serr != nil {
return nil, serr
}
environmentSetting := convertEnvironmentSetting(request.Msg.Setting.Value.GetEnvironment())
oldEnvironmentSetting, err := s.store.GetEnvironment(ctx, workspaceID)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get old environment setting with error: %v", err))
}
newEnvIDMap := map[string]bool{}
for _, env := range environmentSetting.Environments {
newEnvIDMap[env.Id] = true
}
for _, env := range oldEnvironmentSetting.Environments {
if !newEnvIDMap[env.Id] {
// deleted
emptyStr := ""
if _, err := s.store.UpdateInstance(ctx, &store.UpdateInstanceMessage{
EnvironmentID: &emptyStr,
FindByEnvironmentID: &env.Id,
Workspace: common.GetWorkspaceIDFromContext(ctx),
}); err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to unset environment %v for instances", env.Id))
}
if err := s.store.BatchUpdateDatabases(ctx, nil, &store.BatchUpdateDatabases{
Workspace: common.GetWorkspaceIDFromContext(ctx),
EnvironmentID: &emptyStr,
FindByEnvironmentID: &env.Id,
}); err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to unset environment %v for databases", env.Id))
}
}
}
storeSettingValue = environmentSetting
case storepb.SettingName_EMAIL:
if s.profile.SaaS {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("email setting cannot be changed in SaaS mode"))
}
if request.Msg.UpdateMask == nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("update mask is required"))
}
payload := convertEmailSetting(request.Msg.Setting.Value.GetEmail())
if payload == nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("email setting is required"))
}
oldEmailSetting := &storepb.EmailSetting{}
if existing, err := s.store.GetSetting(ctx, workspaceID, storepb.SettingName_EMAIL); err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get email setting: %v", err))
} else if existing != nil {
oldEmailSetting = proto.CloneOf(existing.Value.(*storepb.EmailSetting))
}
for _, path := range request.Msg.UpdateMask.Paths {
switch path {
case "value.email.from":
oldEmailSetting.From = payload.From
case "value.email.from_name":
oldEmailSetting.FromName = payload.FromName
case "value.email.type":
oldEmailSetting.Type = payload.Type
case "value.email.smtp":
newSMTP := payload.GetSmtp()
if newSMTP == nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("smtp config is required when updating smtp"))
}
// Preserve existing password if new password is empty.
if newSMTP.Password == "" {
if oldSMTP := oldEmailSetting.GetSmtp(); oldSMTP != nil {
newSMTP.Password = oldSMTP.Password
}
}
oldEmailSetting.Config = &storepb.EmailSetting_Smtp{Smtp: newSMTP}
default:
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid update mask path %v", path))
}
}
// Validate the final state.
if err := validateEmailSetting(oldEmailSetting); err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
storeSettingValue = oldEmailSetting
default:
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unsupported setting %v", storeSettingName))
}
if request.Msg.ValidateOnly {
return connect.NewResponse(&v1pb.Setting{
Name: request.Msg.Setting.Name,
Value: request.Msg.Setting.Value,
}), nil
}
setting, err := s.store.UpsertSetting(ctx, &store.SettingMessage{
Name: storeSettingName,
Workspace: workspaceID,
Value: storeSettingValue,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to set setting: %v", err))
}
// It's a temporary solution to map the classification to all projects before we support it in the UX.
if resetClassification {
classification, err := s.store.GetDataClassificationSetting(ctx, workspaceID)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get classification setting message: %v", err))
}
var classificationID string
if len(classification.Configs) > 0 {
classificationID = classification.Configs[0].Id
}
projects, err := s.store.ListProjects(ctx, &store.FindProjectMessage{Workspace: workspaceID, ShowDeleted: false})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to list projects with error: %v", err))
}
batchUpdate := []*store.UpdateProjectMessage{}
for _, project := range projects {
setting := proto.CloneOf(project.Setting)
setting.DataClassificationConfigId = classificationID
batchUpdate = append(batchUpdate, &store.UpdateProjectMessage{
ResourceID: project.ResourceID,
Workspace: project.Workspace,
Setting: setting,
})
}
if err = s.store.UpdateProjects(ctx, batchUpdate...); err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to patch project classification with error: %v", err))
}
}
settingMessage, err := convertToSettingMessage(setting)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert setting message: %v", err))
}
return connect.NewResponse(settingMessage), nil
}
// updateAISetting merges the update mask onto the locked AI setting row, so a
// save cannot restore a field outside its mask from a stale read, such as
// turning AI or the AI SQL review back on after another admin turned it off.
// Workspace creation does not seed this row, so a missing row starts empty.
func (s *SettingService) updateAISetting(ctx context.Context, request *connect.Request[v1pb.UpdateSettingRequest], workspaceID string) (*connect.Response[v1pb.Setting], error) {
if request.Msg.UpdateMask == nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("update mask is required"))
}
payload := convertAISetting(request.Msg.Setting.Value.GetAi())
paths := request.Msg.UpdateMask.Paths
if s.profile.SaaS && !canUpdateAISettingInSaaS(paths) {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("only the AI SQL review can be changed in SaaS mode"))
}
if request.Msg.ValidateOnly {
stored, err := s.store.GetAISettingUncached(ctx, workspaceID)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find AI setting: %v", err))
}
if _, err := mergeAISetting(stored, payload, paths); err != nil {
return nil, err
}
return connect.NewResponse(&v1pb.Setting{
Name: request.Msg.Setting.Name,
Value: request.Msg.Setting.Value,
}), nil
}
var lockedBefore *storepb.AISetting
setting, err := s.store.UpsertSettingAtomic(ctx, workspaceID, storepb.SettingName_AI, func(current proto.Message, existed bool) (proto.Message, error) {
stored, ok := current.(*storepb.AISetting)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("invalid setting value type for %s", storepb.SettingName_AI))
}
// A setting that did not exist has no before-image.
if existed {
lockedBefore = stored
}
return mergeAISetting(stored, payload, paths)
}, nil)
// Re-capture the audit before-image from the locked row the merge ran
// against, overwriting UpdateSetting's earlier pre-lock snapshot. A save
// that fails validation is audited too, so this runs before the error check.
if setServiceData, ok := getSetServiceDataFromContext(ctx); ok && lockedBefore != nil {
v1pbSetting, err := convertToSettingMessage(&store.SettingMessage{
Name: storepb.SettingName_AI,
Workspace: workspaceID,
Value: lockedBefore,
})
if err != nil {
slog.Warn("audit: failed to convert to v1.Setting", log.BBError(err))
}
p, err := anypb.New(v1pbSetting)
if err != nil {
slog.Warn("audit: failed to convert to anypb.Any", log.BBError(err))
}
setServiceData(p)
}
if err != nil {
var connectErr *connect.Error
if errors.As(err, &connectErr) {
return nil, err
}
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to set setting: %v", err))
}
settingMessage, err := convertToSettingMessage(setting)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert setting message: %v", err))
}
return connect.NewResponse(settingMessage), nil
}
func canUpdateAISettingInSaaS(paths []string) bool {
return len(paths) == 1 && paths[0] == "value.ai.sql_review_enabled"
}
// mergeAISetting applies the update mask to a copy of stored and validates
// the result.
func mergeAISetting(stored, payload *storepb.AISetting, paths []string) (*storepb.AISetting, error) {
merged := proto.CloneOf(stored)
for _, path := range paths {
switch path {
case "value.ai.enabled":
merged.Enabled = payload.GetEnabled()
case "value.ai.provider":
merged.Provider = payload.GetProvider()
case "value.ai.endpoint":
merged.Endpoint = payload.GetEndpoint()
case "value.ai.api_key":
merged.ApiKey = payload.GetApiKey()
case "value.ai.model":
merged.Model = payload.GetModel()
case "value.ai.sql_review_enabled":
merged.SqlReviewEnabled = payload.GetSqlReviewEnabled()
default:
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid update mask path %v", path))
}
}
if merged.Enabled {
if merged.Endpoint == "" || merged.Model == "" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("API endpoint and model are required"))
}
if merged.ApiKey == "" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("API key is required"))
}
}
return merged, nil
}
// updateExportSetting merges the update mask onto the locked EXPORT setting
// row, as updateAISetting does. Workspace creation does not seed this row, so a
// missing row starts empty.
func (s *SettingService) updateExportSetting(ctx context.Context, request *connect.Request[v1pb.UpdateSettingRequest], workspaceID string) (*connect.Response[v1pb.Setting], error) {
if s.profile.SaaS {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("SharePoint export is not available in Bytebase Cloud"))
}
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_SHAREPOINT_EXPORT); err != nil {
return nil, connect.NewError(connect.CodePermissionDenied, err)
}
if request.Msg.UpdateMask == nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("update mask is required"))
}
payload := convertExportSetting(request.Msg.Setting.Value.GetExport())
paths := request.Msg.UpdateMask.Paths
if request.Msg.ValidateOnly {
stored := &storepb.ExportSetting{}
existing, err := s.store.GetSettingUncached(ctx, workspaceID, storepb.SettingName_EXPORT)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find export setting: %v", err))
}
if existing != nil {
value, ok := existing.Value.(*storepb.ExportSetting)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("invalid setting value type for %s", storepb.SettingName_EXPORT))
}
stored = value
}
merged, err := mergeExportSetting(stored, payload, paths)
if err != nil {
return nil, err
}
settingMessage, err := convertToSettingMessage(&store.SettingMessage{
Name: storepb.SettingName_EXPORT,
Workspace: workspaceID,
Value: merged,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert setting message: %v", err))
}
return connect.NewResponse(settingMessage), nil
}
var lockedBefore *storepb.ExportSetting
setting, err := s.store.UpsertSettingAtomic(ctx, workspaceID, storepb.SettingName_EXPORT, func(current proto.Message, existed bool) (proto.Message, error) {
stored, ok := current.(*storepb.ExportSetting)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("invalid setting value type for %s", storepb.SettingName_EXPORT))
}
if existed {
lockedBefore = stored
}
return mergeExportSetting(stored, payload, paths)
}, nil)
// The audit before-image is the locked row the merge ran against; a save
// that fails validation is audited too.
if setServiceData, ok := getSetServiceDataFromContext(ctx); ok && lockedBefore != nil {
v1pbSetting, err := convertToSettingMessage(&store.SettingMessage{
Name: storepb.SettingName_EXPORT,
Workspace: workspaceID,
Value: lockedBefore,
})
if err != nil {
slog.Warn("audit: failed to convert to v1.Setting", log.BBError(err))
}
p, err := anypb.New(v1pbSetting)
if err != nil {
slog.Warn("audit: failed to convert to anypb.Any", log.BBError(err))
}
setServiceData(p)
}
if err != nil {
var connectErr *connect.Error
if errors.As(err, &connectErr) {
return nil, err
}
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to set setting: %v", err))
}
settingMessage, err := convertToSettingMessage(setting)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert setting message: %v", err))
}
return connect.NewResponse(settingMessage), nil
}
// mergeExportSetting applies the update mask to a copy of stored and validates
// the result. An empty client secret keeps the stored one, because the secret
// is never returned for a client to send back. Clearing both SharePoint IDs
// removes the application, secret included.
func mergeExportSetting(stored, payload *storepb.ExportSetting, paths []string) (*storepb.ExportSetting, error) {
merged := proto.CloneOf(stored)
sharePoint := proto.CloneOf(stored.GetSharepoint())
if sharePoint == nil {
sharePoint = &storepb.SharePointSetting{}
}
for _, path := range paths {
switch path {
case "value.export.sharepoint.tenant_id":
sharePoint.TenantId = strings.TrimSpace(payload.GetSharepoint().GetTenantId())
case "value.export.sharepoint.client_id":
sharePoint.ClientId = strings.TrimSpace(payload.GetSharepoint().GetClientId())
case "value.export.sharepoint.client_secret":
if secret := payload.GetSharepoint().GetClientSecret(); secret != "" {
sharePoint.ClientSecret = secret
}
default:
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid update mask path %v", path))
}
}
if sharePoint.TenantId == "" && sharePoint.ClientId == "" {
merged.Sharepoint = nil
return merged, nil
}
if sharePoint.TenantId == "" || sharePoint.ClientId == "" || sharePoint.ClientSecret == "" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("tenant ID, client ID, and client secret are all required"))
}
merged.Sharepoint = sharePoint
return merged, nil
}
// appIMSettingMaskPath maps each accepted APP_IM mask path to the provider it
// addresses. The paths do not name real proto fields — AppIMSetting holds one
// repeated `settings`, and AIP-161 does not let a mask address a repeated
// element — so they are matched as a fixed vocabulary rather than traversed.
var appIMSettingMaskPath = map[string]storepb.WebhookType{
"value.app_im.slack": storepb.WebhookType_SLACK,
"value.app_im.feishu": storepb.WebhookType_FEISHU,
"value.app_im.wecom": storepb.WebhookType_WECOM,
"value.app_im.lark": storepb.WebhookType_LARK,
"value.app_im.dingtalk": storepb.WebhookType_DINGTALK,
"value.app_im_setting_value.teams": storepb.WebhookType_TEAMS,
}
// updateAppIMSetting handles the APP_IM branch of UpdateSetting through the
// store's row-locking read-modify-write primitive: the merge runs inside the
// transaction against the value of the locked row, so two admins configuring
// different providers at once cannot each merge onto the same stale snapshot
// and have the later write restore the other's provider from it. The row is
// seeded at workspace creation, so the primitive always finds it.
func (s *SettingService) updateAppIMSetting(ctx context.Context, request *connect.Request[v1pb.UpdateSettingRequest], workspaceID string, user *store.UserMessage) (*connect.Response[v1pb.Setting], error) {
if request.Msg.UpdateMask == nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("update mask is required"))
}
payload, err := convertAppIMSetting(request.Msg.Setting.Value.GetAppIm())
if err != nil {
return nil, err
}
if err := preflightAppIMPaths(ctx, payload, request.Msg.UpdateMask.Paths, user); err != nil {
return nil, err
}
var lockedBefore *storepb.AppIMSetting
apply := func(current proto.Message) (proto.Message, error) {
stored, ok := current.(*storepb.AppIMSetting)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("invalid setting value type for %s", storepb.SettingName_APP_IM))
}
// The audit before-image is the row this merge actually ran against,
// not the possibly stale pre-lock snapshot captured by UpdateSetting.
lockedBefore = proto.CloneOf(stored)
return mergeAppIMSetting(stored, payload, request.Msg.UpdateMask.Paths)
}
if request.Msg.ValidateOnly {
fresh, err := s.store.GetSettingUncached(ctx, workspaceID, storepb.SettingName_APP_IM)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find setting %s with error: %v", storepb.SettingName_APP_IM, err))
}
if fresh == nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("cannot find setting %v", storepb.SettingName_APP_IM))
}
merged, err := apply(fresh.Value)
if err != nil {
return nil, err
}
// Return the merged value, not the request: the request carries only
// the masked providers, so echoing it would show every provider this
// update preserves as gone.
return newAppIMSettingResponse(workspaceID, merged)
}
setting, err := s.store.UpdateSettingAtomic(ctx, workspaceID, storepb.SettingName_APP_IM, apply, nil)
if err != nil {
var connectErr *connect.Error
if errors.As(err, &connectErr) {
return nil, err
}
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to set setting: %v", err))
}
// Re-capture the audit before-image from the locked row the merge ran
// against, overwriting UpdateSetting's earlier pre-lock snapshot.
if setServiceData, ok := getSetServiceDataFromContext(ctx); ok && lockedBefore != nil {
v1pbSetting, err := convertToSettingMessage(&store.SettingMessage{
Name: storepb.SettingName_APP_IM,
Workspace: workspaceID,
Value: lockedBefore,
})
if err != nil {
slog.Warn("audit: failed to convert to v1.Setting", log.BBError(err))
}
p, err := anypb.New(v1pbSetting)
if err != nil {
slog.Warn("audit: failed to convert to anypb.Any", log.BBError(err))
}
setServiceData(p)
}
settingMessage, err := convertToSettingMessage(setting)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert setting message: %v", err))
}
return connect.NewResponse(settingMessage), nil
}
func newAppIMSettingResponse(workspaceID string, value proto.Message) (*connect.Response[v1pb.Setting], error) {
settingMessage, err := convertToSettingMessage(&store.SettingMessage{
Name: storepb.SettingName_APP_IM,
Workspace: workspaceID,
Value: value,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert setting message: %v", err))
}
return connect.NewResponse(settingMessage), nil
}
// preflightAppIMPaths validates the credentials of every provider the mask
// names and the payload carries. It runs BEFORE the row-locking transaction:
// each check is a round trip to the provider's own API, and holding the
// setting row lock across one would let a slow vendor block every other write
// to this row. None of it depends on the locked row.
func preflightAppIMPaths(ctx context.Context, payload *storepb.AppIMSetting, paths []string, user *store.UserMessage) error {
for _, path := range paths {
imType, ok := appIMSettingMaskPath[path]
if !ok {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid update mask path %v", path))
}
incoming := findIMSetting(payload.GetSettings(), imType)
if incoming == nil || incoming.GetPayload() == nil {
// A masked provider the payload omits is a removal.
continue
}
if err := validateIMSetting(ctx, incoming, user); err != nil {
return err
}
}
return nil
}
// mergeAppIMSetting splices only the masked providers of payload into stored.
// Assigning the request wholesale used to drop every provider it left out, so
// saving Slack wiped the stored Feishu, WeCom, Lark, DingTalk and Teams
// secrets. A masked provider the payload omits is removed, which is how one is
// deleted. stored is not modified.
func mergeAppIMSetting(stored, payload *storepb.AppIMSetting, paths []string) (*storepb.AppIMSetting, error) {
merged := proto.CloneOf(stored)
for _, path := range paths {
imType, ok := appIMSettingMaskPath[path]
if !ok {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid update mask path %v", path))
}
incoming := findIMSetting(payload.GetSettings(), imType)
if incoming == nil || incoming.GetPayload() == nil {
merged.Settings = slices.DeleteFunc(merged.Settings, func(s *storepb.AppIMSetting_IMSetting) bool {
return s.GetType() == imType
})
continue
}
if existing := findIMSetting(merged.GetSettings(), imType); existing != nil {
proto.Reset(existing)
proto.Merge(existing, incoming)
} else {
merged.Settings = append(merged.Settings, incoming)
}
}
return merged, nil
}
func findIMSetting(settings []*storepb.AppIMSetting_IMSetting, imType storepb.WebhookType) *storepb.AppIMSetting_IMSetting {
for _, setting := range settings {
if setting.GetType() == imType {
return setting
}
}
return nil
}
// validateIMSetting checks the provider's credentials against its own API.
func validateIMSetting(ctx context.Context, setting *storepb.AppIMSetting_IMSetting, user *store.UserMessage) error {
var err error
switch setting.GetType() {
case storepb.WebhookType_SLACK:
err = slack.ValidateToken(ctx, setting.GetSlack().GetToken())
case storepb.WebhookType_FEISHU:
err = feishu.Validate(ctx, setting.GetFeishu().GetAppId(), setting.GetFeishu().GetAppSecret(), user.Email)
case storepb.WebhookType_WECOM:
err = wecom.Validate(ctx, setting.GetWecom().GetCorpId(), setting.GetWecom().GetAgentId(), setting.GetWecom().GetSecret())
case storepb.WebhookType_LARK:
err = lark.Validate(ctx, setting.GetLark().GetAppId(), setting.GetLark().GetAppSecret(), user.Email)
case storepb.WebhookType_DINGTALK:
err = dingtalk.Validate(ctx, setting.GetDingtalk().GetClientId(), setting.GetDingtalk().GetClientSecret(), setting.GetDingtalk().GetRobotCode(), user.Phone)
case storepb.WebhookType_TEAMS:
err = teams.Validate(ctx, setting.GetTeams().GetTenantId(), setting.GetTeams().GetClientId(), setting.GetTeams().GetClientSecret(), user.Email)
default:
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unsupported IM type %v", setting.GetType()))
}
if err != nil {
return connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "validation failed"))
}
return nil
}
// updateWorkspaceProfileSetting handles the WORKSPACE_PROFILE branch of
// UpdateSetting through the store's row-locking read-modify-write primitive:
// the update-mask merge and its validations run inside the transaction against
// the value of the locked row, so validation sees the true final state and a
// concurrent write (another admin, emergency SQL) can never be silently
// reverted by a merge based on a stale read. Validate-only requests run the
// same merge and validations against an uncached snapshot and write nothing.
func (s *SettingService) updateWorkspaceProfileSetting(ctx context.Context, request *connect.Request[v1pb.UpdateSettingRequest], workspaceID string) (*connect.Response[v1pb.Setting], error) {
if request.Msg.UpdateMask == nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("update mask is required"))
}
payload := convertWorkspaceProfileSetting(request.Msg.Setting.Value.GetWorkspaceProfile())
// License, store, and profile checks run before the row-locking
// transaction so apply stays free of database reads.
if err := s.preflightWorkspaceProfilePaths(ctx, workspaceID, request, payload); err != nil {
return nil, err
}
var lockedBefore *storepb.WorkspaceProfileSetting
apply := func(current proto.Message) (proto.Message, error) {
oldSetting, ok := current.(*storepb.WorkspaceProfileSetting)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("invalid setting value type for %s", storepb.SettingName_WORKSPACE_PROFILE))
}
// The audit before-image is the row this merge actually ran against,
// not the possibly stale pre-lock snapshot captured by UpdateSetting.
lockedBefore = proto.CloneOf(oldSetting)
if err := mergeWorkspaceProfilePaths(request, payload, oldSetting); err != nil {
return nil, err
}
if len(oldSetting.Domains) == 0 && oldSetting.EnforceIdentityDomain {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("identity domain can be enforced only when workspace domains are set"))
}
return oldSetting, nil
}
if request.Msg.ValidateOnly {
freshSetting, err := s.store.GetSettingUncached(ctx, workspaceID, storepb.SettingName_WORKSPACE_PROFILE)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find setting %s with error: %v", storepb.SettingName_WORKSPACE_PROFILE, err))
}
if freshSetting == nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("cannot find setting %v", storepb.SettingName_WORKSPACE_PROFILE))
}
profileValue, ok := freshSetting.Value.(*storepb.WorkspaceProfileSetting)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("invalid setting value type for %s", storepb.SettingName_WORKSPACE_PROFILE))
}
// GetSettingUncached returns a fresh object today (uncached reads no
// longer populate the cache), but validate against a clone anyway so
// a validate-only request can never mutate shared state should the
// read path change.
if _, err := apply(proto.CloneOf(profileValue)); err != nil {
return nil, err
}
return connect.NewResponse(&v1pb.Setting{
Name: request.Msg.Setting.Name,
Value: request.Msg.Setting.Value,
}), nil
}
// Runtime derivatives (audit stdout flag, debug log level, pprof gate)
// reconcile from the freshly re-read committed state on EVERY successful
// profile publication — not only when this request touched those fields —
// so a publication skipped by an earlier failure is repaired by the next
// profile write, mirroring startup derivation (server.go). Skipped in
// SaaS, where workspace-scoped stored values must not drive process-global
// state on a shared replica (the corresponding mask paths are also
// rejected in preflight).
//
// The audit-log entitlement is computed here, outside the publish mutex:
// runtime audit stdout requires the stored flag AND a valid license, same
// as startup — and postCommit must not call IsFeatureEnabled itself,
// because it runs under settingPublishMu and a setting cache miss there
// would re-acquire that mutex.
auditLogFeatureEnabled := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_AUDIT_LOG) == nil
postCommit := func(current *store.SettingMessage) {
if s.profile.SaaS {
return
}
profile, ok := current.Value.(*storepb.WorkspaceProfileSetting)
if !ok {
return
}
s.profile.RuntimeEnableAuditLogStdout.Store(profile.EnableAuditLogStdout && auditLogFeatureEnabled)
s.profile.RuntimeDebug.Store(profile.EnableDebug)
level := slog.LevelInfo
if profile.EnableDebug {
level = slog.LevelDebug
}
log.LogLevel.Set(level)
}
setting, err := s.store.UpdateSettingAtomic(ctx, workspaceID, storepb.SettingName_WORKSPACE_PROFILE, apply, postCommit)
if err != nil {
var connectErr *connect.Error
if errors.As(err, &connectErr) {
return nil, err
}
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to set setting: %v", err))
}
// Re-capture the audit before-image from the locked row the merge ran
// against, overwriting UpdateSetting's earlier pre-lock snapshot.
if setServiceData, ok := getSetServiceDataFromContext(ctx); ok && lockedBefore != nil {
v1pbSetting, err := convertToSettingMessage(&store.SettingMessage{
Name: storepb.SettingName_WORKSPACE_PROFILE,
Workspace: workspaceID,
Value: lockedBefore,
})
if err != nil {
slog.Warn("audit: failed to convert to v1.Setting", log.BBError(err))
}
p, err := anypb.New(v1pbSetting)
if err != nil {
slog.Warn("audit: failed to convert to anypb.Any", log.BBError(err))
}
setServiceData(p)
}
settingMessage, err := convertToSettingMessage(setting)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert setting message: %v", err))
}
return connect.NewResponse(settingMessage), nil
}
// preflightWorkspaceProfilePaths runs the update-mask validations that need
// license, store, or profile lookups. It runs BEFORE the row-locking
// transaction: apply must stay free of database reads, because it executes
// while holding the transaction's pooled connection and the row lock, and a
// nested read wanting a second connection is a bounded-pool starvation cycle.
// None of these checks depend on the locked row's state, so hoisting them is
// behavior-preserving. May normalize payload fields (e.g. external_url).
func (s *SettingService) preflightWorkspaceProfilePaths(ctx context.Context, workspaceID string, request *connect.Request[v1pb.UpdateSettingRequest], payload *storepb.WorkspaceProfileSetting) error {
for _, path := range request.Msg.UpdateMask.Paths {
switch path {
case "value.workspace_profile.enable_debug":
// Debug flips the process-global log level and pprof exposure; on
// a shared SaaS replica that would affect other workspaces.
if s.profile.SaaS {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("the enable_debug cannot be changed in SaaS mode"))
}
case "value.workspace_profile.disallow_signup":
if s.profile.SaaS {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("the disallow_signup cannot be changed in SaaS mode"))
}
if payload.DisallowSignup {
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_DISALLOW_SELF_SERVICE_SIGNUP); err != nil {
return connect.NewError(connect.CodePermissionDenied, err)
}
}
case "value.workspace_profile.external_url":
if s.profile.SaaS {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("the external_url cannot be changed in SaaS mode"))
}
// Prevent changing external URL via UI when it's set via command-line flag
if s.profile.ExternalURL != "" {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("external URL is managed via --external-url command-line flag and cannot be changed through the UI"))
}
if payload.ExternalUrl != "" {
externalURL, err := config.NormalizeExternalURL(payload.ExternalUrl)
if err != nil {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid external url: %v", err))
}
payload.ExternalUrl = externalURL
}
case "value.workspace_profile.require_mfa":
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_TWO_FA); err != nil {
return connect.NewError(connect.CodePermissionDenied, err)
}
case "value.workspace_profile.access_token_duration":
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_TOKEN_DURATION_CONTROL); err != nil {
return connect.NewError(connect.CodePermissionDenied, err)
}
if payload.AccessTokenDuration != nil && payload.AccessTokenDuration.Seconds > 0 && payload.AccessTokenDuration.AsDuration() < time.Minute {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("access token duration should be at least one minute"))
}
case "value.workspace_profile.refresh_token_duration":
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_TOKEN_DURATION_CONTROL); err != nil {
return connect.NewError(connect.CodePermissionDenied, err)
}
if payload.RefreshTokenDuration != nil && payload.RefreshTokenDuration.Seconds > 0 && payload.RefreshTokenDuration.AsDuration() < time.Hour {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("refresh token duration should be at least one hour"))
}
case "value.workspace_profile.inactive_session_timeout":
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_TOKEN_DURATION_CONTROL); err != nil {
return connect.NewError(connect.CodePermissionDenied, err)
}
case "value.workspace_profile.announcement":
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_DASHBOARD_ANNOUNCEMENT); err != nil {
return connect.NewError(connect.CodePermissionDenied, err)
}
if payload.Announcement != nil {
if err := validateAnnouncementTheme(payload.Announcement.Theme); err != nil {
return err
}
}
case "value.workspace_profile.enforce_identity_domain":
if payload.EnforceIdentityDomain {
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_USER_EMAIL_DOMAIN_RESTRICTION); err != nil {
return connect.NewError(connect.CodePermissionDenied, err)
}
}
case "value.workspace_profile.allow_email_code_signin":
if s.profile.SaaS {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("allow_email_code_signin cannot be changed in SaaS mode"))
}
if payload.AllowEmailCodeSignin {
emailSetting, err := s.store.GetSetting(ctx, workspaceID, storepb.SettingName_EMAIL)
if err != nil {
return connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to load email setting"))
}
if emailSetting == nil {
return connect.NewError(connect.CodeFailedPrecondition, errors.Errorf("cannot enable email code signin without an EMAIL setting"))
}
}
case "value.workspace_profile.disallow_password_signin":
if s.profile.SaaS {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("the disallow_password_signin cannot be changed in SaaS mode"))
}
if payload.DisallowPasswordSignin {
// We should still allow users to turn it off.
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_DISALLOW_PASSWORD_SIGNIN); err != nil {
return connect.NewError(connect.CodePermissionDenied, err)
}
settingWsID := common.GetWorkspaceIDFromContext(ctx)
identityProviders, err := s.store.ListIdentityProviders(ctx, &store.FindIdentityProviderMessage{Workspace: &settingWsID})
if err != nil {
return connect.NewError(connect.CodeInternal, errors.Errorf("failed to list identity providers: %v", err))
}
if len(identityProviders) == 0 {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("cannot disallow password signin when no identity provider is set"))
}
}
case "value.workspace_profile.enable_audit_log_stdout":
// Audit stdout output is process-global; on a shared SaaS replica
// it would affect other workspaces.
if s.profile.SaaS {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("the enable_audit_log_stdout cannot be changed in SaaS mode"))
}
if payload.EnableAuditLogStdout {
// Require TEAM or ENTERPRISE license
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_AUDIT_LOG); err != nil {
return connect.NewError(connect.CodePermissionDenied, err)
}
}
case "value.workspace_profile.watermark":
if payload.Watermark {
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_WATERMARK); err != nil {
return connect.NewError(connect.CodePermissionDenied, err)
}
}
case "value.workspace_profile.directory_sync_token":
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_DIRECTORY_SYNC); err != nil {
return connect.NewError(connect.CodePermissionDenied, err)
}
case "value.workspace_profile.password_restriction":
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_PASSWORD_RESTRICTIONS); err != nil {
return connect.NewError(connect.CodePermissionDenied, err)
}
if payload.PasswordRestriction != nil && payload.PasswordRestriction.MinLength < 8 {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid password minimum length: must be at least 8"))
}
default:
// Unknown paths are rejected by the merge pass.
}
}
return nil
}
// mergeWorkspaceProfilePaths applies the request's update-mask paths onto
// oldSetting. It is pure apart from directory-sync token generation: it
// performs no database or license reads — those ran in
// preflightWorkspaceProfilePaths — because it executes inside the row-locking
// transaction. Only validations that are payload-local or need the merged
// state live here.
func mergeWorkspaceProfilePaths(request *connect.Request[v1pb.UpdateSettingRequest], payload *storepb.WorkspaceProfileSetting, oldSetting *storepb.WorkspaceProfileSetting) error {
for _, path := range request.Msg.UpdateMask.Paths {
switch path {
case "value.workspace_profile.enable_debug":
oldSetting.EnableDebug = payload.EnableDebug
case "value.workspace_profile.disallow_signup":
oldSetting.DisallowSignup = payload.DisallowSignup
case "value.workspace_profile.external_url":
oldSetting.ExternalUrl = payload.ExternalUrl
case "value.workspace_profile.require_mfa":
oldSetting.Require_2Fa = payload.Require_2Fa
case "value.workspace_profile.access_token_duration":
oldSetting.AccessTokenDuration = payload.AccessTokenDuration
case "value.workspace_profile.refresh_token_duration":
oldSetting.RefreshTokenDuration = payload.RefreshTokenDuration
case "value.workspace_profile.inactive_session_timeout":
oldSetting.InactiveSessionTimeout = payload.InactiveSessionTimeout
case "value.workspace_profile.announcement":
oldSetting.Announcement = payload.Announcement
case "value.workspace_profile.maximum_request_expiration":
if payload.MaximumRequestExpiration != nil {
// If the value is less than or equal to 0, we will remove the setting. AKA no limit.
if payload.MaximumRequestExpiration.Seconds <= 0 {
payload.MaximumRequestExpiration = nil
}
}
oldSetting.MaximumRequestExpiration = payload.MaximumRequestExpiration
case "value.workspace_profile.maximum_role_expiration":
if payload.MaximumRoleExpiration != nil {
// If the value is less than or equal to 0, we will remove the setting. AKA no limit.
if payload.MaximumRoleExpiration.Seconds <= 0 {
payload.MaximumRoleExpiration = nil
}
}
oldSetting.MaximumRoleExpiration = payload.MaximumRoleExpiration
case "value.workspace_profile.domains":
if err := validateDomains(payload.Domains); err != nil {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid domains, error %v", err))
}
oldSetting.Domains = payload.Domains
case "value.workspace_profile.enforce_identity_domain":
oldSetting.EnforceIdentityDomain = payload.EnforceIdentityDomain
case "value.workspace_profile.database_change_mode":
oldSetting.DatabaseChangeMode = payload.DatabaseChangeMode
case "value.workspace_profile.allow_email_code_signin":
oldSetting.AllowEmailCodeSignin = payload.AllowEmailCodeSignin
case "value.workspace_profile.disallow_password_signin":
oldSetting.DisallowPasswordSignin = payload.DisallowPasswordSignin
case "value.workspace_profile.enable_metric_collection":
oldSetting.EnableMetricCollection = payload.EnableMetricCollection
case "value.workspace_profile.enable_audit_log_stdout":
oldSetting.EnableAuditLogStdout = payload.EnableAuditLogStdout
case "value.workspace_profile.watermark":
oldSetting.Watermark = payload.Watermark
case "value.workspace_profile.password_restriction":
oldSetting.PasswordRestriction = payload.PasswordRestriction
case "value.workspace_profile.sql_result_size":
oldSetting.SqlResultSize = payload.SqlResultSize
case "value.workspace_profile.query_timeout":
oldSetting.QueryTimeout = payload.QueryTimeout
case "value.workspace_profile.sql_editor_theme_id":
oldSetting.SqlEditorThemeId = payload.SqlEditorThemeId
case "value.workspace_profile.sql_editor_custom_theme":
if err := validateSQLEditorCustomTheme(payload.SqlEditorCustomTheme); err != nil {
return err
}
oldSetting.SqlEditorCustomTheme = payload.SqlEditorCustomTheme
default:
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid update mask path %v", path))
}
}
return nil
}
// TestEmailSetting sends a test email using the provided config.
func (s *SettingService) TestEmailSetting(ctx context.Context, req *connect.Request[v1pb.TestEmailSettingRequest]) (*connect.Response[v1pb.TestEmailSettingResponse], error) {
emailSetting := convertEmailSetting(req.Msg.EmailSetting)
if emailSetting == nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("email_setting is required"))
}
// Substitute stored password if not provided.
if smtp := emailSetting.GetSmtp(); smtp != nil && smtp.Password == "" {
workspaceID := common.GetWorkspaceIDFromContext(ctx)
if existing, err := s.store.GetSetting(ctx, workspaceID, storepb.SettingName_EMAIL); err == nil && existing != nil {
if oldEmail, ok := existing.Value.(*storepb.EmailSetting); ok {
if oldSMTP := oldEmail.GetSmtp(); oldSMTP != nil {
smtp.Password = oldSMTP.Password
}
}
}
}
sender, err := mailer.NewSender(emailSetting)
if err != nil {
return connect.NewResponse(&v1pb.TestEmailSettingResponse{ //nolint:nilerr
Success: false,
Error: err.Error(),
}), nil
}
err = sender.Send(ctx, &mailer.SendRequest{
To: []string{req.Msg.To},
Subject: "Bytebase email config test",
TextBody: "This is a test email from Bytebase to verify your email configuration.",
})
if err != nil {
return connect.NewResponse(&v1pb.TestEmailSettingResponse{ //nolint:nilerr
Success: false,
Error: err.Error(),
}), nil
}
return connect.NewResponse(&v1pb.TestEmailSettingResponse{
Success: true,
}), nil
}
func (s *SettingService) checkSettingPermission(ctx context.Context, req connect.AnyRequest, perm permission.Permission) error {
user, ok := GetUserFromContext(ctx)
if !ok {
return connect.NewError(connect.CodeInternal, errors.Errorf("user not found"))
}
ok, err := s.iamManager.CheckPermission(ctx, perm, user, common.GetWorkspaceIDFromContext(ctx))
if err != nil {
return connect.NewError(connect.CodeInternal, errors.Errorf("failed to check permission with error: %v", err.Error()))
}
if !ok {
err := permissionDeniedError(ctx, errors.Errorf("user does not have permission %q", perm))
if detail, detailErr := connect.NewErrorDetail(&v1pb.PermissionDeniedDetail{
Method: req.Spec().Procedure,
RequiredPermissions: []string{string(perm)},
}); detailErr == nil {
err.AddDetail(detail)
}
return err
}
return nil
}
var domainRegexp = regexp.MustCompile(`^(?i:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$`)
var disallowedDomains = map[string]bool{
"gmail.com": true,
"googlemail.com": true,
"outlook.com": true,
"hotmail.com": true,
"live.com": true,
"msn.com": true,
"icloud.com": true,
"me.com": true,
"mac.com": true,
"yahoo.com": true,
"ymail.com": true,
"rocketmail.com": true,
"aol.com": true,
"aim.com": true,
"protonmail.com": true,
"pm.me": true,
"zoho.com": true,
"mail.com": true,
"gmx.com": true,
"gmx.net": true,
"163.com": true,
"126.com": true,
"qq.com": true,
"yeah.net": true,
}
func (*SettingService) isSettingDisallowed(name storepb.SettingName) bool {
// Backend-only settings that should never be exposed via the API.
switch name {
case storepb.SettingName_SYSTEM:
// SYSTEM: Internal system settings (auth secret, workspace ID, enterprise license)
return true
default:
return false
}
}
func validateApprovalTemplate(template *v1pb.ApprovalTemplate) error {
if template == nil {
return errors.Errorf("approval template cannot be nil")
}
if template.Flow == nil {
return errors.Errorf("approval template flow cannot be nil")
}
// Empty roles means "no approval required" - issue will be auto-approved
for i, role := range template.Flow.Roles {
if strings.TrimSpace(role) == "" {
return errors.Errorf("approval template role at position %d cannot be empty", i+1)
}
}
return nil
}
func validateDomains(domains []string) error {
for _, domain := range domains {
if !domainRegexp.MatchString(domain) {
return errors.Errorf("invalid domain %q", domain)
}
if disallowedDomains[domain] {
return errors.Errorf("domain %q is not allowed", domain)
}
}
return nil
}
// validateSQLEditorCustomTheme checks the SHAPE of a custom theme, not the
// frontend's token vocabulary. The `--color-*` token keys are a frontend/CSS
// concern owned by SQL_EDITOR_THEME_TOKENS; the server only ensures the stored
// value isn't garbage (non-empty tokens, each an opaque Color). The frontend
// derives the full token set and falls back to a built-in if one is missing, so
// the backend stays theme-catalog-agnostic.
func validateSQLEditorCustomTheme(t *storepb.SQLEditorThemeSetting) error {
if t == nil {
return nil // built-in reference or unset
}
if t.Id == "" {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("sql_editor_custom_theme.id is required"))
}
if t.Name == "" {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("sql_editor_custom_theme.name is required"))
}
// monaco_base is a registered VSCode color-theme id (e.g. "vs", "vs-dark",
// "Dark Modern"). The valid set is owned by the frontend theme service, so the
// server only requires it be non-empty rather than hardcoding the vocabulary.
if t.MonacoBase == "" {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("sql_editor_custom_theme.monaco_base is required"))
}
if len(t.Tokens) == 0 {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("sql_editor_custom_theme.tokens is required"))
}
for k, v := range t.Tokens {
if !isOpaqueColor(v) {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("sql_editor_custom_theme token %s invalid", k))
}
}
return nil
}
func validateAnnouncementTheme(t *storepb.WorkspaceProfileSetting_Announcement_AnnouncementTheme) error {
if t == nil {
return nil
}
if !isOpaqueColor(t.Background) {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("announcement theme background invalid"))
}
if !isOpaqueColor(t.Text) {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("announcement theme text invalid"))
}
return nil
}
// validateMCPCapability rejects UNSPECIFIED and unknown enum numbers.
func validateMCPCapability(capability storepb.MCPSetting_Capability) error {
if capability == storepb.MCPSetting_CAPABILITY_UNSPECIFIED {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("capability must be specified"))
}
if _, ok := storepb.MCPSetting_Capability_name[int32(capability)]; !ok {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unknown capability value %d", capability))
}
return nil
}
func (s *SettingService) validateEnvironments(ctx context.Context, workspaceID string, envs []*v1pb.EnvironmentSetting_Environment) error {
used := map[string]bool{}
for _, env := range envs {
if env.Title == "" {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("environment title cannot be empty"))
}
if !isValidResourceID(env.Id) {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid environment ID %v", env.Id))
}
if used[env.Id] {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("duplicate environment ID %v", env.Id))
}
if env.Color != nil && !isOpaqueColor(env.Color) {
return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("environment color invalid"))
}
if v, ok := env.Tags["protected"]; ok && v == "protected" {
if err := s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_ENVIRONMENT_TIERS); err != nil {
return connect.NewError(connect.CodePermissionDenied, err)
}
}
used[env.Id] = true
}
return nil
}
func validateEmailSetting(setting *storepb.EmailSetting) error {
if setting.From == "" {
return errors.Errorf("from address is required")
}
switch setting.Type {
case storepb.EmailSetting_SMTP:
smtp := setting.GetSmtp()
if smtp == nil {
return errors.Errorf("smtp config is required when type is SMTP")
}
if smtp.Host == "" {
return errors.Errorf("smtp host is required")
}
if smtp.Port <= 0 {
return errors.Errorf("smtp port must be positive")
}
default:
return errors.Errorf("unsupported email type: %v", setting.Type)
}
return nil
}