@futdevpro/nts-dynamo 1.15.156 → 1.15.160

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

@@ -1,123 +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_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 = new DyNTS_ScopedConfig({
-        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);
-    });
-  });
-
-  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

@@ -1,108 +0,0 @@
-
-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,
-  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> {
-
-  constructor(
-    set: {
-      data?: DyNTS_ScopedConfig,
-      issuer: string,
-    },
-  ) {
-    super(
-      set.data instanceof DyNTS_ScopedConfig ? set.data : new DyNTS_ScopedConfig(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> {
-    return new DyNTS_ArchiveDataService<DyNTS_ScopedConfig>(
-      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>): Promise<DyNTS_ScopedConfig> {
-    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>): Promise<DyNTS_ScopedConfig[]> {
-    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 },
-      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> {
-    const filter: DyFM_DBFilterSimple<DyNTS_ScopedConfig> = { 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

@@ -1,17 +0,0 @@
-
-
-// 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';

package/src/_modules/server/errors/errors.control-service.spec.ts

@@ -1,246 +0,0 @@
-
-import { DyNTS_Errors_ControlService } from './errors.control-service';
-import { DyFM_Error, DyFM_Errors, DyFM_ErrorLevel, DyFM_RelativeDate, DyFM_Paged, DyFM_SearchQuery, DyFM_SearchResult } from '@futdevpro/fsm-dynamo';
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-
-class TestError extends DyFM_Error {
-  constructor(set?: Partial<TestError>) {
-    super(set);
-    Object.assign(this, set);
-  }
-}
-
-class TestErrors extends DyFM_Errors<TestError> {
-  constructor(set?: Partial<TestErrors>) {
-    super(set);
-    Object.assign(this, set);
-  }
-}
-
-class TestErrorsControlService extends DyNTS_Errors_ControlService<TestError, TestErrors> {
-  async recordError(data: TestErrors, issuer: string, alwaysRecord?: boolean): Promise<void> {
-    // Mock implementation
-  }
-
-  async handleInternalError(error: any, issuer: string, alwaysRecord?: boolean): Promise<void> {
-    // Mock implementation
-  }
-
-  checkErrorIsStringifyableOrResolvable(error: TestError, issuer: string): TestError | 'UNRESOLVABLE' {
-    return error;
-  }
-
-  getPriorityMultiplierByLevel(level: DyFM_ErrorLevel, issuer: string): number {
-    return 1;
-  }
-
-  async getErrorsFromDate(date: Date, issuer: string): Promise<DyFM_Paged<TestErrors>> {
-    return {
-      items: [],
-      total: 0,
-      pageIndex: 0,
-      pageSize: 0,
-    };
-  }
-
-  async deleteError(errorId: string, issuer: string, alwaysDelete?: boolean): Promise<void> {
-    // Mock implementation
-  }
-
-  async deleteAllErrors(issuer: string, alwaysDelete?: boolean): Promise<void> {
-    // Mock implementation
-  }
-
-  async recordFixAttempt(errorId: string, version: string, hypothesis: string, issuer: string): Promise<any> {
-    return { at: new Date(), by: issuer, version, hypothesis };
-  }
-
-  async getErrorsByCategoryPaged(category: string, range: any, pageSize: number, pageIndex: number, issuer: string): Promise<any> {
-    return { items: [], total: 0, pageIndex, pageSize };
-  }
-
-  async resolveError(errorId: string, issuer: string, notes?: string): Promise<void> {
-    return;
-  }
-
-  async getErrorsByStatusPaged(status: string, range: any, pageSize: number, pageIndex: number, issuer: string): Promise<any> {
-    return { items: [], total: 0, pageIndex, pageSize };
-  }
-
-  async getErrorsInRange(range: DyFM_RelativeDate, issuer: string): Promise<DyFM_Paged<TestErrors>> {
-    return {
-      items: [],
-      total: 0,
-      pageIndex: 0,
-      pageSize: 0,
-    };
-  }
-
-  async getErrorsPaged(range: DyFM_RelativeDate, pageSize: number, pageIndex: number, issuer: string): Promise<DyFM_Paged<TestErrors>> {
-    return {
-      items: [],
-      total: 0,
-      pageIndex,
-      pageSize,
-    };
-  }
-
-  async getLastErrors(range: DyFM_RelativeDate, pageSize: number, pageIndex: number, issuer: string): Promise<DyFM_Paged<TestErrors>> {
-    return {
-      items: [],
-      total: 0,
-      pageIndex,
-      pageSize,
-    };
-  }
-
-  async searchErrors(searchQuery: DyFM_SearchQuery<TestErrors>, issuer: string): Promise<DyFM_SearchResult<TestErrors>> {
-    return {
-      results: [],
-      totalItems: 0,
-    };
-  }
-
-  static getInstance(): TestErrorsControlService {
-    return (TestErrorsControlService as any).getSingletonInstance();
-  }
-}
-
-describe('| DyNTS_Errors_ControlService', () => {
-  let service: TestErrorsControlService;
-
-  beforeEach(() => {
-    service = new (TestErrorsControlService as any)();
-  });
-
-  describe('| constructor', () => {
-    it('| should initialize with default values', () => {
-      expect(service.debugLog).toBe(false);
-      expect(service.version).toBe(DyNTS_global_settings.systemVersion);
-      expect(service.duplicationCounter).toBeUndefined();
-    });
-  });
-
-  describe('| properties', () => {
-    it('| should have version property', () => {
-      expect(service.version).toBeDefined();
-      expect(typeof service.version).toBe('string');
-    });
-
-    it('| should have debugLog property', () => {
-      expect(service.debugLog).toBeDefined();
-      expect(typeof service.debugLog).toBe('boolean');
-    });
-  });
-
-  describe('| recordError', () => {
-    it('| should record error', async () => {
-      const errors = new TestErrors({
-        error: new TestError({ _message: 'Test error' }),
-      });
-
-      await service.recordError(errors, 'test-issuer');
-
-      expect(service.recordError).toBeDefined();
-    });
-  });
-
-  describe('| handleInternalError', () => {
-    it('| should handle internal error', async () => {
-      const error = new Error('Internal error');
-
-      await service.handleInternalError(error, 'test-issuer');
-
-      expect(service.handleInternalError).toBeDefined();
-    });
-  });
-
-  describe('| checkErrorIsStringifyableOrResolvable', () => {
-    it('| should check if error is stringifyable', () => {
-      const error = new TestError({ _message: 'Test error' });
-
-      const result = service.checkErrorIsStringifyableOrResolvable(error, 'test-issuer');
-
-      expect(result).toBe(error);
-    });
-  });
-
-  describe('| getPriorityMultiplierByLevel', () => {
-    it('| should return priority multiplier', () => {
-      const result = service.getPriorityMultiplierByLevel(DyFM_ErrorLevel.error, 'test-issuer');
-
-      expect(result).toBe(1);
-    });
-  });
-
-  describe('| getErrorsFromDate', () => {
-    it('| should get errors from date', async () => {
-      const date = new Date();
-      const result = await service.getErrorsFromDate(date, 'test-issuer');
-
-      expect(result).toBeDefined();
-      expect(result.items).toBeDefined();
-      expect(result.total).toBeDefined();
-    });
-  });
-
-  describe('| deleteError', () => {
-    it('| should delete error', async () => {
-      await service.deleteError('error-123', 'test-issuer');
-
-      expect(service.deleteError).toBeDefined();
-    });
-  });
-
-  describe('| deleteAllErrors', () => {
-    it('| should delete all errors', async () => {
-      await service.deleteAllErrors('test-issuer');
-
-      expect(service.deleteAllErrors).toBeDefined();
-    });
-  });
-
-  describe('| getErrorsInRange', () => {
-    it('| should get errors in range', async () => {
-      const result = await service.getErrorsInRange(DyFM_RelativeDate.lastWeek, 'test-issuer');
-
-      expect(result).toBeDefined();
-      expect(result.items).toBeDefined();
-    });
-  });
-
-  describe('| getErrorsPaged', () => {
-    it('| should get errors paged', async () => {
-      const result = await service.getErrorsPaged(DyFM_RelativeDate.lastWeek, 10, 0, 'test-issuer');
-
-      expect(result).toBeDefined();
-      expect(result.items).toBeDefined();
-      expect(result.pageIndex).toBe(0);
-      expect(result.pageSize).toBe(10);
-    });
-  });
-
-  describe('| getLastErrors', () => {
-    it('| should get last errors', async () => {
-      const result = await service.getLastErrors(DyFM_RelativeDate.lastWeek, 10, 0, 'test-issuer');
-
-      expect(result).toBeDefined();
-      expect(result.items).toBeDefined();
-    });
-  });
-
-  describe('| searchErrors', () => {
-    it('| should search errors', async () => {
-      const searchQuery: DyFM_SearchQuery<TestErrors> = {
-        filterBy: {},
-      };
-
-      const result = await service.searchErrors(searchQuery, 'test-issuer');
-
-      expect(result).toBeDefined();
-      expect(result.results).toBeDefined();
-      expect(result.totalItems).toBeDefined();
-    });
-  });
-});
-

package/src/_modules/server/errors/errors.control-service.ts

@@ -1,100 +0,0 @@
-
-
-
-
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_DBUpdate } from '../../../_models/types/db-update.type';
-import { DyNTS_DataService } from '../../../_services/base/data.service';
-
-import {
-  DyFM_AnyError,
-  DyFM_DBFilter,
-  DyFM_DataModel_Params, DyFM_Error, DyFM_ErrorLevel, DyFM_Error_Settings,
-  DyFM_Log, DyFM_Object, DyFM_errorFlag, DyFM_Errors,
-  DyFM_RelativeDate,
-  DyFM_Paged,
-  DyFM_SearchQuery,
-  DyFM_SearchResult,
-  DyFM_Errors_FixAttempt
-} from '@futdevpro/fsm-dynamo';
-
-export abstract class DyNTS_Errors_ControlService<
-  T_Error extends DyFM_Error,
-  T_Errors extends DyFM_Errors<T_Error>
-> {
-  debugLog: boolean = false;
-  readonly version: string = DyNTS_global_settings.systemVersion;
-  duplicationCounter: number;
-
-  abstract recordError(data: T_Errors, issuer: string, alwaysRecord?: boolean): Promise<void>;
-
-  abstract handleInternalError(
-    error: DyFM_AnyError | any, 
-    issuer: string,
-    alwaysRecord?: boolean,
-  ): Promise<void>;
-
-  abstract checkErrorIsStringifyableOrResolvable(error: T_Error, issuer: string): T_Error | 'UNRESOLVABLE';
-
-  abstract getPriorityMultiplierByLevel(level: DyFM_ErrorLevel, issuer: string): number;
-
-  abstract getErrorsFromDate(
-    date: Date,
-    issuer: string,
-  ): Promise<DyFM_Paged<T_Errors>>;
-
-  abstract deleteError(errorId: string, issuer: string, alwaysDelete?: boolean): Promise<void>;
-
-  abstract deleteAllErrors(issuer: string, alwaysDelete?: boolean): Promise<void>;
-
-  abstract recordFixAttempt(
-    errorId: string,
-    version: string,
-    hypothesis: string,
-    issuer: string,
-    notes?: string,
-  ): Promise<DyFM_Errors_FixAttempt>;
-
-  abstract resolveError(
-    errorId: string,
-    issuer: string,
-    notes?: string,
-  ): Promise<void>;
-
-  abstract getErrorsByStatusPaged(
-    status: string,
-    range: DyFM_RelativeDate,
-    pageSize: number,
-    pageIndex: number,
-    issuer: string,
-  ): Promise<DyFM_Paged<T_Errors>>;
-
-  abstract getErrorsInRange(range: DyFM_RelativeDate, issuer: string): Promise<DyFM_Paged<T_Errors>>;
-
-  abstract getErrorsPaged(
-    range: DyFM_RelativeDate,
-    pageSize: number,
-    pageIndex: number,
-    issuer: string,
-  ): Promise<DyFM_Paged<T_Errors>>;
-
-  abstract getErrorsByCategoryPaged(
-    category: string,
-    range: DyFM_RelativeDate,
-    pageSize: number,
-    pageIndex: number,
-    issuer: string,
-  ): Promise<DyFM_Paged<T_Errors>>;
-
-  abstract getLastErrors(
-    range: DyFM_RelativeDate,
-    pageSize: number,
-    pageIndex: number,
-    issuer: string,
-  ): Promise<DyFM_Paged<T_Errors>>;
-
-  abstract searchErrors(
-    searchQuery: DyFM_SearchQuery<T_Errors>,
-    issuer: string,
-  ): Promise<DyFM_SearchResult<T_Errors>>;
-}