@futdevpro/nts-dynamo 1.15.156 → 1.15.160

package/src/_modules/scoped-config/_services/dynts-scoped-config.control-service.spec.ts

@@ -1,312 +0,0 @@
-
-import { DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_GlobalService } from '../../../_services/core/global.service';
-import { DyNTS_ScopedConfig_Level } from '../_enums/dynts-scoped-config-level.enum';
-import { DyNTS_ScopedConfig } from '../_models/data-models/dynts-scoped-config.data-model';
-import {
-  DyNTS_ScopedConfigResolvedValue
-} from '../_models/interfaces/dynts-scoped-config.interface';
-import { DyNTS_ScopedConfig_DataService } from './dynts-scoped-config.data-service';
-import { DyNTS_ScopedConfig_ControlService } from './dynts-scoped-config.control-service';
-
-/**
- * BFR-AM-004 — a generikus scoped-config precedencia-engine spec-jei.
- *
- * A `DyNTS_ScopedConfig_ControlService` minden DB-művelet előtt lazy `new DyNTS_ScopedConfig_DataService`-t
- * készít (eager DB-resolve a base-ctor-ban — memory: dynts_dataservice_eager_resolve), ezért a teszt:
- * (1) stub-olja a `DyNTS_GlobalService.getDBService`-t (hogy a base-ctor ne dobjon),
- * (2) stub-olja a `DyNTS_ScopedConfig_DataService.prototype.findActiveList`-et a kontrollált
- *     rekord-halmazzal (a precedencia memóriában fut, így NEM kell élő Mongo) → a DB-round-trip
- *     spec-ek így tisztán futnak Mongo NÉLKÜL (skip-guard nem szükséges).
- */
-describe('| DyNTS_ScopedConfig_ControlService', () => {
-
-  let control: DyNTS_ScopedConfig_ControlService;
-  let mockDBService: jasmine.SpyObj<{ find: () => Promise<unknown[]>; findOne: () => Promise<unknown> }>;
-
-  /** Egy aktív rekord gyors gyártása a kontrollált rekord-halmazhoz. */
-  const makeRecord = (set: Partial<DyNTS_ScopedConfig>): DyNTS_ScopedConfig =>
-    new DyNTS_ScopedConfig(set);
-
-  beforeAll(() => {
-    if (!DyNTS_global_settings.systemShortCodeName) {
-      (DyNTS_global_settings as { systemShortCodeName?: string }).systemShortCodeName = 'TEST';
-    }
-
-    if (!DyNTS_global_settings.env_settings) {
-      (DyNTS_global_settings as { env_settings?: unknown }).env_settings = {
-        environment: DyFM_EnvironmentFlag.local,
-      };
-    }
-  });
-
-  beforeEach(() => {
-    // A base-ctor eager getDBService-jét stub-oljuk, hogy a lazy DataService-példányok ne dobjanak.
-    mockDBService = jasmine.createSpyObj('DyNTS_DBService', [ 'find', 'findOne' ]);
-    mockDBService.find.and.returnValue(Promise.resolve([]));
-    mockDBService.findOne.and.returnValue(Promise.resolve(null));
-    spyOn(DyNTS_GlobalService, 'getDBService').and.returnValue(mockDBService as never);
-
-    // Friss singleton-állapot minden teszthez (új instance + tiszta cache).
-    (DyNTS_ScopedConfig_ControlService as unknown as { _instance?: DyNTS_ScopedConfig_ControlService })._instance = undefined;
-    control = DyNTS_ScopedConfig_ControlService.getInstance();
-    control.invalidateCache();
-  });
-
-  /** A kontrollált aktív rekord-halmaz beállítása (a `loadEffectiveRecords` ezt kapja vissza). */
-  const stubRecords = (records: DyNTS_ScopedConfig[]): void => {
-    spyOn(DyNTS_ScopedConfig_DataService.prototype, 'findActiveList').and.returnValue(Promise.resolve(records));
-  };
-
-  describe('| getInstance', () => {
-    it('| should return the same singleton instance', () => {
-      expect(DyNTS_ScopedConfig_ControlService.getInstance()).toBe(control);
-    });
-  });
-
-  describe('| resolve — precedence', () => {
-
-    it('| should return builtinDefault when no DB record exists', async () => {
-      stubRecords([]);
-
-      const resolved: DyNTS_ScopedConfigResolvedValue<number> =
-        await control.resolve<number>('read.topK', { builtinDefault: 5 });
-
-      expect(resolved.value).toBe(5);
-      expect(resolved.resolvedFrom).toBe('builtin');
-    });
-
-    it('| should return global over builtinDefault', async () => {
-      stubRecords([
-        makeRecord({ level: DyNTS_ScopedConfig_Level.global, key: 'read.topK', value: 10, setBy: 'manual' }),
-      ]);
-
-      const resolved: DyNTS_ScopedConfigResolvedValue<number> =
-        await control.resolve<number>('read.topK', { builtinDefault: 5 });
-
-      expect(resolved.value).toBe(10);
-      expect(resolved.resolvedFrom).toBe('global');
-      expect(resolved.setBy).toBe('manual');
-    });
-
-    it('| should return table over global', async () => {
-      stubRecords([
-        makeRecord({ level: DyNTS_ScopedConfig_Level.global, key: 'read.topK', value: 10 }),
-        makeRecord({ level: DyNTS_ScopedConfig_Level.table, tableScope: 'documents', key: 'read.topK', value: 20 }),
-      ]);
-
-      const resolved: DyNTS_ScopedConfigResolvedValue<number> =
-        await control.resolve<number>('read.topK', { table: 'documents', builtinDefault: 5 });
-
-      expect(resolved.value).toBe(20);
-      expect(resolved.resolvedFrom).toBe('table');
-    });
-
-    it('| should return scope-root over table', async () => {
-      stubRecords([
-        makeRecord({ level: DyNTS_ScopedConfig_Level.global, key: 'read.topK', value: 10 }),
-        makeRecord({ level: DyNTS_ScopedConfig_Level.table, tableScope: 'documents', key: 'read.topK', value: 20 }),
-        makeRecord({ level: DyNTS_ScopedConfig_Level.scope, tableScope: 'documents', scopeId: 'root', key: 'read.topK', value: 30 }),
-      ]);
-
-      const resolved: DyNTS_ScopedConfigResolvedValue<number> = await control.resolve<number>('read.topK', {
-        table: 'documents',
-        scopePath: [{ scopeId: 'root' }],
-        builtinDefault: 5,
-      });
-
-      expect(resolved.value).toBe(30);
-      expect(resolved.resolvedFrom).toBe('scope');
-      expect(resolved.scopeId).toBe('root');
-    });
-
-    it('| should return scope-LEAF over scope-root (deepest wins)', async () => {
-      stubRecords([
-        makeRecord({ level: DyNTS_ScopedConfig_Level.table, tableScope: 'documents', key: 'read.topK', value: 20 }),
-        makeRecord({ level: DyNTS_ScopedConfig_Level.scope, tableScope: 'documents', scopeId: 'root', key: 'read.topK', value: 30 }),
-        makeRecord({ level: DyNTS_ScopedConfig_Level.scope, tableScope: 'documents', scopeId: 'leaf', key: 'read.topK', value: 40 }),
-      ]);
-
-      // scopePath: gyökér→levél; a feloldás a LEVÉBŐL (leaf) indul → 'leaf' nyer 'root' felett.
-      const resolved: DyNTS_ScopedConfigResolvedValue<number> = await control.resolve<number>('read.topK', {
-        table: 'documents',
-        scopePath: [{ scopeId: 'root' }, { scopeId: 'leaf' }],
-        builtinDefault: 5,
-      });
-
-      expect(resolved.value).toBe(40);
-      expect(resolved.resolvedFrom).toBe('scope');
-      expect(resolved.scopeId).toBe('leaf');
-    });
-
-    it('| should fall back to scope-root when leaf has no record for the key', async () => {
-      stubRecords([
-        makeRecord({ level: DyNTS_ScopedConfig_Level.scope, tableScope: 'documents', scopeId: 'root', key: 'read.topK', value: 30 }),
-        // 'leaf' csak EGY MÁSIK kulcsot állít — read.topK-ra nincs leaf-rekord → scope-root nyer.
-        makeRecord({ level: DyNTS_ScopedConfig_Level.scope, tableScope: 'documents', scopeId: 'leaf', key: 'read.maxResults', value: 99 }),
-      ]);
-
-      const resolved: DyNTS_ScopedConfigResolvedValue<number> = await control.resolve<number>('read.topK', {
-        table: 'documents',
-        scopePath: [{ scopeId: 'root' }, { scopeId: 'leaf' }],
-        builtinDefault: 5,
-      });
-
-      expect(resolved.value).toBe(30);
-      expect(resolved.scopeId).toBe('root');
-    });
-
-    it('| should NOT use a table record from a different tableScope', async () => {
-      stubRecords([
-        makeRecord({ level: DyNTS_ScopedConfig_Level.table, tableScope: 'other', key: 'read.topK', value: 999 }),
-        makeRecord({ level: DyNTS_ScopedConfig_Level.global, key: 'read.topK', value: 10 }),
-      ]);
-
-      const resolved: DyNTS_ScopedConfigResolvedValue<number> =
-        await control.resolve<number>('read.topK', { table: 'documents', builtinDefault: 5 });
-
-      // 'other' table-rekord nem releváns → global nyer.
-      expect(resolved.value).toBe(10);
-      expect(resolved.resolvedFrom).toBe('global');
-    });
-
-    it('| should ignore scope/table records when context has no table', async () => {
-      stubRecords([
-        makeRecord({ level: DyNTS_ScopedConfig_Level.table, tableScope: 'documents', key: 'read.topK', value: 20 }),
-        makeRecord({ level: DyNTS_ScopedConfig_Level.global, key: 'read.topK', value: 10 }),
-      ]);
-
-      const resolved: DyNTS_ScopedConfigResolvedValue<number> =
-        await control.resolve<number>('read.topK', { builtinDefault: 5 });
-
-      expect(resolved.value).toBe(10);
-      expect(resolved.resolvedFrom).toBe('global');
-    });
-  });
-
-  describe('| resolve — Mixed value get', () => {
-
-    it('| should resolve a string[] (Mixed) value intact', async () => {
-      const patterns: string[] = [ '**/node_modules/**', '**/.git/**' ];
-
-      stubRecords([
-        makeRecord({ level: DyNTS_ScopedConfig_Level.global, key: 'scan.ignorePatterns', value: patterns }),
-      ]);
-
-      const resolved: DyNTS_ScopedConfigResolvedValue<string[]> =
-        await control.resolve<string[]>('scan.ignorePatterns', { builtinDefault: [] });
-
-      expect(resolved.value).toEqual(patterns);
-      expect(resolved.resolvedFrom).toBe('global');
-    });
-
-    it('| should resolve an object (Mixed) value intact', async () => {
-      const obj = { provider: 'openai', model: 'text-embedding-3-large' };
-
-      stubRecords([
-        makeRecord({ level: DyNTS_ScopedConfig_Level.global, key: 'embedding.config', value: obj }),
-      ]);
-
-      const resolved: DyNTS_ScopedConfigResolvedValue<{ provider: string; model: string }> =
-        await control.resolve('embedding.config', { builtinDefault: { provider: '', model: '' } });
-
-      expect(resolved.value).toEqual(obj);
-    });
-  });
-
-  describe('| resolveAll', () => {
-
-    it('| should merge all configured keys with their resolved source level', async () => {
-      stubRecords([
-        makeRecord({ level: DyNTS_ScopedConfig_Level.global, key: 'read.topK', value: 10 }),
-        makeRecord({ level: DyNTS_ScopedConfig_Level.table, tableScope: 'documents', key: 'read.topK', value: 20 }),
-        makeRecord({ level: DyNTS_ScopedConfig_Level.global, key: 'read.minScore', value: 0.5 }),
-        makeRecord({ level: DyNTS_ScopedConfig_Level.scope, tableScope: 'documents', scopeId: 'leaf', key: 'read.maxResults', value: 99 }),
-      ]);
-
-      const all = await control.resolveAll({ table: 'documents', scopePath: [{ scopeId: 'leaf' }] });
-
-      // read.topK: table nyer a global felett.
-      expect(all['read.topK'].value).toBe(20);
-      expect(all['read.topK'].resolvedFrom).toBe('table');
-      // read.minScore: csak global.
-      expect(all['read.minScore'].value).toBe(0.5);
-      expect(all['read.minScore'].resolvedFrom).toBe('global');
-      // read.maxResults: scope (leaf).
-      expect(all['read.maxResults'].value).toBe(99);
-      expect(all['read.maxResults'].resolvedFrom).toBe('scope');
-    });
-
-    it('| should return empty object when no records configured', async () => {
-      stubRecords([]);
-      const all = await control.resolveAll({ table: 'documents' });
-
-      expect(Object.keys(all).length).toBe(0);
-    });
-  });
-
-  describe('| set', () => {
-
-    it('| should archive an existing active record then write the new one', async () => {
-      const existing: DyNTS_ScopedConfig =
-        makeRecord({ _id: 'old-id', level: DyNTS_ScopedConfig_Level.global, key: 'read.topK', value: 10 });
-      const savedNew: DyNTS_ScopedConfig =
-        makeRecord({ _id: 'new-id', level: DyNTS_ScopedConfig_Level.global, key: 'read.topK', value: 25 });
-
-      const findActiveSpy = spyOn(DyNTS_ScopedConfig_DataService.prototype, 'findActive')
-        .and.returnValue(Promise.resolve(existing));
-      const deleteSpy = spyOn(DyNTS_ScopedConfig_DataService.prototype, 'deleteData')
-        .and.returnValue(Promise.resolve());
-      const saveSpy = spyOn(DyNTS_ScopedConfig_DataService.prototype, 'saveData')
-        .and.returnValue(Promise.resolve(savedNew));
-
-      const result: DyNTS_ScopedConfig =
-        await control.set(DyNTS_ScopedConfig_Level.global, 'read.topK', 25, { setBy: 'cli' });
-
-      expect(findActiveSpy).toHaveBeenCalled();
-      expect(deleteSpy).toHaveBeenCalledWith('old-id');
-      expect(saveSpy).toHaveBeenCalled();
-      // A kiírt rekord a helyes kulcsot + értéket + audit-ot hordozza.
-      const written: DyNTS_ScopedConfig = saveSpy.calls.mostRecent().args[0];
-
-      expect(written.key).toBe('read.topK');
-      expect(written.value).toBe(25);
-      expect(written.setBy).toBe('cli');
-      expect(result).toBe(savedNew);
-    });
-
-    it('| should write a new record without deleting when no active record exists', async () => {
-      spyOn(DyNTS_ScopedConfig_DataService.prototype, 'findActive').and.returnValue(Promise.resolve(null));
-      const deleteSpy = spyOn(DyNTS_ScopedConfig_DataService.prototype, 'deleteData').and.returnValue(Promise.resolve());
-
-      spyOn(DyNTS_ScopedConfig_DataService.prototype, 'saveData')
-        .and.callFake((data?: DyNTS_ScopedConfig) => Promise.resolve(data));
-
-      const result: DyNTS_ScopedConfig = await control.set(
-        DyNTS_ScopedConfig_Level.table,
-        'read.topK',
-        20,
-        { tableScope: 'documents' },
-      );
-
-      expect(deleteSpy).not.toHaveBeenCalled();
-      expect(result.value).toBe(20);
-      expect(result.tableScope).toBe('documents');
-      expect(result.setBy).toBe('system');
-    });
-
-    it('| should throw when table level set is missing tableScope', async () => {
-      await expectAsync(
-        control.set(DyNTS_ScopedConfig_Level.table, 'read.topK', 20, {}),
-      ).toBeRejectedWithError(/tableScope/);
-    });
-
-    it('| should throw when scope level set is missing scopeId', async () => {
-      await expectAsync(
-        control.set(DyNTS_ScopedConfig_Level.scope, 'read.topK', 20, { tableScope: 'documents' }),
-      ).toBeRejectedWithError(/scopeId/);
-    });
-  });
-});

