@futdevpro/nts-dynamo 1.15.57 → 1.15.58

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

@@ -0,0 +1,118 @@
+
+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_DataModel } from '../_models/data-models/dynts-scoped-config.data-model';
+import { DyNTS_ScopedConfig_DataService } from './dynts-scoped-config.data-service';
+
+/**
+ * BFR-AM-004 — a `DyNTS_ScopedConfig_DataService` spec-jei. A base-ctor eager `getDBService`-jét
+ * stub-oljuk (memory: dynts_dataservice_eager_resolve), így NEM kell élő Mongo. A `setValue`
+ * spec bizonyítja a Mixed-érték ATOMIKUS `$set` írását (memory: mongoose_mixed_atomic_write).
+ */
+describe('| DyNTS_ScopedConfig_DataService', () => {
+
+  let mockDBService: jasmine.SpyObj<{ find: () => Promise<unknown[]>; findOne: () => Promise<unknown> }>;
+
+  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(() => {
+    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);
+  });
+
+  describe('| constructor', () => {
+
+    it('| should create the service with a data model', () => {
+      const data: DyNTS_ScopedConfig_DataModel = new DyNTS_ScopedConfig_DataModel({
+        level: DyNTS_ScopedConfig_Level.global,
+        key: 'read.topK',
+        value: 5,
+      });
+
+      const service: DyNTS_ScopedConfig_DataService =
+        new DyNTS_ScopedConfig_DataService({ data: data, issuer: 'issuer-123' });
+
+      expect(service).toBeInstanceOf(DyNTS_ScopedConfig_DataService);
+      expect(service.data).toBeDefined();
+      expect(service.data.key).toBe('read.topK');
+      expect(service.haveArchiveDataService).toBeTrue();
+    });
+
+    it('| should create the service without data', () => {
+      const service: DyNTS_ScopedConfig_DataService =
+        new DyNTS_ScopedConfig_DataService({ issuer: 'issuer-123' });
+
+      expect(service).toBeInstanceOf(DyNTS_ScopedConfig_DataService);
+      expect(service.data).toBeInstanceOf(DyNTS_ScopedConfig_DataModel);
+    });
+  });
+
+  describe('| setValue — atomic $set (Mongoose Mixed)', () => {
+
+    it('| should issue an updateOne $set for the Mixed value + audit fields', async () => {
+      const service: DyNTS_ScopedConfig_DataService =
+        new DyNTS_ScopedConfig_DataService({ issuer: 'issuer-123' });
+
+      const updateSpy = spyOn(service, 'updateData').and.returnValue(Promise.resolve());
+
+      await service.setValue('rec-id', ['a', 'b'], { setBy: 'cli', setByDetail: 'user-x' });
+
+      expect(updateSpy).toHaveBeenCalledTimes(1);
+      const arg = updateSpy.calls.mostRecent().args[0] as {
+        filterBy: { _id: string };
+        update: { $set: { value: unknown; setBy?: string; setByDetail?: string } };
+      };
+      expect(arg.filterBy._id).toBe('rec-id');
+      expect(arg.update.$set.value).toEqual(['a', 'b']);
+      expect(arg.update.$set.setBy).toBe('cli');
+      expect(arg.update.$set.setByDetail).toBe('user-x');
+    });
+  });
+
+  describe('| levelKeyFilter (static)', () => {
+
+    it('| should build a global filter with only level + key', () => {
+      const filter = DyNTS_ScopedConfig_DataService.levelKeyFilter(
+        DyNTS_ScopedConfig_Level.global, 'read.topK', {},
+      );
+      expect(filter).toEqual({ level: DyNTS_ScopedConfig_Level.global, key: 'read.topK' });
+    });
+
+    it('| should include tableScope for a table filter', () => {
+      const filter = DyNTS_ScopedConfig_DataService.levelKeyFilter(
+        DyNTS_ScopedConfig_Level.table, 'read.topK', { tableScope: 'documents' },
+      );
+      expect(filter).toEqual({
+        level: DyNTS_ScopedConfig_Level.table,
+        key: 'read.topK',
+        tableScope: 'documents',
+      });
+    });
+
+    it('| should include tableScope + scopeId for a scope filter', () => {
+      const filter = DyNTS_ScopedConfig_DataService.levelKeyFilter(
+        DyNTS_ScopedConfig_Level.scope, 'read.topK', { tableScope: 'documents', scopeId: 'leaf' },
+      );
+      expect(filter).toEqual({
+        level: DyNTS_ScopedConfig_Level.scope,
+        key: 'read.topK',
+        tableScope: 'documents',
+        scopeId: 'leaf',
+      });
+    });
+  });
+});

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

