fix(settings): persist Set/SetMulti to the correct DB row

settings.Set/SetMulti silently failed to write to the database for all
callers, and even once writing they targeted the wrong row.

Three compounding bugs:

1. PRIMARY: Setting.SettingsID had `gorm:"primaryKey"` with no column tag,
   so GORM derived column `settings_id` while the table PK is `id`. Every
   INSERT/UPDATE referenced a missing column and errored; the error was
   swallowed by `_ = saveSingleSetting(...)`. Reads survived because Find
   uses SELECT *. Fixed to `gorm:"column:id;primaryKey"`.

2. Setting.Protected mapped to a non-existent `protected` column, breaking
   full-struct Save. Changed to `gorm:"-"` (kept for JSON only).

3. Read/write key asymmetry: LoadDatabaseSettings reconstructs keys as
   <domainPath>.<name> from the domain hierarchy, but the writer flattened
   the whole dotted key into one name under a hardcoded `default` domain.
   Rewrote the writer: Set/SetMulti pass the original dotted key;
   splitSettingKey splits on the last dot; resolveDomainID resolves/creates
   the domain hierarchy using Attrs() for create-only columns so an existing
   migration-seeded domain is matched instead of spawning a duplicate.

Flat (non-dotted) keys still resolve to the `default` domain, so SaveToDB
and flat-key callers are unchanged. Verified end-to-end against the dev DB.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: iesreza

lib/settings/database.go

@@ -3,6 +3,7 @@ package settings
 import (
 	"fmt"
 	"github.com/getevo/evo/v2/lib/db"
+	"strings"
 	"time"
 )
 
