@futdevpro/nts-dynamo 1.15.58 → 1.15.64

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

@@ -4,7 +4,7 @@ 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 } from '../_models/data-models/dynts-scoped-config.data-model';
 import { DyNTS_ScopedConfig_DataService } from './dynts-scoped-config.data-service';
 
 /**
@@ -20,6 +20,7 @@ describe('| DyNTS_ScopedConfig_DataService', () => {
     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,
@@ -28,7 +29,7 @@ describe('| DyNTS_ScopedConfig_DataService', () => {
   });
 
   beforeEach(() => {
-    mockDBService = jasmine.createSpyObj('DyNTS_DBService', ['find', 'findOne']);
+    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);
@@ -37,7 +38,7 @@ describe('| DyNTS_ScopedConfig_DataService', () => {
   describe('| constructor', () => {
 
     it('| should create the service with a data model', () => {
-      const data: DyNTS_ScopedConfig_DataModel = new DyNTS_ScopedConfig_DataModel({
+      const data: DyNTS_ScopedConfig = new DyNTS_ScopedConfig({
         level: DyNTS_ScopedConfig_Level.global,
         key: 'read.topK',
         value: 5,
@@ -57,7 +58,7 @@ describe('| DyNTS_ScopedConfig_DataService', () => {
         new DyNTS_ScopedConfig_DataService({ issuer: 'issuer-123' });
 
       expect(service).toBeInstanceOf(DyNTS_ScopedConfig_DataService);
-      expect(service.data).toBeInstanceOf(DyNTS_ScopedConfig_DataModel);
+      expect(service.data).toBeInstanceOf(DyNTS_ScopedConfig);
     });
   });
 
@@ -69,15 +70,16 @@ describe('| DyNTS_ScopedConfig_DataService', () => {
 
       const updateSpy = spyOn(service, 'updateData').and.returnValue(Promise.resolve());
 
-      await service.setValue('rec-id', ['a', 'b'], { setBy: 'cli', setByDetail: 'user-x' });
+      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.value).toEqual([ 'a', 'b' ]);
       expect(arg.update.$set.setBy).toBe('cli');
       expect(arg.update.$set.setByDetail).toBe('user-x');
     });
@@ -89,6 +91,7 @@ describe('| DyNTS_ScopedConfig_DataService', () => {
       const filter = DyNTS_ScopedConfig_DataService.levelKeyFilter(
         DyNTS_ScopedConfig_Level.global, 'read.topK', {},
       );
+
       expect(filter).toEqual({ level: DyNTS_ScopedConfig_Level.global, key: 'read.topK' });
     });
 
@@ -96,6 +99,7 @@ describe('| DyNTS_ScopedConfig_DataService', () => {
       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',
@@ -107,6 +111,7 @@ describe('| DyNTS_ScopedConfig_DataService', () => {
       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',

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

@@ -5,8 +5,8 @@ import { DyNTS_ArchiveDataService } from '../../../_services/base/archive-data.s
 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,
+  DyNTS_ScopedConfig,
+  DyNTS_scopedConfig_dataParams
 } from '../_models/data-models/dynts-scoped-config.data-model';
 
 /**
@@ -22,17 +22,17 @@ import {
  * 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> {
+export class DyNTS_ScopedConfig_DataService extends DyNTS_DataService<DyNTS_ScopedConfig> {
 
   constructor(
     set: {
-      data?: DyNTS_ScopedConfig_DataModel,
+      data?: DyNTS_ScopedConfig,
       issuer: string,
     },
   ) {
     super(
-      set.data instanceof DyNTS_ScopedConfig_DataModel ? set.data : new DyNTS_ScopedConfig_DataModel(set.data),
-      dyNTS_scopedConfig_dataParams,
+      set.data instanceof DyNTS_ScopedConfig ? set.data : new DyNTS_ScopedConfig(set.data),
+      DyNTS_scopedConfig_dataParams,
       set.issuer,
     );
   }
@@ -41,10 +41,10 @@ export class DyNTS_ScopedConfig_DataService extends DyNTS_DataService<DyNTS_Scop
    * 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>(
+  override getArchiveDataService(): DyNTS_ArchiveDataService<DyNTS_ScopedConfig> {
+    return new DyNTS_ArchiveDataService<DyNTS_ScopedConfig>(
       this.data,
-      dyNTS_scopedConfig_dataParams,
+      DyNTS_scopedConfig_dataParams,
       this.issuer,
     );
   }
@@ -53,14 +53,14 @@ export class DyNTS_ScopedConfig_DataService extends DyNTS_DataService<DyNTS_Scop
    * 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> {
+  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_DataModel>): Promise<DyNTS_ScopedConfig_DataModel[]> {
+  async findActiveList(filter: DyFM_DBFilter<DyNTS_ScopedConfig>): Promise<DyNTS_ScopedConfig[]> {
     return this.findDataList(filter, true);
   }
 
@@ -75,7 +75,7 @@ export class DyNTS_ScopedConfig_DataService extends DyNTS_DataService<DyNTS_Scop
     audit: { setBy?: string, setByDetail?: string, note?: string } = {},
   ): Promise<void> {
     await this.updateData({
-      filterBy: { _id: id } as DyFM_DBFilterSimple<DyNTS_ScopedConfig_DataModel>,
+      filterBy: { _id: id },
       update: {
         $set: {
           value: value,
@@ -92,14 +92,17 @@ export class DyNTS_ScopedConfig_DataService extends DyNTS_DataService<DyNTS_Scop
     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 };
+  ): 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/_services/core/global.service.spec.ts

@@ -128,6 +128,23 @@ describe('| DyNTS_GlobalService', () => {
 
       expect(result).toBe(authService);
     });
+
+    it('| should NOT throw and return undefined when auth_settings.optional is true', () => {
+      // Suppress: public / no-auth szerver — a beállítás elnyomja a
+      // "Unique Authentication Service missing!" dobást. A flag-et finally-ben
+      // visszaállítjuk, hogy a randomizált futásban ne szivárogjon más tesztbe.
+      const prev = DyNTS_global_settings.auth_settings?.optional;
+      try {
+        DyNTS_global_settings.auth_settings = { optional: true };
+        let result: DyNTS_AuthService;
+        expect(() => {
+          result = DyNTS_GlobalService.getAuthService();
+        }).not.toThrow();
+        expect(result).toBeUndefined();
+      } finally {
+        DyNTS_global_settings.auth_settings = { optional: prev ?? false };
+      }
+    });
   });
 
   describe('| getDBServiceCollection', () => {

package/src/_services/core/global.service.ts

@@ -212,7 +212,10 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
   private static async setAuthService(authService?: DyNTS_AuthService): Promise<void> {
     try {
       if (!authService) {
-        DyFM_Log.warn(`Authentication Service missing!`);
+        // Opcionális auth-service esetén ez VÁRT (public / no-auth szerver) — nincs warn.
+        if (!DyNTS_global_settings.auth_settings?.optional) {
+          DyFM_Log.warn(`Authentication Service missing!`);
+        }
       } else {
         this.instance.authService = authService;
       }
@@ -300,16 +303,27 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
    */
   static getAuthService(): DyNTS_AuthService {
     if (!this.instance?.authService) {
+      // Ha az app explicit opcionálisnak jelölte az auth-service-t
+      // (DyNTS_global_settings.auth_settings.optional), NEM dobunk: undefined-ot
+      // adunk vissza. A hívók (pl. a request-path issuer-kinyerés) optional-
+      // chaining-gel kezelik. Public / no-auth szervereknek — így a
+      // "Unique Authentication Service missing!" hiba suppress-elhető beállításból.
+      if (DyNTS_global_settings.auth_settings?.optional) {
+        return undefined;
+      }
+
       throw new Error(
-        `\n  Unique Authentication Service missing!` + 
-        `\n    Please create a Unique Authentication Service extending DyNTS_AuthService, ` + 
+        `\n  Unique Authentication Service missing!` +
+        `\n    Please create a Unique Authentication Service extending DyNTS_AuthService, ` +
         `\n      and Setup with DyNTS_GlobalServiceC.setServices(...)` +
         '\n    (If you set the globalErrorHandler, ' +
-          'please check if it is using the same node_modules as the app)',
+          'please check if it is using the same node_modules as the app)' +
+        '\n    (To run WITHOUT an auth service, set ' +
+          'DyNTS_global_settings.auth_settings.optional = true)',
       );
     }
 
-    return this.instance.authService;      
+    return this.instance.authService;
   }
 
   /**

package/src/_services/server/app.server.ts

@@ -29,6 +29,7 @@ import {
 import { DyNTS_defaultFallbackCacheMaxAge } from '../../_collections/default-fallback-cache-max-age.const';
 import { DyNTS_defaultNotFoundPageHtml } from '../../_collections/default-not-found-page.const';
 import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { startMongoReconnectGuard } from '../../_collections/mongo-reconnect-guard.util';
 import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
 import { DyNTS_App_Params } from '../../_models/control-models/app-params.control-model';
 import {
@@ -985,10 +986,30 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
     } catch (error) {
       throw new DyFM_Error({
         ...this._getDefaultErrorSettings('startDB', error),
-        
+
         errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-SDB0`,
       });
     }
+
+    // 2026-06-20 — Mongo reconnect-guard. A MongoDB-driver a hostnevet connect-kor EGYSZER
+    // resolválja + cache-eli az IP-t; ha a Mongo-konténert recreate-elik (új docker-network IP),
+    // a driver a HALOTT IP-n ragad → ECONNREFUSED + buffering-timeout, és a service magától SOHA
+    // nem áll vissza. A guard sustained-disconnect (readyState !== 1) esetén — a driver saját
+    // grace-e UTÁN — TELJES disconnect()+connect()-et csinál → ÚJ MongoClient → ÚJ DNS-resolve →
+    // új IP → reconnect. Best-effort, always-on, healthy connection-t (===1) SOHA nem bánt; csak
+    // konténer-IP-frissítés, nem ír adatot. Lásd: mongo-reconnect-guard.util.ts.
+    try {
+      startMongoReconnectGuard({
+        getReadyState: (): number => this.mongoose.connection.readyState,
+        reconnect: async (): Promise<void> => {
+          await this.mongoose.disconnect().catch((): void => undefined);
+          await this.mongoose.connect(this._params.dbUri, this._params.dbOptions);
+        },
+        log: (msg: string): void => DyFM_Log.warn(msg),
+      });
+    } catch (guardErr) {
+      DyFM_Log.warn(`[mongo-reconnect-guard] failed to start (non-fatal): ${guardErr instanceof Error ? guardErr.message : String(guardErr)}`);
+    }
   }
 
   /**