@zucker-framework/config 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1265 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/config.service.ts
+import { Injectable as Injectable2, Inject, Logger as Logger2, Optional } from "@nestjs/common";
+import { ValidationException } from "@zucker-framework/core";
+import { EventEmitter2 } from "eventemitter2";
+
+// src/config-scope-manager.ts
+import { Injectable, Logger } from "@nestjs/common";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var ConfigScopeManager = class _ConfigScopeManager {
+  static {
+    __name(this, "ConfigScopeManager");
+  }
+  logger = new Logger(_ConfigScopeManager.name);
+  scopes = /* @__PURE__ */ new Map();
+  /**
+  * Register a fully defined scope.
+  */
+  register(scope) {
+    this.scopes.set(scope.id, scope);
+    this.logger.debug(`Config scope registered: ${scope.id} (${scope.name})`);
+  }
+  /**
+  * Add a scope with separate property definitions — mirrors jetlinks ConfigScopeManager.addScope().
+  *
+  * Reference: jetlinks ConfigScopeManager.addScope(ConfigScope, List<ConfigPropertyDef>)
+  */
+  addScope(scopePartial, properties) {
+    const existing = this.scopes.get(scopePartial.id);
+    if (existing) {
+      const existingKeys = new Set(existing.properties.map((p) => p.key));
+      for (const prop of properties) {
+        if (!existingKeys.has(prop.key)) {
+          existing.properties.push(prop);
+          existingKeys.add(prop.key);
+        }
+      }
+      return;
+    }
+    const scope = {
+      id: scopePartial.id,
+      name: scopePartial.name,
+      isPublic: scopePartial.publicAccess ?? false,
+      publicAccess: scopePartial.publicAccess ?? false,
+      properties
+    };
+    this.scopes.set(scope.id, scope);
+    this.logger.debug(`Config scope added: ${scope.id} (${scope.name})`);
+  }
+  /**
+  * Apply customizers — call during module initialization.
+  *
+  * Reference: jetlinks ConfigScopeProperties.custom()
+  */
+  applyCustomizers(customizers) {
+    for (const customizer of customizers) {
+      customizer.custom(this);
+    }
+  }
+  get(scopeId) {
+    return this.scopes.get(scopeId);
+  }
+  getAll() {
+    return Array.from(this.scopes.values());
+  }
+  has(scopeId) {
+    return this.scopes.has(scopeId);
+  }
+  unregister(scopeId) {
+    return this.scopes.delete(scopeId);
+  }
+  /**
+  * Get all scopes marked as public access.
+  *
+  * Reference: jetlinks SystemConfigManagerController checks isPublicAccess()
+  * for unauthenticated access.
+  */
+  getPublicScopes() {
+    return Array.from(this.scopes.values()).filter((s) => s.publicAccess);
+  }
+  getProperties(scopeId) {
+    return this.scopes.get(scopeId)?.properties ?? [];
+  }
+  /**
+  * Validate a config value against its scope property definition.
+  * Returns error messages if invalid.
+  */
+  validate(scopeId, key, value) {
+    const scope = this.scopes.get(scopeId);
+    if (!scope) return [
+      `Unknown scope: ${scopeId}`
+    ];
+    const prop = scope.properties.find((p) => p.key === key);
+    if (!prop) return [
+      `Unknown property: ${key} in scope ${scopeId}`
+    ];
+    const errors = [];
+    if (prop.readonly) {
+      errors.push(`Property ${key} is read-only`);
+    }
+    if (value === null || value === void 0) {
+      return errors;
+    }
+    const actualType = typeof value;
+    switch (prop.type) {
+      case "string":
+        if (actualType !== "string") errors.push(`Expected string for ${key}, got ${actualType}`);
+        break;
+      case "number":
+        if (actualType !== "number") errors.push(`Expected number for ${key}, got ${actualType}`);
+        break;
+      case "boolean":
+        if (actualType !== "boolean") errors.push(`Expected boolean for ${key}, got ${actualType}`);
+        break;
+      case "json":
+      case "object":
+        if (actualType !== "object") errors.push(`Expected object for ${key}, got ${actualType}`);
+        break;
+      case "password":
+      case "encrypted":
+        if (actualType !== "string") errors.push(`Expected string for encrypted ${key}, got ${actualType}`);
+        break;
+    }
+    return errors;
+  }
+};
+ConfigScopeManager = _ts_decorate([
+  Injectable()
+], ConfigScopeManager);
+
+// src/config.service.ts
+import { DATABASE_ADAPTER } from "@zucker-framework/crud";
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var CONFIG_CHANGED_EVENT = "zucker.config-changed";
+var CONFIG_CHANGED_TOPIC = "system/config/changed";
+var CONFIG_ENCRYPTOR = "CONFIG_ENCRYPTOR";
+var ConfigService = class _ConfigService {
+  static {
+    __name(this, "ConfigService");
+  }
+  db;
+  eventEmitter;
+  scopeManager;
+  encryptor;
+  topicEventBus;
+  logger = new Logger2(_ConfigService.name);
+  cache = /* @__PURE__ */ new Map();
+  static CACHE_MAX_SIZE = 1024;
+  constructor(db, eventEmitter, scopeManager, encryptor, topicEventBus) {
+    this.db = db;
+    this.eventEmitter = eventEmitter;
+    this.scopeManager = scopeManager;
+    this.encryptor = encryptor;
+    this.topicEventBus = topicEventBus;
+  }
+  /**
+  * 获取指定 scope 和 key 的配置值
+  * @param scope 配置域
+  * @param key 配置键
+  * @returns 配置值，不存在时返回 undefined
+  */
+  async get(scope, key) {
+    const cacheKey = `${scope}:${key}`;
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+    const record = await this.db.model("config").findUnique({
+      where: {
+        scope_key: {
+          scope,
+          key
+        }
+      }
+    });
+    if (!record) return void 0;
+    let value = record.value;
+    if (this.encryptor && this.isEncryptedProperty(scope, key)) {
+      try {
+        value = await this.encryptor.decrypt(value);
+      } catch (decryptError) {
+        this.logger.error(`Failed to decrypt config ${scope}.${key}: ${decryptError instanceof Error ? decryptError.message : String(decryptError)}`);
+        return void 0;
+      }
+    }
+    while (this.cache.size >= _ConfigService.CACHE_MAX_SIZE) {
+      const firstKey = this.cache.keys().next().value;
+      this.cache.delete(firstKey);
+    }
+    this.cache.set(cacheKey, value);
+    return value;
+  }
+  /**
+  * Get a config value with a fallback default.
+  * If no stored value exists, checks the scope definition default,
+  * then falls back to the provided default.
+  *
+  * Reference: jetlinks getProperties merges defaults from ConfigPropertyDef.
+  */
+  async getOrDefault(scope, key, defaultValue) {
+    const value = await this.get(scope, key);
+    if (value !== void 0) return value;
+    if (this.scopeManager?.has(scope)) {
+      const prop = this.scopeManager.getProperties(scope).find((p) => p.key === key);
+      if (prop?.defaultValue !== void 0) return prop.defaultValue;
+    }
+    return defaultValue;
+  }
+  /**
+  * 设置配置值（自动触发变更事件）
+  * @param scope 配置域
+  * @param key 配置键
+  * @param value 配置值
+  * @throws ValidationException 校验失败时
+  */
+  async set(scope, key, value) {
+    if (this.scopeManager?.has(scope)) {
+      const errors = this.scopeManager.validate(scope, key, value);
+      if (errors.length > 0) {
+        throw new ValidationException({
+          [key]: errors
+        }, `Config validation failed: ${errors.join(", ")}`);
+      }
+    }
+    const cacheKey = `${scope}:${key}`;
+    let oldValue = this.cache.get(cacheKey);
+    if (oldValue === void 0) {
+      const existing = await this.db.model("config").findUnique({
+        where: {
+          scope_key: {
+            scope,
+            key
+          }
+        }
+      });
+      if (existing) {
+        oldValue = existing.value;
+      }
+    }
+    let storedValue = value;
+    if (this.encryptor && this.isEncryptedProperty(scope, key) && typeof value === "string") {
+      storedValue = await this.encryptor.encrypt(value);
+    }
+    await this.db.model("config").update({
+      where: {
+        scope_key: {
+          scope,
+          key
+        }
+      },
+      data: {
+        value: storedValue
+      }
+    }).catch(async (updateError) => {
+      this.logger.debug(`Config key ${scope}.${key} not found, creating: ${updateError instanceof Error ? updateError.message : String(updateError)}`);
+      await this.db.model("config").create({
+        data: {
+          scope,
+          key,
+          value: storedValue
+        }
+      });
+    });
+    while (this.cache.size >= _ConfigService.CACHE_MAX_SIZE) {
+      const firstKey = this.cache.keys().next().value;
+      this.cache.delete(firstKey);
+    }
+    this.cache.set(cacheKey, value);
+    await this.recordHistory(scope, key, oldValue, value);
+    const payload = {
+      scope,
+      key,
+      oldValue,
+      newValue: value
+    };
+    this.eventEmitter?.emit(CONFIG_CHANGED_EVENT, payload);
+    if (this.topicEventBus) {
+      await this.topicEventBus.publish(CONFIG_CHANGED_TOPIC, payload);
+    }
+    this.logger.debug(`Config updated: ${scope}.${key}`);
+  }
+  /**
+  * Set multiple properties at once for a scope.
+  * Performs batch validation first, then persists all values and emits
+  * a single consolidated event — mirrors jetlinks ConfigManager.setProperties(scope, Map)
+  * which does repository.save + cache.evict instead of N individual updates.
+  */
+  async setProperties(scope, values) {
+    const entries = Object.entries(values);
+    if (entries.length === 0) return;
+    if (this.scopeManager?.has(scope)) {
+      const allErrors = {};
+      for (const [key, value] of entries) {
+        const errors = this.scopeManager.validate(scope, key, value);
+        if (errors.length > 0) {
+          allErrors[key] = errors;
+        }
+      }
+      if (Object.keys(allErrors).length > 0) {
+        throw new ValidationException(allErrors, `Config batch validation failed`);
+      }
+    }
+    const changes = [];
+    await this.db.$transaction(async (tx) => {
+      for (const [key, value] of entries) {
+        const cacheKey = `${scope}:${key}`;
+        const oldValue = this.cache.get(cacheKey);
+        let storedValue = value;
+        if (this.encryptor && this.isEncryptedProperty(scope, key) && typeof value === "string") {
+          storedValue = await this.encryptor.encrypt(value);
+        }
+        await tx.model("config").update({
+          where: {
+            scope_key: {
+              scope,
+              key
+            }
+          },
+          data: {
+            value: storedValue
+          }
+        }).catch(async (updateError) => {
+          this.logger.debug(`Config key ${scope}.${key} not found, creating: ${updateError instanceof Error ? updateError.message : String(updateError)}`);
+          await tx.model("config").create({
+            data: {
+              scope,
+              key,
+              value: storedValue
+            }
+          });
+        });
+        if (this.cache.size >= _ConfigService.CACHE_MAX_SIZE) {
+          const firstKey = this.cache.keys().next().value;
+          this.cache.delete(firstKey);
+        }
+        this.cache.set(cacheKey, value);
+        changes.push({
+          scope,
+          key,
+          oldValue,
+          newValue: value
+        });
+      }
+    });
+    for (const payload of changes) {
+      this.eventEmitter?.emit(CONFIG_CHANGED_EVENT, payload);
+    }
+    if (this.topicEventBus) {
+      for (const payload of changes) {
+        await this.topicEventBus.publish(CONFIG_CHANGED_TOPIC, payload);
+      }
+    }
+    this.logger.debug(`Config batch updated: ${scope} (${entries.length} properties)`);
+  }
+  /**
+  * 获取指定 scope 下的所有配置
+  * @param scope 配置域
+  * @returns 键值对集合（包含默认值）
+  */
+  async getAll(scope) {
+    const records = await this.db.model("config").findMany({
+      where: {
+        scope
+      }
+    });
+    const result = {};
+    if (this.scopeManager?.has(scope)) {
+      const props = this.scopeManager.getProperties(scope);
+      for (const prop of props) {
+        if (prop.defaultValue !== void 0) {
+          result[prop.key] = prop.defaultValue;
+        }
+      }
+    }
+    for (const record of records) {
+      let value = record.value;
+      if (this.encryptor && this.isEncryptedProperty(scope, record.key)) {
+        try {
+          value = await this.encryptor.decrypt(value);
+        } catch (decryptError) {
+          this.logger.error(`Failed to decrypt config ${scope}.${record.key}: ${decryptError instanceof Error ? decryptError.message : String(decryptError)}`);
+          continue;
+        }
+      }
+      result[record.key] = value;
+      if (this.cache.size >= _ConfigService.CACHE_MAX_SIZE) {
+        const firstKey = this.cache.keys().next().value;
+        this.cache.delete(firstKey);
+      }
+      this.cache.set(`${scope}:${record.key}`, value);
+    }
+    return result;
+  }
+  /**
+  * Remove a specific config property.
+  */
+  async remove(scope, key) {
+    const cacheKey = `${scope}:${key}`;
+    let oldValue = this.cache.get(cacheKey);
+    if (oldValue === void 0) {
+      const existing = await this.db.model("config").findUnique({
+        where: {
+          scope_key: {
+            scope,
+            key
+          }
+        }
+      });
+      if (existing) {
+        oldValue = existing.value;
+      }
+    }
+    await this.db.model("config").delete({
+      where: {
+        scope_key: {
+          scope,
+          key
+        }
+      }
+    }).catch(() => {
+    });
+    this.cache.delete(cacheKey);
+    const payload = {
+      scope,
+      key,
+      oldValue,
+      newValue: void 0
+    };
+    this.eventEmitter?.emit(CONFIG_CHANGED_EVENT, payload);
+    if (this.topicEventBus) {
+      await this.topicEventBus.publish(CONFIG_CHANGED_TOPIC, payload);
+    }
+  }
+  /**
+  * 监听配置变更事件
+  * @param callback 变更回调
+  * @returns 订阅句柄，调用 unsubscribe() 取消监听
+  */
+  onChange(callback) {
+    if (!this.eventEmitter) return {
+      unsubscribe: /* @__PURE__ */ __name(() => void 0, "unsubscribe")
+    };
+    const ee = this.eventEmitter;
+    ee.on(CONFIG_CHANGED_EVENT, callback);
+    return {
+      unsubscribe: /* @__PURE__ */ __name(() => ee.off(CONFIG_CHANGED_EVENT, callback), "unsubscribe")
+    };
+  }
+  /**
+  * 监听指定 scope.key 的配置变更，每次变更时执行回调。
+  *
+  * @param scope 配置域
+  * @param key 配置键（可选，不传则监听整个 scope）
+  * @param callback 变更回调
+  * @returns 取消监听函数
+  */
+  watch(scope, key, callback) {
+    const handler = /* @__PURE__ */ __name((payload) => {
+      if (payload.scope !== scope) return;
+      if (key && payload.key !== key) return;
+      callback(payload.newValue, payload.oldValue);
+    }, "handler");
+    if (!this.eventEmitter) return {
+      unsubscribe: /* @__PURE__ */ __name(() => void 0, "unsubscribe")
+    };
+    const ee = this.eventEmitter;
+    ee.on(CONFIG_CHANGED_EVENT, handler);
+    return {
+      unsubscribe: /* @__PURE__ */ __name(() => ee.off(CONFIG_CHANGED_EVENT, handler), "unsubscribe")
+    };
+  }
+  /**
+  * 清除配置缓存
+  * @param scope 可选的配置域，不传则清除所有缓存
+  */
+  clearCache(scope) {
+    if (scope) {
+      const prefix = `${scope}:`;
+      for (const key of this.cache.keys()) {
+        if (key.startsWith(prefix)) this.cache.delete(key);
+      }
+    } else {
+      this.cache.clear();
+    }
+  }
+  // ─── 配置版本控制 ──────────────────────────────────────────────────
+  /**
+  * 记录配置变更历史（自动版本号递增）
+  * 配置版本控制
+  */
+  async recordHistory(scope, key, oldValue, newValue) {
+    try {
+      await this.db.model("configHistory").create({
+        data: {
+          scope,
+          key,
+          oldValue: oldValue !== void 0 ? JSON.stringify(oldValue) : null,
+          newValue: JSON.stringify(newValue),
+          changedAt: /* @__PURE__ */ new Date()
+        }
+      });
+    } catch {
+    }
+  }
+  /**
+  * 查询配置变更历史
+  * @param scope 配置域
+  * @param key 配置键（可选，不传则查询该 scope 所有变更）
+  * @param limit 返回条数（默认 20）
+  */
+  async getHistory(scope, key, limit = 20) {
+    try {
+      const where = {
+        scope
+      };
+      if (key) where.key = key;
+      return await this.db.model("configHistory").findMany({
+        where,
+        orderBy: {
+          changedAt: "desc"
+        },
+        take: limit
+      });
+    } catch {
+      return [];
+    }
+  }
+  /**
+  * 回滚配置到指定历史版本
+  * @param historyId 历史记录 ID
+  */
+  async rollback(historyId) {
+    try {
+      const record = await this.db.model("configHistory").findUnique({
+        where: {
+          id: historyId
+        }
+      });
+      if (!record || record.oldValue === null) return;
+      const value = JSON.parse(record.oldValue);
+      await this.set(record.scope, record.key, value);
+    } catch (error) {
+      this.logger.warn(`Config rollback failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+  * Check if a property is marked as encrypted in its scope definition.
+  */
+  isEncryptedProperty(scope, key) {
+    if (!this.scopeManager) return false;
+    const props = this.scopeManager.getProperties(scope);
+    const prop = props.find((p) => p.key === key);
+    return prop?.encrypted === true;
+  }
+};
+ConfigService = _ts_decorate2([
+  Injectable2(),
+  _ts_param(0, Inject(DATABASE_ADAPTER)),
+  _ts_param(1, Optional()),
+  _ts_param(2, Optional()),
+  _ts_param(3, Optional()),
+  _ts_param(3, Inject(CONFIG_ENCRYPTOR)),
+  _ts_param(4, Optional()),
+  _ts_param(4, Inject("TOPIC_EVENT_BUS")),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DatabaseAdapter === "undefined" ? Object : DatabaseAdapter,
+    typeof EventEmitter2 === "undefined" ? Object : EventEmitter2,
+    typeof ConfigScopeManager === "undefined" ? Object : ConfigScopeManager,
+    typeof ConfigEncryptor === "undefined" ? Object : ConfigEncryptor,
+    typeof TopicEventBusLike === "undefined" ? Object : TopicEventBusLike
+  ])
+], ConfigService);
+
+// src/config.module.ts
+import { Module, Global } from "@nestjs/common";
+
+// src/layered-config.service.ts
+import { Injectable as Injectable3, Inject as Inject2, Logger as Logger3, Optional as Optional2 } from "@nestjs/common";
+import { ValidationException as ValidationException2 } from "@zucker-framework/core";
+import { EventEmitter2 as EventEmitter22 } from "eventemitter2";
+import { DATABASE_ADAPTER as DATABASE_ADAPTER2 } from "@zucker-framework/crud";
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata2(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var CONFIG_LAYER_PRIORITY = {
+  system: 0,
+  tenant: 1,
+  user: 2
+};
+var LAYERED_CONFIG_CHANGED_EVENT = "zucker.layered-config-changed";
+var LAYERED_CONFIG_CHANGED_TOPIC = "system/config/layered-changed";
+var LayeredConfigService = class _LayeredConfigService {
+  static {
+    __name(this, "LayeredConfigService");
+  }
+  db;
+  scopeManager;
+  eventEmitter;
+  topicEventBus;
+  logger = new Logger3(_LayeredConfigService.name);
+  cache = /* @__PURE__ */ new Map();
+  constructor(db, scopeManager, eventEmitter, topicEventBus) {
+    this.db = db;
+    this.scopeManager = scopeManager;
+    this.eventEmitter = eventEmitter;
+    this.topicEventBus = topicEventBus;
+  }
+  /**
+  * Get a config value, resolving through layers (user > tenant > system > default).
+  */
+  async get(scope, key, context) {
+    if (context?.userId) {
+      const userValue = await this.getLayerValue(scope, key, "user", context.userId);
+      if (userValue !== void 0) return userValue;
+    }
+    if (context?.tenantId) {
+      const tenantValue = await this.getLayerValue(scope, key, "tenant", context.tenantId);
+      if (tenantValue !== void 0) return tenantValue;
+    }
+    const systemValue = await this.getLayerValue(scope, key, "system");
+    if (systemValue !== void 0) return systemValue;
+    const scopeDef = this.scopeManager.get(scope);
+    if (scopeDef) {
+      const prop = scopeDef.properties.find((p) => p.key === key);
+      if (prop) return prop.defaultValue;
+    }
+    return void 0;
+  }
+  /**
+  * Set a config value at a specific layer.
+  */
+  async set(scope, key, value, layer, ownerId) {
+    const errors = this.scopeManager.validate(scope, key, value);
+    if (errors.length > 0) {
+      throw new ValidationException2({
+        [key]: errors
+      }, `Config validation failed: ${errors.join(", ")}`);
+    }
+    const compositeKey = this.buildLayerKey(scope, key, layer, ownerId);
+    const oldValue = await this.getLayerValue(scope, key, layer, ownerId);
+    await this.db.model("config").update({
+      where: {
+        scope_key: {
+          scope: compositeKey,
+          key
+        }
+      },
+      data: {
+        value,
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    }).catch(async () => {
+      await this.db.model("config").create({
+        data: {
+          scope: compositeKey,
+          key,
+          value
+        }
+      });
+    });
+    const payload = {
+      scope,
+      key,
+      layer,
+      oldValue,
+      newValue: value
+    };
+    this.eventEmitter?.emit(LAYERED_CONFIG_CHANGED_EVENT, payload);
+    if (this.topicEventBus) {
+      await this.topicEventBus.publish(LAYERED_CONFIG_CHANGED_TOPIC, payload);
+    }
+  }
+  /**
+  * Get all values for a scope, merged across layers.
+  */
+  async getAll(scope, context) {
+    const result = {};
+    const scopeDef = this.scopeManager.get(scope);
+    if (scopeDef) {
+      for (const prop of scopeDef.properties) {
+        if (prop.defaultValue !== void 0) {
+          result[prop.key] = prop.defaultValue;
+        }
+      }
+    }
+    const systemRecords = await this.getLayerRecords(scope, "system");
+    for (const [k, v] of Object.entries(systemRecords)) {
+      result[k] = v;
+    }
+    if (context?.tenantId) {
+      const tenantRecords = await this.getLayerRecords(scope, "tenant", context.tenantId);
+      for (const [k, v] of Object.entries(tenantRecords)) {
+        result[k] = v;
+      }
+    }
+    if (context?.userId) {
+      const userRecords = await this.getLayerRecords(scope, "user", context.userId);
+      for (const [k, v] of Object.entries(userRecords)) {
+        result[k] = v;
+      }
+    }
+    return result;
+  }
+  /**
+  * Set multiple properties at a specific layer.
+  * Validates all entries first, then persists in batch.
+  *
+  * Reference: jetlinks ConfigManager.setProperties(scope, Map)
+  */
+  async setProperties(scope, values, layer, ownerId) {
+    const entries = Object.entries(values);
+    if (entries.length === 0) return;
+    const allErrors = {};
+    for (const [key, value] of entries) {
+      const errors = this.scopeManager.validate(scope, key, value);
+      if (errors.length > 0) {
+        allErrors[key] = errors;
+      }
+    }
+    if (Object.keys(allErrors).length > 0) {
+      throw new ValidationException2(allErrors, `Layered config batch validation failed`);
+    }
+    const changes = [];
+    await this.db.$transaction(async (txDb) => {
+      for (const [key, value] of entries) {
+        const compositeKey = this.buildLayerKey(scope, key, layer, ownerId);
+        const cacheKey = `${compositeKey}:${key}`;
+        const oldValue = this.cache.get(cacheKey);
+        await txDb.model("config").update({
+          where: {
+            scope_key: {
+              scope: compositeKey,
+              key
+            }
+          },
+          data: {
+            value,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        }).catch(async () => {
+          await txDb.model("config").create({
+            data: {
+              scope: compositeKey,
+              key,
+              value
+            }
+          });
+        });
+        this.cache.set(cacheKey, value);
+        changes.push({
+          scope,
+          key,
+          layer,
+          oldValue,
+          newValue: value
+        });
+      }
+    });
+    for (const payload of changes) {
+      this.eventEmitter?.emit(LAYERED_CONFIG_CHANGED_EVENT, payload);
+    }
+    if (this.topicEventBus) {
+      for (const payload of changes) {
+        await this.topicEventBus.publish(LAYERED_CONFIG_CHANGED_TOPIC, payload);
+      }
+    }
+  }
+  /**
+  * Remove a config value at a specific layer.
+  */
+  async remove(scope, key, layer, ownerId) {
+    const compositeKey = this.buildLayerKey(scope, key, layer, ownerId);
+    const cacheKey = `${compositeKey}:${key}`;
+    const oldValue = this.cache.get(cacheKey);
+    await this.db.model("config").delete({
+      where: {
+        scope_key: {
+          scope: compositeKey,
+          key
+        }
+      }
+    }).catch(() => {
+    });
+    this.cache.delete(cacheKey);
+    const payload = {
+      scope,
+      key,
+      layer,
+      oldValue,
+      newValue: void 0
+    };
+    this.eventEmitter?.emit(LAYERED_CONFIG_CHANGED_EVENT, payload);
+    if (this.topicEventBus) {
+      await this.topicEventBus.publish(LAYERED_CONFIG_CHANGED_TOPIC, payload);
+    }
+  }
+  /**
+  * Clear the in-memory cache.
+  * @param scope Optional — only clear entries for this scope prefix
+  */
+  clearCache(scope) {
+    if (scope) {
+      for (const key of this.cache.keys()) {
+        if (key.startsWith(scope)) this.cache.delete(key);
+      }
+    } else {
+      this.cache.clear();
+    }
+  }
+  async getLayerValue(scope, key, layer, ownerId) {
+    const compositeKey = this.buildLayerKey(scope, key, layer, ownerId);
+    const cacheKey = `${compositeKey}:${key}`;
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+    const record = await this.db.model("config").findUnique({
+      where: {
+        scope_key: {
+          scope: compositeKey,
+          key
+        }
+      }
+    });
+    if (record) {
+      this.cache.set(cacheKey, record.value);
+    }
+    return record?.value;
+  }
+  async getLayerRecords(scope, layer, ownerId) {
+    const compositeScope = ownerId ? `${scope}@${layer}:${ownerId}` : `${scope}@${layer}`;
+    const records = await this.db.model("config").findMany({
+      where: {
+        scope: compositeScope
+      }
+    });
+    const result = {};
+    for (const record of records) {
+      result[record.key] = record.value;
+    }
+    return result;
+  }
+  buildLayerKey(scope, _key, layer, ownerId) {
+    if (ownerId) {
+      return `${scope}@${layer}:${ownerId}`;
+    }
+    return `${scope}@${layer}`;
+  }
+};
+LayeredConfigService = _ts_decorate3([
+  Injectable3(),
+  _ts_param2(0, Inject2(DATABASE_ADAPTER2)),
+  _ts_param2(2, Optional2()),
+  _ts_param2(3, Optional2()),
+  _ts_param2(3, Inject2("TOPIC_EVENT_BUS")),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof DatabaseAdapter === "undefined" ? Object : DatabaseAdapter,
+    typeof ConfigScopeManager === "undefined" ? Object : ConfigScopeManager,
+    typeof EventEmitter22 === "undefined" ? Object : EventEmitter22,
+    typeof TopicEventBusLike === "undefined" ? Object : TopicEventBusLike
+  ])
+], LayeredConfigService);
+
+// src/config.module.ts
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+var CONFIG_MODULE_OPTIONS = /* @__PURE__ */ Symbol("CONFIG_MODULE_OPTIONS");
+var ZuckerConfigModule = class _ZuckerConfigModule {
+  static {
+    __name(this, "ZuckerConfigModule");
+  }
+  static forRoot(options) {
+    const providers = [
+      ConfigService,
+      ConfigScopeManager,
+      LayeredConfigService
+    ];
+    if (options?.encryptor) {
+      providers.push({
+        provide: CONFIG_ENCRYPTOR,
+        useValue: options.encryptor
+      });
+    }
+    return {
+      module: _ZuckerConfigModule,
+      global: true,
+      providers,
+      exports: [
+        ConfigService,
+        ConfigScopeManager,
+        LayeredConfigService
+      ]
+    };
+  }
+  static forRootAsync(options) {
+    const asyncProviders = this.createAsyncProviders(options);
+    return {
+      module: _ZuckerConfigModule,
+      global: true,
+      imports: options.imports ?? [],
+      providers: [
+        ...asyncProviders,
+        {
+          provide: CONFIG_ENCRYPTOR,
+          useFactory: /* @__PURE__ */ __name((opts) => opts.encryptor ?? null, "useFactory"),
+          inject: [
+            CONFIG_MODULE_OPTIONS
+          ]
+        },
+        ConfigService,
+        ConfigScopeManager,
+        LayeredConfigService
+      ],
+      exports: [
+        ConfigService,
+        ConfigScopeManager,
+        LayeredConfigService
+      ]
+    };
+  }
+  static createAsyncProviders(options) {
+    if (options.useFactory) {
+      return [
+        {
+          provide: CONFIG_MODULE_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject ?? []
+        }
+      ];
+    }
+    const optionsProvider = {
+      provide: CONFIG_MODULE_OPTIONS,
+      useFactory: /* @__PURE__ */ __name(async (factory) => factory.createConfigOptions(), "useFactory"),
+      inject: [
+        options.useClass ?? options.useExisting
+      ]
+    };
+    if (options.useClass) {
+      return [
+        {
+          provide: options.useClass,
+          useClass: options.useClass
+        },
+        optionsProvider
+      ];
+    }
+    return [
+      optionsProvider
+    ];
+  }
+};
+ZuckerConfigModule = _ts_decorate4([
+  Global(),
+  Module({})
+], ZuckerConfigModule);
+
+// src/config.guard.ts
+import { Injectable as Injectable4, Inject as Inject3, Logger as Logger4 } from "@nestjs/common";
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata3(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var CONFIG_SCOPE_REGISTRY = "CONFIG_SCOPE_REGISTRY";
+var ConfigGuard = class _ConfigGuard {
+  static {
+    __name(this, "ConfigGuard");
+  }
+  scopeRegistry;
+  logger = new Logger4(_ConfigGuard.name);
+  constructor(scopeRegistry) {
+    this.scopeRegistry = scopeRegistry;
+  }
+  canActivate(context) {
+    const request = context.switchToHttp().getRequest();
+    const scope = request.params?.scope ?? request.query?.scope;
+    if (!scope) {
+      return this.isAuthenticated(request);
+    }
+    const entry = this.scopeRegistry.get(scope);
+    if (entry?.publicAccess) {
+      this.logger.debug(`\u516C\u5F00\u8BBF\u95EE scope: ${scope}`);
+      return true;
+    }
+    return this.isAuthenticated(request);
+  }
+  isAuthenticated(request) {
+    return !!request.user;
+  }
+};
+ConfigGuard = _ts_decorate5([
+  Injectable4(),
+  _ts_param3(0, Inject3(CONFIG_SCOPE_REGISTRY)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Map === "undefined" ? Object : Map
+  ])
+], ConfigGuard);
+
+// src/feature-flags.ts
+import { Injectable as Injectable5 } from "@nestjs/common";
+import { FeatureFlagEvaluator } from "@zucker-framework/feature-flags";
+import { FeatureFlagEvaluator as FeatureFlagEvaluator2, defaultFeatureFlagEnvKey } from "@zucker-framework/feature-flags";
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata4(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata4, "_ts_metadata");
+var FeatureFlagService = class extends FeatureFlagEvaluator {
+  static {
+    __name(this, "FeatureFlagService");
+  }
+  constructor() {
+    super((key) => process.env[key]);
+  }
+};
+FeatureFlagService = _ts_decorate6([
+  Injectable5(),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [])
+], FeatureFlagService);
+
+// src/config-watcher.ts
+import { Logger as Logger5 } from "@nestjs/common";
+import { watch, existsSync, statSync } from "fs";
+var ConfigFileWatcher = class _ConfigFileWatcher {
+  static {
+    __name(this, "ConfigFileWatcher");
+  }
+  logger = new Logger5(_ConfigFileWatcher.name);
+  stabilityMs;
+  deleteGraceMs;
+  watched = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.stabilityMs = options.stabilityMs ?? 1e3;
+    this.deleteGraceMs = options.deleteGraceMs ?? 1700;
+  }
+  /**
+  * 开始监听文件
+  * @returns 取消监听函数
+  */
+  watch(filePath, callback) {
+    if (this.watched.has(filePath)) {
+      this.unwatch(filePath);
+    }
+    const entry = {
+      path: filePath,
+      callback,
+      watcher: null,
+      debounceTimer: null,
+      deleteGraceTimer: null,
+      lastModified: this.getModifiedTime(filePath)
+    };
+    try {
+      entry.watcher = watch(filePath, (eventType) => {
+        this.handleEvent(entry, eventType);
+      });
+      entry.watcher.on("error", (err) => {
+        this.logger.warn(`Watch error on ${filePath}: ${err.message}`);
+      });
+    } catch {
+      this.logger.warn(`Cannot watch ${filePath} \u2014 file may not exist yet`);
+    }
+    this.watched.set(filePath, entry);
+    return () => this.unwatch(filePath);
+  }
+  /**
+  * 停止监听指定文件
+  */
+  unwatch(filePath) {
+    const entry = this.watched.get(filePath);
+    if (!entry) return;
+    entry.watcher?.close();
+    if (entry.debounceTimer) clearTimeout(entry.debounceTimer);
+    if (entry.deleteGraceTimer) clearTimeout(entry.deleteGraceTimer);
+    this.watched.delete(filePath);
+  }
+  /**
+  * 关闭所有监听
+  */
+  close() {
+    for (const path of [
+      ...this.watched.keys()
+    ]) {
+      this.unwatch(path);
+    }
+  }
+  /**
+  * 获取当前监听的文件列表
+  */
+  getWatchedFiles() {
+    return [
+      ...this.watched.keys()
+    ];
+  }
+  handleEvent(entry, eventType) {
+    if (eventType === "rename") {
+      if (!existsSync(entry.path)) {
+        if (entry.deleteGraceTimer) clearTimeout(entry.deleteGraceTimer);
+        entry.deleteGraceTimer = setTimeout(() => {
+          entry.deleteGraceTimer = null;
+          if (!existsSync(entry.path)) {
+            this.logger.warn(`Config file deleted: ${entry.path}`);
+          }
+        }, this.deleteGraceMs);
+        return;
+      }
+      if (entry.deleteGraceTimer) {
+        clearTimeout(entry.deleteGraceTimer);
+        entry.deleteGraceTimer = null;
+      }
+    }
+    if (entry.debounceTimer) clearTimeout(entry.debounceTimer);
+    entry.debounceTimer = setTimeout(() => {
+      entry.debounceTimer = null;
+      const newModified = this.getModifiedTime(entry.path);
+      if (newModified === entry.lastModified) return;
+      entry.lastModified = newModified;
+      this.logger.log(`Config changed: ${entry.path}`);
+      try {
+        entry.callback();
+      } catch (err) {
+        this.logger.error(`Config reload callback failed: ${err}`);
+      }
+    }, this.stabilityMs);
+  }
+  getModifiedTime(filePath) {
+    try {
+      return statSync(filePath).mtimeMs;
+    } catch {
+      return 0;
+    }
+  }
+};
+export {
+  CONFIG_CHANGED_EVENT,
+  CONFIG_CHANGED_TOPIC,
+  CONFIG_ENCRYPTOR,
+  CONFIG_LAYER_PRIORITY,
+  CONFIG_MODULE_OPTIONS,
+  CONFIG_SCOPE_REGISTRY,
+  ConfigFileWatcher,
+  ConfigGuard,
+  ConfigScopeManager,
+  ConfigService,
+  DATABASE_ADAPTER,
+  FeatureFlagEvaluator2 as FeatureFlagEvaluator,
+  FeatureFlagService,
+  LAYERED_CONFIG_CHANGED_EVENT,
+  LAYERED_CONFIG_CHANGED_TOPIC,
+  LayeredConfigService,
+  ZuckerConfigModule,
+  defaultFeatureFlagEnvKey
+};