Skip to content

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

62.3 KB
Raw Blame
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
}