@@ -0,0 +1,105 @@
+
+import { DyFM_DBFilter, DyFM_DBFilterSimple } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_ArchiveDataService } from '../../../_services/base/archive-data.service';
+import { DyNTS_DataService } from '../../../_services/base/data.service';
+import { DyNTS_ScopedConfig_Level } from '../_enums/dynts-scoped-config-level.enum';
+import {
+  DyNTS_ScopedConfig_DataModel,
+  dyNTS_scopedConfig_dataParams,
+} from '../_models/data-models/dynts-scoped-config.data-model';
+
+/**
+ * `DyNTS_ScopedConfig_DataService` — a `dynts_scoped_config` collection CRUD + soft-delete history-rétege
+ * (BFR-AM-004). `extends DyNTS_DataService`; `addArchive: true` → a felülírt (régi) értékek
+ * soft-delete-elve megőrződnek (audit-trail). A nts-konvenció szerinti `{ data?, issuer }` constructor.
+ *
+ * **FIGYELEM (memory: dynts_dataservice_eager_resolve):** a `DyNTS_DataService` base-ctor EAGER
+ * `getDBService`-t hív → a control-service NEM tarthat élő data-service-példányt mezőként; minden
+ * művelet előtt lazy `new DyNTS_ScopedConfig_DataService(...)` kell.
+ *
+ * **A `value` írása `$set`-tel atomikus** (Mongoose Mixed silent-drop ellen — memory:
+ * mongoose_mixed_atomic_write): a `findOne→mutate→save` SILENT-DROP-ot ad a Mixed mezőkre, ezért az
+ * érték-frissítést a `setValue` `updateOne({ ... }, { $set: { value } })`-vel végzi.
+ */
+export class DyNTS_ScopedConfig_DataService extends DyNTS_DataService<DyNTS_ScopedConfig_DataModel> {
+
+  constructor(
+    set: {
+      data?: DyNTS_ScopedConfig_DataModel,
+      issuer: string,
+    },
+  ) {
+    super(
+      set.data instanceof DyNTS_ScopedConfig_DataModel ? set.data : new DyNTS_ScopedConfig_DataModel(set.data),
+      dyNTS_scopedConfig_dataParams,
+      set.issuer,
+    );
+  }
+
+  /**
+   * Az archív (soft-delete-elt) rekordokhoz tartozó data-service (a base override-ja). A
+   * `DyNTS_DataService.deleteData` ezen át archiválja a felülírt aktív rekordokat (history).
+   */
+  override getArchiveDataService(): DyNTS_ArchiveDataService<DyNTS_ScopedConfig_DataModel> {
+    return new DyNTS_ArchiveDataService<DyNTS_ScopedConfig_DataModel>(
+      this.data,
+      dyNTS_scopedConfig_dataParams,
+      this.issuer,
+    );
+  }
+
+  /**
+   * Egy adott feloldási-kulcson (`level`+`tableScope`+`scopeId`+`key`) az AKTÍV (nem soft-delete-elt)
+   * rekord. Az aktív rekordon a `_deleted` Date soft-delete marker nincs beállítva.
+   */
+  async findActive(filter: DyFM_DBFilter<DyNTS_ScopedConfig_DataModel>): Promise<DyNTS_ScopedConfig_DataModel> {
+    return this.findData(filter, true);
+  }
+
+  /**
+   * Az adott kontextusra konfigurált ÖSSZES aktív rekord (a `resolveAll` egy Mongo-köre).
+   */
+  async findActiveList(filter: DyFM_DBFilter<DyNTS_ScopedConfig_DataModel>): Promise<DyNTS_ScopedConfig_DataModel[]> {
+    return this.findDataList(filter, true);
+  }
+
+  /**
+   * Egy létező aktív rekord `value`-jának ATOMIKUS frissítése (`$set`). A Mixed mező `findOne→mutate→
+   * save` útján SILENT-DROP-ot adna; a `$set` ezt elkerüli (memory: mongoose_mixed_atomic_write). A
+   * `setBy`/`setByDetail`/`note` audit-mezők is frissülnek.
+   */
+  async setValue(
+    id: string,
+    value: unknown,
+    audit: { setBy?: string, setByDetail?: string, note?: string } = {},
+  ): Promise<void> {
+    await this.updateData({
+      filterBy: { _id: id } as DyFM_DBFilterSimple<DyNTS_ScopedConfig_DataModel>,
+      update: {
+        $set: {
+          value: value,
+          setBy: audit.setBy,
+          setByDetail: audit.setByDetail,
+          note: audit.note,
+        },
+      },
+    });
+  }
+
+  /** A `(level, tableScope, scopeId, key)` feloldási-kulcs filtere (a logikai unique-constraint). */
+  static levelKeyFilter(
+    level: DyNTS_ScopedConfig_Level,
+    key: string,
+    set: { tableScope?: string, scopeId?: string },
+  ): DyFM_DBFilterSimple<DyNTS_ScopedConfig_DataModel> {
+    const filter: DyFM_DBFilterSimple<DyNTS_ScopedConfig_DataModel> = { level: level, key: key };
+    if (level === DyNTS_ScopedConfig_Level.table || level === DyNTS_ScopedConfig_Level.scope) {
+      filter.tableScope = set.tableScope;
+    }
+    if (level === DyNTS_ScopedConfig_Level.scope) {
+      filter.scopeId = set.scopeId;
+    }
+    return filter;
+  }
+}

package/src/_modules/scoped-config/index.ts

@@ -0,0 +1,17 @@
+
+
+// SCOPED-CONFIG MODULE (BFR-AM-004) — DB-backed, domain-agnostic scoped config precedence engine.
+// Precedencia: scope (leaf→root) > table > global > builtinDefault.
+
+// ENUMS
+export * from './_enums/dynts-scoped-config-level.enum';
+
+// INTERFACES
+export * from './_models/interfaces/dynts-scoped-config.interface';
+
+// DATA-MODELS
+export * from './_models/data-models/dynts-scoped-config.data-model';
+
+// SERVICES
+export * from './_services/dynts-scoped-config.data-service';
+export * from './_services/dynts-scoped-config.control-service';