@futdevpro/nts-dynamo 1.15.60 → 1.15.64

package/src/_collections/global-settings.const.ts

@@ -54,6 +54,13 @@ export const DyNTS_global_settings: DyNTS_Global_Settings = {
 
   autoResearchIssues: true,
 
+  // Auth-service kötelező alapból (régi viselkedés). Public / no-auth szervereknél
+  // `auth_settings.optional = true` → getAuthService() undefined-ot ad dobás helyett,
+  // és a startup 'Authentication Service missing!' warn is elmarad.
+  auth_settings: {
+    optional: false,
+  },
+
   bot_settings: null,
 
   openAi_settings: null,

package/src/_collections/mongo-reconnect-guard.util.spec.ts

@@ -0,0 +1,52 @@
+import { shouldForceMongoReconnect, MongoReconnectState } from './mongo-reconnect-guard.util';
+
+/**
+ * A Mongo reconnect-guard PURE döntés-magjának unit-tesztjei. A helyesség kritikus, mert ez dönti
+ * el, hogy egy futó service force-reconnectolja-e a Mongo-kapcsolatát (disconnect+connect →
+ * re-resolve). Healthy connection-t SOHA nem szabad bántani; csak tartós nem-connected + grace +
+ * cooldown letelt esetén szabad force-reconnectolni.
+ */
+describe('| mongo-reconnect-guard shouldForceMongoReconnect', () => {
+  const base: MongoReconnectState = {
+    readyState: 0,
+    msSinceUnhealthy: 60_000,         // 60s unhealthy (a 30s grace fölött)
+    unhealthyGraceMs: 30_000,
+    reconnectInFlight: false,
+    msSinceLastReconnect: Number.POSITIVE_INFINITY,
+    reconnectCooldownMs: 20_000,
+  };
+
+  it('| connected (readyState=1) → SOHA nem reconnect (a healthy connection-t nem bántjuk)', () => {
+    expect(shouldForceMongoReconnect({ ...base, readyState: 1 }).reconnect).toBe(false);
+  });
+
+  it('| connecting (readyState=2) → nem reconnect (hagyjuk a drivert befejezni)', () => {
+    expect(shouldForceMongoReconnect({ ...base, readyState: 2 }).reconnect).toBe(false);
+  });
+
+  it('| disconnected + grace + cooldown letelt + nincs in-flight → RECONNECT', () => {
+    const d = shouldForceMongoReconnect({ ...base, readyState: 0 });
+    expect(d.reconnect).toBe(true);
+    expect(d.reason).toContain('re-resolve');
+  });
+
+  it('| disconnecting (readyState=3) ugyanígy → RECONNECT (tartós nem-connected)', () => {
+    expect(shouldForceMongoReconnect({ ...base, readyState: 3 }).reconnect).toBe(true);
+  });
+
+  it('| grace-en BELÜL → nem reconnect (hagyjuk a driver saját reconnect-jét előbb)', () => {
+    expect(shouldForceMongoReconnect({ ...base, msSinceUnhealthy: 10_000 }).reconnect).toBe(false);
+  });
+
+  it('| cooldown-on belül (frissen reconnectoltunk) → nem reconnect (anti-thrash)', () => {
+    expect(shouldForceMongoReconnect({ ...base, msSinceLastReconnect: 5_000 }).reconnect).toBe(false);
+  });
+
+  it('| már van in-flight reconnect → nem indítunk másikat', () => {
+    expect(shouldForceMongoReconnect({ ...base, reconnectInFlight: true }).reconnect).toBe(false);
+  });
+
+  it('| pontosan a grace-küszöbön (msSinceUnhealthy === grace) → RECONNECT', () => {
+    expect(shouldForceMongoReconnect({ ...base, msSinceUnhealthy: 30_000, unhealthyGraceMs: 30_000 }).reconnect).toBe(true);
+  });
+});

package/src/_collections/mongo-reconnect-guard.util.ts

@@ -0,0 +1,172 @@
+import { DyFM_Log, second } from '@futdevpro/fsm-dynamo';
+
+/**
+ * DyNTS Mongo reconnect-guard (2026-06-20) — TÚLÉLI a Mongo-konténer IP-VÁLTÁSÁT.
+ *
+ * PROBLÉMA (élőben, 2026-06-19): a MongoDB-driver a hostnevet (`mongodb`) connect-kor EGYSZER
+ * resolválja és cache-eli az IP-t (pl. 172.18.0.20); standalone-nál disconnect után UGYANAZT az
+ * IP-t pingeli, NEM re-resolve-ol. Ha a Mongo-konténert recreate-elik (új docker-network IP), a
+ * driver örökre a HALOTT IP-n lóg → `connect ECONNREFUSED <oldIp>:29017` + `buffering timed out`,
+ * és a service magától SOHA nem áll vissza (csak külső restart-tal). Ez a 2026-06-19 incidens fél
+ * test-stacket levitt (auth/ftp/helocia/futdevpro/… mind a régi Mongo-IP-n ragadt).
+ *
+ * MEGOLDÁS: a guard figyeli a `mongoose.connection.readyState`-et; ha TARTÓSAN nem-connected
+ * (a driver saját reconnect-grace-e UTÁN is), **TELJES `disconnect()` + `connect()`-et** csinál
+ * → ÚJ MongoClient → ÚJ DNS-resolve → új IP → reconnect. Így minden DyNTS_App-service magától
+ * túléli a Mongo IP-váltását, KÜLSŐ beavatkozás nélkül. Best-effort, sose dob; csak konténer-IP-
+ * frissítés, NEM törli/írja az adatot.
+ *
+ * SAFE always-on: egy app újracsatlakozása a SAJÁT DB-jéhez korrekt, nem-destruktív viselkedés
+ * (nincs az infra-restart-érzékenység, ami a külső watchdog-oknál — FR-229/237). Csak akkor
+ * avatkozik be, ha readyState !== 1 a grace + cooldown letelte UTÁN is; healthy connection-t (===1)
+ * SOHA nem bánt.
+ *
+ * A döntés-mag (`shouldForceMongoReconnect`) PURE + unit-tesztelt; a futtató injektált dep-ekkel
+ * dolgozik (readyState-olvasás / reconnect / log) a tesztelhetőségért.
+ */
+
+/** A pure döntés inputja (minden numerikus → determinisztikus + tesztelhető). */
+export interface MongoReconnectState {
+  /** mongoose.connection.readyState: 0=disconnected, 1=connected, 2=connecting, 3=disconnecting. */
+  readyState: number;
+  /** Mióta (ms) nem-connected a readyState (0, ha épp connected). */
+  msSinceUnhealthy: number;
+  /** Grace: ennyi ideig hagyjuk a drivert SAJÁT magát visszahozni, mielőtt force-reconnectolnánk. */
+  unhealthyGraceMs: number;
+  /** Épp folyamatban van-e már egy force-reconnect (ne torlódjon). */
+  reconnectInFlight: boolean;
+  /** Mióta (ms) volt az utolsó force-reconnect (Infinity, ha még nem volt). */
+  msSinceLastReconnect: number;
+  /** Két force-reconnect közti minimum (anti-thrash). */
+  reconnectCooldownMs: number;
+}
+
+/** A pure döntés eredménye. */
+export interface MongoReconnectDecision {
+  reconnect: boolean;
+  reason: string;
+}
+
+/**
+ * PURE döntés: kell-e force-reconnect. Healthy (===1) / connecting (===2) / in-flight / grace-en
+ * vagy cooldown-on belül → NEM. Csak tartós nem-connected (disconnected/disconnecting) + grace és
+ * cooldown letelt + nincs in-flight → IGEN.
+ */
+export function shouldForceMongoReconnect(s: MongoReconnectState): MongoReconnectDecision {
+  if (s.readyState === 1) {
+    return { reconnect: false, reason: 'connected (readyState=1)' };
+  }
+  if (s.readyState === 2) {
+    return { reconnect: false, reason: 'connecting (readyState=2) — letting the driver finish' };
+  }
+  if (s.reconnectInFlight) {
+    return { reconnect: false, reason: 'a force-reconnect is already in flight' };
+  }
+  if (s.msSinceUnhealthy < s.unhealthyGraceMs) {
+    return {
+      reconnect: false,
+      reason: `unhealthy for ${Math.round(s.msSinceUnhealthy / 1000)}s (< ${Math.round(s.unhealthyGraceMs / 1000)}s grace) — letting the driver self-heal first`,
+    };
+  }
+  if (s.msSinceLastReconnect < s.reconnectCooldownMs) {
+    return {
+      reconnect: false,
+      reason: `last force-reconnect ${Math.round(s.msSinceLastReconnect / 1000)}s ago (< ${Math.round(s.reconnectCooldownMs / 1000)}s cooldown)`,
+    };
+  }
+  return {
+    reconnect: true,
+    reason: `Mongo connection unhealthy (readyState=${s.readyState}) for ${Math.round(s.msSinceUnhealthy / 1000)}s past grace — forcing disconnect+connect to re-resolve the host IP`,
+  };
+}
+
+/** Injektált függőségek a futtatóhoz (best-effort; a futtató sose dob). */
+export interface MongoReconnectGuardDeps {
+  /** A jelenlegi `mongoose.connection.readyState`. */
+  getReadyState: () => number;
+  /**
+   * Force-reconnect: `disconnect()` majd `connect(uri, opts)` — ÚJ MongoClient → ÚJ DNS-resolve.
+   * Dobhat (a connect elbukhat, ha a Mongo épp tényleg down) — a futtató elkapja.
+   */
+  reconnect: () => Promise<void>;
+  /** Log. */
+  log: (msg: string) => void;
+  /** Tick-intervallum (ms). Default 10s. */
+  intervalMs?: number;
+  /** Grace, amíg a driver saját reconnect-jét várjuk (ms). Default 30s. */
+  unhealthyGraceMs?: number;
+  /** Cooldown két force-reconnect közt (ms). Default 20s. */
+  reconnectCooldownMs?: number;
+}
+
+/**
+ * Elindítja a periodikus reconnect-guard-ot. A visszaadott függvény leállítja (teszt/teardown).
+ * `.unref()` — nem tartja életben az event-loop-ot.
+ */
+export function startMongoReconnectGuard(deps: MongoReconnectGuardDeps): () => void {
+  const intervalMs: number = deps.intervalMs ?? 10 * second;
+  const unhealthyGraceMs: number = deps.unhealthyGraceMs ?? 30 * second;
+  const reconnectCooldownMs: number = deps.reconnectCooldownMs ?? 20 * second;
+
+  let unhealthySinceMs: number | null = null;
+  let lastReconnectAtMs: number | null = null;
+  let inFlight: boolean = false;
+  let ticking: boolean = false;
+
+  const tick = async (): Promise<void> => {
+    if (ticking) { return; }
+    ticking = true;
+    try {
+      const nowMs: number = Date.now();
+      const readyState: number = deps.getReadyState();
+
+      if (readyState === 1) {
+        if (unhealthySinceMs !== null) {
+          deps.log(`[mongo-reconnect-guard] Mongo connection healthy again (was unhealthy ${Math.round((nowMs - unhealthySinceMs) / 1000)}s)`);
+        }
+        unhealthySinceMs = null;
+        return;
+      }
+
+      // Nem-connected: indítsuk/folytassuk az unhealthy-órát.
+      if (unhealthySinceMs === null) { unhealthySinceMs = nowMs; }
+
+      const decision: MongoReconnectDecision = shouldForceMongoReconnect({
+        readyState: readyState,
+        msSinceUnhealthy: nowMs - unhealthySinceMs,
+        unhealthyGraceMs: unhealthyGraceMs,
+        reconnectInFlight: inFlight,
+        msSinceLastReconnect: lastReconnectAtMs === null ? Number.POSITIVE_INFINITY : nowMs - lastReconnectAtMs,
+        reconnectCooldownMs: reconnectCooldownMs,
+      });
+
+      if (!decision.reconnect) { return; }
+
+      deps.log(`[mongo-reconnect-guard] ${decision.reason}`);
+      inFlight = true;
+      lastReconnectAtMs = nowMs;
+      try {
+        await deps.reconnect();
+        deps.log('[mongo-reconnect-guard] force-reconnect dispatched ✓ (re-resolved host; awaiting connection open)');
+      } catch (e: unknown) {
+        // A connect elbukhat, ha a Mongo épp tényleg elérhetetlen — nem baj, a következő tick
+        // (cooldown után) újrapróbál; amint a Mongo új IP-n elérhető, a re-resolve becsatlakozik.
+        deps.log(`[mongo-reconnect-guard] force-reconnect attempt failed (will retry after cooldown): ${e instanceof Error ? e.message : String(e)}`);
+      } finally {
+        inFlight = false;
+      }
+    } catch (e: unknown) {
+      deps.log(`[mongo-reconnect-guard] tick error (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
+    } finally {
+      ticking = false;
+    }
+  };
+
+  const handle: NodeJS.Timeout = setInterval((): void => { void tick(); }, intervalMs);
+  if (typeof handle.unref === 'function') { handle.unref(); }
+  DyFM_Log.info(
+    `[mongo-reconnect-guard] started — check every ${Math.round(intervalMs / 1000)}s, `
+    + `force disconnect+reconnect after ${Math.round(unhealthyGraceMs / 1000)}s sustained-unhealthy (re-resolves host IP), cooldown ${Math.round(reconnectCooldownMs / 1000)}s`,
+  );
+  return (): void => { clearInterval(handle); };
+}

package/src/_models/interfaces/global-settings.interface.ts

@@ -122,6 +122,28 @@ export interface DyNTS_Global_Settings {
    */
   assistant_settings?: any;
 
+  /**
+   * Auth-service beállítások.
+   *
+   * Ha `optional: true`, a framework NEM követeli meg az egyedi Auth Service-t:
+   * a {@link DyNTS_GlobalService.getAuthService} hiányzó service esetén `undefined`-ot
+   * ad vissza a `"Unique Authentication Service missing!"` hiba DOBÁSA HELYETT, és
+   * a startup-warn ('Authentication Service missing!') is elmarad. Public / no-auth
+   * szervereknek (pl. nyílt RAG/MCP backend), ahol nincs saját auth-réteg.
+   *
+   * Default: `{ optional: false }` — az auth-service kötelező (visszafelé kompatibilis,
+   * a régi viselkedés: hiányzó service → dobott hiba).
+   */
+  auth_settings?: {
+    /**
+     * Ha `true`, az Auth Service opcionális: `getAuthService()` NEM dob hiányzó
+     * service esetén, hanem `undefined`-ot ad vissza (a hívók optional-chaining-gel
+     * kezelik), és a startup 'Authentication Service missing!' warn is elmarad.
+     * Default: `false`.
+     */
+    optional?: boolean;
+  };
+
   /**
    * this setting will set the doc chunking settings
    */

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)}`);
+    }
   }
 
   /**