package/src/_modules/scoped-config/_services/dynts-scoped-config.control-service.ts

@@ -1,311 +0,0 @@
-
-import { DyFM_DBFilterSimple } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_ScopedConfig_Level } from '../_enums/dynts-scoped-config-level.enum';
-import { DyNTS_ScopedConfig } from '../_models/data-models/dynts-scoped-config.data-model';
-import {
-  DyNTS_ScopedConfigResolveContext,
-  DyNTS_ScopedConfigResolvedFrom,
-  DyNTS_ScopedConfigResolvedValue,
-  DyNTS_ScopedConfigResolveOptions,
-  DyNTS_ScopedConfigSetOptions,
-  DyNTS_ScopedConfigValue
-} from '../_models/interfaces/dynts-scoped-config.interface';
-import { DyNTS_ScopedConfig_DataService } from './dynts-scoped-config.data-service';
-
-/**
- * Egy memória-cache bejegyzés (a `resolveAll` egy-Mongo-körös eredménye, rövid TTL-lel).
- */
-interface DyNTS_ScopedConfigCacheEntry {
-  /** A cache-elt aktív rekordok (egy kontextus-szeletre). */
-  records: DyNTS_ScopedConfig[];
-  /** Lejárati timestamp (epoch ms). */
-  expiresAt: number;
-}
-
-/**
- * `DyNTS_ScopedConfig_ControlService` — a DB-backed, scoped config GENERIKUS feloldó-engine (BFR-AM-004).
- *
- * Singleton. Domain-agnosztikus: NINCS beépített kulcs-katalógus / default — a katalógus a FOGYASZTÓ
- * dolga (a FAM `FAM_Config_ControlService` ennek vékony fogyasztója lesz). A bedrock CSAK a generikus
- * precedencia-engine + a tárolás + a rövid-TTL cache.
- *
- * **Precedencia (a legspecifikusabb nyer):** `scope (leaf→root, a legmélyebb találat) > table > global
- * > builtinDefault` (utóbbi a hívó által átadott fallback). A `resolve(key, opts)` egy kulcsot old fel;
- * a `resolveAll(ctx)` az összes konfigurált kulcsot egy Mongo-körrel; a `set(level, key, value, opts)`
- * archive-old-active + új aktív rekord + cache-invalidálás.
- *
- * **FIGYELEM (memory: dynts_dataservice_eager_resolve):** NEM tartunk élő `DyNTS_ScopedConfig_DataService`
- * mezőt (eager DB-resolve a base-ctor-ban) — minden DB-művelet előtt lazy `new ...DataService`.
- */
-export class DyNTS_ScopedConfig_ControlService {
-
-  private static _instance: DyNTS_ScopedConfig_ControlService;
-
-  /** Default issuer a config-műveletekhez. */
-  private readonly issuer: string = 'DyNTS_ScopedConfig_ControlService';
-
-  /** Rövid-TTL memória-cache (kulcs: kontextus-szelet; `set` invalidálja). */
-  private cache: Map<string, DyNTS_ScopedConfigCacheEntry> = new Map<string, DyNTS_ScopedConfigCacheEntry>();
-
-  /** A cache TTL ms-ben (~5s; rövid, hogy a hot-path olcsó legyen, de a `set` után friss). */
-  private cacheTtlMs: number = 5000;
-
-  static getInstance(): DyNTS_ScopedConfig_ControlService {
-    if (!DyNTS_ScopedConfig_ControlService._instance) {
-      DyNTS_ScopedConfig_ControlService._instance = new DyNTS_ScopedConfig_ControlService();
-    }
-
-    return DyNTS_ScopedConfig_ControlService._instance;
-  }
-
-  // =========================================================================
-  // RESOLVE — precedencia: scope (leaf→root) > table > global > builtinDefault
-  // =========================================================================
-
-  /**
-   * Egy kulcs feloldása a legspecifikusabb beállított értékre. A precedencia:
-   * (1) SCOPE szint a `scopePath` LEVÉBŐL a gyökér felé (az első/legmélyebb találat nyer),
-   * (2) TABLE szint, (3) GLOBAL szint, (4) a hívó által átadott `builtinDefault` (ha van).
-   *
-   * A `scopePath` canonical formában érkezik (a fogyasztó read/write-path-ja oldotta fel).
-   */
-  async resolve<T = DyNTS_ScopedConfigValue>(
-    key: string,
-    options?: DyNTS_ScopedConfigResolveOptions<T>,
-  ): Promise<DyNTS_ScopedConfigResolvedValue<T>> {
-    const context: DyNTS_ScopedConfigResolveContext = {
-      table: options?.table,
-      scopePath: options?.scopePath,
-    };
-    const records: DyNTS_ScopedConfig[] = await this.loadEffectiveRecords(context);
-
-    return this.resolveFromRecords<T>(key, records, context, options?.builtinDefault);
-  }
-
-  /**
-   * A teljes effektív config egy adott kontextusra (batch). EGY Mongo-kör (cache-elt), majd memóriában
-   * merge: minden KONFIGURÁLT kulcsra a feloldott érték + forrás-szint. A hot-path (read/write) ezt
-   * használja, nem per-key kört. A builtin-only kulcsok NEM jelennek meg (nincs katalógus a bedrock-ban
-   * — azokat a fogyasztó iterálja a saját katalógusából a `resolve`-on át).
-   */
-  async resolveAll(context?: DyNTS_ScopedConfigResolveContext): Promise<{ [key: string]: DyNTS_ScopedConfigResolvedValue }> {
-    const records: DyNTS_ScopedConfig[] = await this.loadEffectiveRecords(context);
-    const result: { [key: string]: DyNTS_ScopedConfigResolvedValue } = {};
-    const keys: Set<string> = new Set<string>(records.map((record) => record.key));
-
-    for (const key of keys) {
-      result[key] = this.resolveFromRecords(key, records, context);
-    }
-
-    return result;
-  }
-
-  /**
-   * A `resolve` mag (memóriában, a betöltött rekord-halmazon). Külön metódus, hogy a `resolveAll` is
-   * ezt használja (egyetlen Mongo-kör után minden kulcsra). A `builtinDefault` a hívó fallback-je.
-   */
-  private resolveFromRecords<T = DyNTS_ScopedConfigValue>(
-    key: string,
-    records: DyNTS_ScopedConfig[],
-    context?: DyNTS_ScopedConfigResolveContext,
-    builtinDefault?: T,
-  ): DyNTS_ScopedConfigResolvedValue<T> {
-    const table: string | undefined = context?.table;
-    const scopePath = context?.scopePath ?? [];
-
-    // 1. SCOPE szint — a scopePath levéből a gyökér felé (leaf→root); az első találat nyer.
-    if (table && scopePath.length) {
-      for (let i = scopePath.length - 1; i >= 0; i--) {
-        const scopeId: string = scopePath[i].scopeId;
-        const hit: DyNTS_ScopedConfig | undefined = records.find((record) =>
-          record.level === DyNTS_ScopedConfig_Level.scope &&
-          record.tableScope === table &&
-          record.scopeId === scopeId &&
-          record.key === key,
-        );
-
-        if (hit) {
-          return this.toResolved<T>(hit, 'scope');
-        }
-      }
-    }
-
-    // 2. TABLE szint.
-    if (table) {
-      const hit: DyNTS_ScopedConfig | undefined = records.find((record) =>
-        record.level === DyNTS_ScopedConfig_Level.table &&
-        record.tableScope === table &&
-        record.key === key,
-      );
-
-      if (hit) {
-        return this.toResolved<T>(hit, 'table');
-      }
-    }
-
-    // 3. GLOBAL szint.
-    const globalHit: DyNTS_ScopedConfig | undefined = records.find((record) =>
-      record.level === DyNTS_ScopedConfig_Level.global && record.key === key,
-    );
-
-    if (globalHit) {
-      return this.toResolved<T>(globalHit, 'global');
-    }
-
-    // 4. builtinDefault (a hívó fallback-je; a bedrock NEM tart katalógust).
-    return {
-      value: builtinDefault,
-      resolvedFrom: 'builtin',
-    };
-  }
-
-  /** Egy DB-rekordot a feloldott-érték shape-re (a forrás-szinttel + audittal). */
-  private toResolved<T = DyNTS_ScopedConfigValue>(
-    record: DyNTS_ScopedConfig,
-    resolvedFrom: DyNTS_ScopedConfigResolvedFrom,
-  ): DyNTS_ScopedConfigResolvedValue<T> {
-    return {
-      value: record.value as T,
-      resolvedFrom: resolvedFrom,
-      scopeId: record.scopeId,
-      setBy: record.setBy,
-      setByDetail: record.setByDetail,
-    };
-  }
-
-  /**
-   * A kontextusra releváns aktív rekordok betöltése EGY Mongo-körrel, cache-elve. A filter a global +
-   * (ha van) table + a scopePath összes scopeId-jára szűkít — a merge memóriában fut. `set` invalidál.
-   */
-  private async loadEffectiveRecords(context?: DyNTS_ScopedConfigResolveContext): Promise<DyNTS_ScopedConfig[]> {
-    const cacheKey: string = this.cacheKey(context);
-    const cached: DyNTS_ScopedConfigCacheEntry | undefined = this.cache.get(cacheKey);
-
-    if (cached && cached.expiresAt > Date.now()) {
-      return cached.records;
-    }
-
-    const orClauses: DyFM_DBFilterSimple<DyNTS_ScopedConfig>[] = [{ level: DyNTS_ScopedConfig_Level.global }];
-
-    if (context?.table) {
-      orClauses.push({ level: DyNTS_ScopedConfig_Level.table, tableScope: context.table });
-      const scopeIds: string[] = (context.scopePath ?? []).map((ref) => ref.scopeId);
-
-      if (scopeIds.length) {
-        orClauses.push({ level: DyNTS_ScopedConfig_Level.scope, tableScope: context.table, scopeId: { $in: scopeIds } });
-      }
-    }
-
-    const dataService: DyNTS_ScopedConfig_DataService = new DyNTS_ScopedConfig_DataService({ issuer: this.issuer });
-    const records: DyNTS_ScopedConfig[] = await dataService.findActiveList({ $or: orClauses });
-
-    this.cache.set(cacheKey, { records: records, expiresAt: Date.now() + this.cacheTtlMs });
-
-    return records;
-  }
-
-  /** A cache-kulcs egy kontextus-szeletre (table + a scopePath scopeId-lánca). */
-  private cacheKey(context?: DyNTS_ScopedConfigResolveContext): string {
-    const table: string = context?.table ?? '-';
-    const scopeIds: string = (context?.scopePath ?? []).map((ref) => ref.scopeId).join('>') || '-';
-
-    return `${table}|${scopeIds}`;
-  }
-
-  /** A teljes cache invalidálása (`set` után). */
-  invalidateCache(): void {
-    this.cache.clear();
-  }
-
-  /** A cache TTL felülírása (ms); a fogyasztó hangolhatja (pl. a saját `reference.cacheTtlMs`-éből). */
-  setCacheTtlMs(ttlMs: number): void {
-    this.cacheTtlMs = ttlMs;
-  }
-
-  // =========================================================================
-  // SET — archive-old-active → write-new → invalidate cache
-  // =========================================================================
-
-  /**
-   * Egy config-érték beállítása egy adott szinten (BFR-AM-004). A `set`:
-   * (1) az ugyanazon `(level,tableScope,scopeId,key)` kulcson lévő AKTÍV régi rekordot soft-delete-eli
-   *     (archív → history), (2) az új aktív rekordot kiírja (a `value` Mixed), (3) invalidálja a cache-t.
-   *
-   * **Domain-agnosztikus:** NINCS típus-/tartomány-validáció (az a fogyasztó katalógusának dolga); a
-   * bedrock csak a feloldási-kulcs konzisztenciáját biztosítja (table-/scope-szinten a megfelelő
-   * scope-azonosító jelenléte kötelező).
-   */
-  async set(
-    level: DyNTS_ScopedConfig_Level,
-    key: string,
-    value: unknown,
-    options: DyNTS_ScopedConfigSetOptions = {},
-  ): Promise<DyNTS_ScopedConfig> {
-    this.assertLevelConsistency(level, key, options);
-
-    const issuer: string = options.issuer ?? this.issuer;
-    const filter: DyFM_DBFilterSimple<DyNTS_ScopedConfig> =
-      DyNTS_ScopedConfig_DataService.levelKeyFilter(level, key, options);
-
-    // Régi aktív rekord (ha van) → soft-delete (archív; history-megőrzés).
-    const findService: DyNTS_ScopedConfig_DataService = new DyNTS_ScopedConfig_DataService({ issuer: issuer });
-    const existing: DyNTS_ScopedConfig = await findService.findActive(filter);
-
-    if (existing && existing._id) {
-      await findService.deleteData(existing._id);
-    }
-
-    // Új aktív rekord — a `value` Mixed.
-    const record: DyNTS_ScopedConfig = new DyNTS_ScopedConfig({
-      level: level,
-      tableScope: options.tableScope,
-      scopeId: options.scopeId,
-      key: key,
-      value: value,
-      setBy: options.setBy ?? 'system',
-      setByDetail: options.setByDetail,
-      note: options.note,
-    });
-    const writeService: DyNTS_ScopedConfig_DataService = new DyNTS_ScopedConfig_DataService({ data: record, issuer: issuer });
-    const saved: DyNTS_ScopedConfig = await writeService.saveData(record);
-
-    this.invalidateCache();
-
-    return saved;
-  }
-
-  /**
-   * A feloldási-kulcs minimál-konzisztenciája (NEM domain-validáció): table-/scope-szinten kötelező a
-   * `tableScope`, scope-szinten a `scopeId`. Ezek nélkül a feloldási-kulcs értelmetlen lenne.
-   */
-  private assertLevelConsistency(level: DyNTS_ScopedConfig_Level, key: string, options: DyNTS_ScopedConfigSetOptions): void {
-    if ((level === DyNTS_ScopedConfig_Level.table || level === DyNTS_ScopedConfig_Level.scope) && !options.tableScope) {
-      throw new Error(`DyNTS_ScopedConfig: '${key}' '${level}' szintű beállításához kötelező a tableScope.`);
-    }
-
-    if (level === DyNTS_ScopedConfig_Level.scope && !options.scopeId) {
-      throw new Error(`DyNTS_ScopedConfig: '${key}' 'scope' szintű beállításához kötelező a scopeId.`);
-    }
-  }
-
-  // =========================================================================
-  // HISTORY — felülírás-history (soft-delete-elt régi rekordok)
-  // =========================================================================
-
-  /**
-   * Egy feloldási-kulcs felülírás-historyja: a soft-delete-elt (archív) régi rekordok az archív
-   * collection-ből. Audit-trail / rollback-alap. (A FOGYASZTÓ presetjei/auditja erre épülhetnek.)
-   */
-  async getHistory(
-    level: DyNTS_ScopedConfig_Level,
-    key: string,
-    options: DyNTS_ScopedConfigSetOptions = {},
-  ): Promise<DyNTS_ScopedConfig[]> {
-    const filter: DyFM_DBFilterSimple<DyNTS_ScopedConfig> =
-      DyNTS_ScopedConfig_DataService.levelKeyFilter(level, key, options);
-    const dataService: DyNTS_ScopedConfig_DataService = new DyNTS_ScopedConfig_DataService({ issuer: options.issuer ?? this.issuer });
-
-    return dataService.getArchiveDataService().findDataList(filter, true);
-  }
-}