@@ -23,7 +24,12 @@ func (SettingDomain) TableName() string {
 }
 
 type Setting struct {
-	SettingsID     uint          `gorm:"primaryKey" json:"-"`
+	// The primary key column is `id`. Without the explicit column tag GORM
+	// derives `settings_id`, which does not exist in the table — every
+	// INSERT/UPDATE then references a missing column and fails (reads via
+	// SELECT * still work, which is why this stayed hidden). Keep this in sync
+	// with the canonical model in apps/settings/models.go.
+	SettingsID     uint          `gorm:"column:id;primaryKey" json:"-"`
 	DomainID       uint          `gorm:"column:domain_id;fk:settings_domain" json:"domain"`
 	Domain         string        `gorm:"-" json:"-"`
 	Name           string        `gorm:"column:name;size:128" json:"name"`
@@ -33,7 +39,9 @@ type Setting struct {
 	DefaultValue   string        `gorm:"column:default_value" json:"default_value"`
 	ReadOnly       bool          `gorm:"column:read_only" json:"read_only"`
 	Visible        bool          `gorm:"column:visible" json:"visible"`
-	Protected      bool          `gorm:"column:protected" json:"protected"`
+	// No `protected` column exists in the table; mapping it to a column made
+	// full-struct writes fail. Kept as a non-persisted field for API/JSON.
+	Protected      bool          `gorm:"-" json:"protected"`
 	Type           string        `gorm:"column:type" json:"type"`
 	Params         string        `gorm:"column:params" json:"params"`
 	SettingsDomain SettingDomain `gorm:"-" json:"-"`
@@ -97,31 +105,99 @@ func LoadDatabaseSettings() error {
 	return nil
 }
 
-// saveSingleSetting saves a single setting to the database.
-// Creates or updates the setting in the default domain.
+// splitSettingKey splits a hierarchical setting key into its domain path and
+// leaf name on the LAST dot separator. This mirrors LoadDatabaseSettings, which
+// reconstructs a key as "<domainPath>.<name>". A key with no dot has an empty
+// domain path and is stored in the default domain.
+//
+//	"CMS.LLMS" -> ("CMS", "LLMS")
+//	"A.B.C"    -> ("A.B", "C")
+//	"FLATKEY"  -> ("",    "FLATKEY")
+func splitSettingKey(key string) (domainPath, name string) {
+	if idx := strings.LastIndex(key, "."); idx >= 0 {
+		return key[:idx], key[idx+1:]
+	}
+	return "", key
+}
+
+// resolveDomainID resolves a (possibly nested) domain path to its domain id,
+// creating any missing domains along the way. An empty path resolves to the
+// "default" domain. This is the write-side counterpart of getFullDomainPath
+// used by LoadDatabaseSettings, so a value written by Set/SetMulti is read back
+// under the exact same key after a reload (rather than landing in an orphan
+// row that nothing reads — the previous behaviour, which flattened the whole
+// dotted key into a single name under the "default" domain).
+func resolveDomainID(domainPath string) (uint, error) {
+	if domainPath == "" {
+		// Search only on the domain name; create-only columns go in Attrs so a
+		// pre-existing "default" row matches regardless of its other column
+		// values (see the loop below for why this matters).
+		var defaultDomain SettingDomain
+		err := db.Where("domain = ?", "default").
+			Attrs(SettingDomain{
+				Title:       "Default Settings",
+				Description: "Default settings domain",
+				Visible:     true,
+			}).
+			FirstOrCreate(&defaultDomain).Error
+		if err != nil {
+			return 0, fmt.Errorf("failed to create default domain: %w", err)
+		}
+		return defaultDomain.SettingsDomainID, nil
+	}
+
+	var parentID *uint
+	var leafID uint
+	for _, segment := range strings.Split(domainPath, ".") {
+		// Search ONLY on the domain's identity (name + parent). Create-only
+		// columns go in Attrs — if they were passed as FirstOrCreate conds GORM
+		// would fold their non-zero values (title, visible) into the SELECT, so
+		// an existing domain seeded by a migration with a different title would
+		// fail to match and a duplicate domain would be created.
+		var domain SettingDomain
+		query := db.Where("domain = ?", segment)
+		if parentID == nil {
+			query = query.Where("parent_domain IS NULL")
+		} else {
+			query = query.Where("parent_domain = ?", *parentID)
+		}
+		err := query.
+			Attrs(SettingDomain{
+				ParentDomain: parentID,
+				Title:        segment,
+				Visible:      true,
+			}).
+			FirstOrCreate(&domain).Error
+		if err != nil {
+			return 0, fmt.Errorf("failed to create/find domain %q: %w", segment, err)
+		}
+		leafID = domain.SettingsDomainID
+		id := domain.SettingsDomainID
+		parentID = &id
+	}
+	return leafID, nil
+}
+
+// saveSingleSetting saves a single setting to the database under the domain
+// implied by its hierarchical key. Creates the domain hierarchy and the
+// setting row if they don't exist; otherwise updates the existing row in place
+// so the change is picked up by every node via the settings-table CDC hook.
 func saveSingleSetting(key string, value any) error {
-	// Ensure default domain exists (cached after first call)
-	var defaultDomain SettingDomain
-	err := db.Where("domain = ?", "default").FirstOrCreate(&defaultDomain, SettingDomain{
-		Domain:      "default",
-		Title:       "Default Settings",
-		Description: "Default settings domain",
-		ReadOnly:    false,
-		Visible:     true,
-	}).Error
+	domainPath, name := splitSettingKey(key)
+	domainID, err := resolveDomainID(domainPath)
 	if err != nil {
-		return fmt.Errorf("failed to create default domain: %w", err)
+		return err
 	}
 
 	// Convert value to string for storage
 	valueStr := fmt.Sprint(value)
 
-	// Find or create the setting
+	// Find or create the setting under the resolved domain
 	var setting Setting
-	err = db.Where("domain_id = ? AND name = ?", defaultDomain.SettingsDomainID, key).
+	err = db.Where("domain_id = ? AND name = ?", domainID, name).
 		FirstOrCreate(&setting, Setting{
-			DomainID: defaultDomain.SettingsDomainID,
-			Name:     key,
+			DomainID: domainID,
+			Name:     name,
 		}).Error
 	if err != nil {
 		return fmt.Errorf("failed to create/find setting %s: %w", key, err)
@@ -138,45 +214,13 @@ func saveSingleSetting(key string, value any) error {
 	return nil
 }
 
-// saveDatabaseSettings saves multiple settings to the database.
-// Creates or updates settings in the default domain (domain_id = 1).
-func saveDatabaseSettings(flattenedData map[string]any) error {
-	// Ensure default domain exists
-	var defaultDomain SettingDomain
-	err := db.Where("domain = ?", "default").FirstOrCreate(&defaultDomain, SettingDomain{
-		Domain:      "default",
-		Title:       "Default Settings",
-		Description: "Default settings domain",
-		ReadOnly:    false,
-		Visible:     true,
-	}).Error
-	if err != nil {
-		return fmt.Errorf("failed to create default domain: %w", err)
-	}
-
-	// Save or update each setting
-	for key, value := range flattenedData {
-		// Convert value to string for storage
-		valueStr := fmt.Sprint(value)
-
-		var setting Setting
-		err := db.Where("domain_id = ? AND name = ?", defaultDomain.SettingsDomainID, key).
-			FirstOrCreate(&setting, Setting{
-				DomainID: defaultDomain.SettingsDomainID,
-				Name:     key,
-			}).Error
-		if err != nil {
-			return fmt.Errorf("failed to create/find setting %s: %w", key, err)
-		}
-
-		// Update value if changed
-		if setting.Value != valueStr {
-			setting.Value = valueStr
-			if err := db.Save(&setting).Error; err != nil {
-				return fmt.Errorf("failed to save setting %s: %w", key, err)
-			}
+// saveDatabaseSettings saves multiple settings to the database, each under the
+// domain implied by its hierarchical key (see saveSingleSetting).
+func saveDatabaseSettings(data map[string]any) error {
+	for key, value := range data {
+		if err := saveSingleSetting(key, value); err != nil {
+			return err
 		}
 	}
-
 	return nil
 }

lib/settings/settings.go

@@ -146,9 +146,12 @@ func Set(key string, value any) {
 	data[normalizedKey] = value
 	mu.Unlock()
 
-	// Persist to database if enabled
+	// Persist to database if enabled. The ORIGINAL (dotted) key is passed —
+	// not the flattened normalizedKey — so the domain hierarchy can be
+	// reconstructed and the value lands in the same row LoadDatabaseSettings
+	// reads back.
 	if db.IsEnabled() {
-		_ = saveSingleSetting(normalizedKey, value)
+		_ = saveSingleSetting(key, value)
 	}
 
 	// Trigger change callbacks
@@ -177,15 +180,11 @@ func SetMulti(in map[string]any) {
 	}
 	mu.Unlock()
 
-	// Persist to database if enabled
+	// Persist to database if enabled. Pass the ORIGINAL (dotted) keys so each
+	// value is stored under the correct domain hierarchy (see saveSingleSetting).
 	if db.IsEnabled() {
-		normalizedMap := make(map[string]any, len(in))
-		for key, value := range in {
-			normalizedMap[normalizeKey(key)] = value
-		}
 		db.UseModel(Setting{}, SettingDomain{})
-		_ = saveDatabaseSettings(normalizedMap)
-
+		_ = saveDatabaseSettings(in)
 	}
 
 	// Trigger change callbacks outside lock