@futdevpro/nts-dynamo 1.15.131 → 1.15.134

package/build/index.js

@@ -48,9 +48,11 @@ tslib_1.__exportStar(require("./_models/interfaces/signed-url-verify-result.inte
 tslib_1.__exportStar(require("./_models/interfaces/static-client-settings.interface"), exports);
 tslib_1.__exportStar(require("./_models/interfaces/cors-settings.interface"), exports);
 tslib_1.__exportStar(require("./_models/interfaces/security-headers-settings.interface"), exports);
+tslib_1.__exportStar(require("./_models/interfaces/app-version-header-settings.interface"), exports);
 tslib_1.__exportStar(require("./_models/interfaces/db-query-options.interface"), exports);
 tslib_1.__exportStar(require("./_models/interfaces/migration-entry.interface"), exports);
 tslib_1.__exportStar(require("./_collections/security-headers.util"), exports);
+tslib_1.__exportStar(require("./_collections/app-version-header.util"), exports);
 tslib_1.__exportStar(require("./_collections/signed-url.util"), exports);
 tslib_1.__exportStar(require("./_collections/client-safe-error.util"), exports);
 tslib_1.__exportStar(require("./_collections/load-shed.util"), exports);

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;;;;;;;;;IAsBI;;;AAEJ,cAAc;AACd,sEAA4C;AAC5C,wFAA8D;AAC9D,8FAAoE;AACpE,sFAA4D;AAC5D,mFAAyD;AACzD,uFAA6D;AAC7D,+EAAqD;AAGrD,QAAQ;AACR,wEAA8C;AAC9C,8EAAoD;AACpD,8EAAoD;AACpD,uEAA6C;AAG7C,6CAA6C;AAE7C,mEAAmE;AACnE,gGAAsE;AACtE,8FAAoE;AACpE,iGAAuE;AACvE,yFAA+D;AAC/D,iGAAuE;AACvE,kGAAwE;AACxE,gGAAsE;AACtE,uFAA6D;AAC7D,mGAAyE;AACzE,0FAAgE;AAChE,yFAA+D;AAC/D,+EAAqD;AACrD,yEAA+C;AAC/C,gFAAsD;AACtD,wEAA8C;AAC9C,mFAAyD;AACzD,kFAAwD;AACxD,4EAAkD;AAClD,+EAAqD;AAErD,wBAAwB;AACxB,iGAAuE;AACvE,yGAA8E;AAC9E,4FAAkE;AAClE,qGAA2E;AAC3E,iGAAuE;AACvE,+FAAqE;AACrE,gGAAsE;AAEtE,eAAe;AACf,yEAA+C;AAE/C,qBAAqB;AACrB,4FAAkE;AAGlE,WAAW;AACX,gBAAgB;AAChB,uEAA6C;AAC7C,wEAA8C;AAE9C,yEAA+C;AAC/C,6FAAmE;AACnE,0EAAgD;AAChD,gFAAsD;AAEtD,sFAA4D;AAC5D,oFAA0D;AAE1D,gBAAgB;AAChB,4EAAkD;AAClD,gFAAsD;AACtD,wEAA8C;AAC9C,sEAA4C;AAC5C,kFAAwD;AACxD,6EAAmD;AAEnD,kBAAkB;AAClB,wEAA8C;AAE9C,iBAAiB;AACjB,+EAAqD;AACrD,mFAAyD;AAEzD,kBAAkB;AAClB,4EAAkD"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;;;;;;;;;IAsBI;;;AAEJ,cAAc;AACd,sEAA4C;AAC5C,wFAA8D;AAC9D,8FAAoE;AACpE,sFAA4D;AAC5D,mFAAyD;AACzD,uFAA6D;AAC7D,+EAAqD;AAGrD,QAAQ;AACR,wEAA8C;AAC9C,8EAAoD;AACpD,8EAAoD;AACpD,uEAA6C;AAG7C,6CAA6C;AAE7C,mEAAmE;AACnE,gGAAsE;AACtE,8FAAoE;AACpE,iGAAuE;AACvE,yFAA+D;AAC/D,iGAAuE;AACvE,kGAAwE;AACxE,gGAAsE;AACtE,uFAA6D;AAC7D,mGAAyE;AACzE,qGAA2E;AAC3E,0FAAgE;AAChE,yFAA+D;AAC/D,+EAAqD;AACrD,iFAAuD;AACvD,yEAA+C;AAC/C,gFAAsD;AACtD,wEAA8C;AAC9C,mFAAyD;AACzD,kFAAwD;AACxD,4EAAkD;AAClD,+EAAqD;AAErD,wBAAwB;AACxB,iGAAuE;AACvE,yGAA8E;AAC9E,4FAAkE;AAClE,qGAA2E;AAC3E,iGAAuE;AACvE,+FAAqE;AACrE,gGAAsE;AAEtE,eAAe;AACf,yEAA+C;AAE/C,qBAAqB;AACrB,4FAAkE;AAGlE,WAAW;AACX,gBAAgB;AAChB,uEAA6C;AAC7C,wEAA8C;AAE9C,yEAA+C;AAC/C,6FAAmE;AACnE,0EAAgD;AAChD,gFAAsD;AAEtD,sFAA4D;AAC5D,oFAA0D;AAE1D,gBAAgB;AAChB,4EAAkD;AAClD,gFAAsD;AACtD,wEAA8C;AAC9C,sEAA4C;AAC5C,kFAAwD;AACxD,6EAAmD;AAEnD,kBAAkB;AAClB,wEAA8C;AAE9C,iBAAiB;AACjB,+EAAqD;AACrD,mFAAyD;AAEzD,kBAAkB;AAClB,4EAAkD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futdevpro/nts-dynamo",
-  "version": "01.15.131",
+  "version": "01.15.134",
   "description": "Dynamic NodeTS (NodeJS-Typescript), MongoDB Backend System Framework by Future Development Program Ltd.",
   "DyBu_settings": {
     "packageType": "server-package",
@@ -378,7 +378,7 @@
     "@anthropic-ai/sdk": "~0.39.0",
     "@modelcontextprotocol/sdk": "~1.29.0",
     "better-sqlite3": "~12.4.1",
-    "@futdevpro/fsm-dynamo": "1.16.34",
+    "@futdevpro/fsm-dynamo": "1.16.37",
     "@types/express": "4.17.21",
     "@types/geoip-lite": "~1.4.1",
     "@types/node": "~24.1.0",

package/src/_collections/app-version-header.util.spec.ts

@@ -0,0 +1,108 @@
+import {
+  DYNTS_APP_VERSION_HEADER,
+  DyNTS_createAppVersionHeaderMiddleware,
+  DyNTS_resolveExposeHeaders,
+} from './app-version-header.util';
+
+/**
+ * FR-292 — a deployolt app-verzió minden válaszon.
+ *
+ * A garanciák, amiket ez a spec ŐRIZ:
+ *  - ISMERETLEN verziónál NINCS header (a `unknown-version` hamis „új verzió"-riasztást adna),
+ *  - a verzió a hívás pillanatában olvasódik (az app-params KÉSŐBB tölti be — egy induláskor
+ *    befagyasztott érték örökre `unknown` maradna),
+ *  - a CORS expose-lista BŐVÜL, nem felülíródik (különben más headerek olvashatatlanná válnának),
+ *  - a bővítés IDEMPOTENS (kétszeri felszerelés nem duplikál).
+ */
+describe('| FR-292 app-version response header', () => {
+
+  /** Minimal Express-válasz stub — csak a header-tárolás kell hozzá. */
+  function makeRes(): { headers: Record<string, string>; setHeader: Function; getHeader: Function } {
+    const headers: Record<string, string> = {};
+    return {
+      headers: headers,
+      setHeader: (name: string, value: string): void => { headers[name] = value; },
+      getHeader: (name: string): string | undefined => headers[name],
+    };
+  }
+
+  describe('| DyNTS_resolveExposeHeaders', () => {
+
+    it('| ures listabol a header neve lesz', () => {
+      expect(DyNTS_resolveExposeHeaders(undefined, 'X-App-Version')).toBe('X-App-Version');
+      expect(DyNTS_resolveExposeHeaders('', 'X-App-Version')).toBe('X-App-Version');
+    });
+
+
+    it('| a MEGLEVO listat megtartja es hozzafuz (nem felulir)', () => {
+      expect(DyNTS_resolveExposeHeaders('Content-Length, Content-Type', 'X-App-Version'))
+        .toBe('Content-Length, Content-Type, X-App-Version');
+    });
+
+
+    it('| idempotens — ha mar benne van, nem duplikal (kis-nagybetu fuggetlenul)', () => {
+      expect(DyNTS_resolveExposeHeaders('Content-Type, X-App-Version', 'X-App-Version'))
+        .toBe('Content-Type, X-App-Version');
+      expect(DyNTS_resolveExposeHeaders('content-type, x-app-version', 'X-App-Version'))
+        .toBe('content-type, x-app-version');
+    });
+  });
+
+
+  describe('| DyNTS_createAppVersionHeaderMiddleware', () => {
+
+    it('| kiirja a verziot ES exposeolja a CORS-nak', () => {
+      const res = makeRes();
+      let nextCalled: boolean = false;
+      DyNTS_createAppVersionHeaderMiddleware((): string => '01.15.460')(
+        {} as never, res as never, ((): void => { nextCalled = true; }) as never,
+      );
+      expect(res.headers[DYNTS_APP_VERSION_HEADER]).toBe('01.15.460');
+      expect(res.headers['Access-Control-Expose-Headers']).toContain(DYNTS_APP_VERSION_HEADER);
+      expect(nextCalled).toBe(true);
+    });
+
+
+    it('| ISMERETLEN verzional nem ir headert — de a lancot TOVABBENGEDI', () => {
+      for (const version of [undefined, '', 'unknown-version']) {
+        const res = makeRes();
+        let nextCalled: boolean = false;
+        DyNTS_createAppVersionHeaderMiddleware((): string | undefined => version)(
+          {} as never, res as never, ((): void => { nextCalled = true; }) as never,
+        );
+        expect(res.headers[DYNTS_APP_VERSION_HEADER]).withContext(String(version)).toBeUndefined();
+        expect(nextCalled).withContext(String(version)).toBe(true);
+      }
+    });
+
+
+    /**
+     * A verziót a HÍVÁSKOR kell olvasni: a `systemVersion` az app-params betöltésekor áll be,
+     * ami a middleware felszerelése UTÁN történik. Ha a middleware befagyasztaná az értéket,
+     * a fejléc örökre hiányozna — pont a friss deployon.
+     */
+    it('| a verziot HIVASKOR olvassa, nem felszereleskor', () => {
+      let current: string = 'unknown-version';
+      const middleware = DyNTS_createAppVersionHeaderMiddleware((): string => current);
+
+      const firstRes = makeRes();
+      middleware({} as never, firstRes as never, ((): void => undefined) as never);
+      expect(firstRes.headers[DYNTS_APP_VERSION_HEADER]).toBeUndefined();
+
+      current = '01.15.461'; // app-params betoltodott
+      const secondRes = makeRes();
+      middleware({} as never, secondRes as never, ((): void => undefined) as never);
+      expect(secondRes.headers[DYNTS_APP_VERSION_HEADER]).toBe('01.15.461');
+    });
+
+
+    it('| egyedi header-nev is hasznalhato', () => {
+      const res = makeRes();
+      DyNTS_createAppVersionHeaderMiddleware((): string => '1.2.3', 'X-Custom-Version')(
+        {} as never, res as never, ((): void => undefined) as never,
+      );
+      expect(res.headers['X-Custom-Version']).toBe('1.2.3');
+      expect(res.headers['Access-Control-Expose-Headers']).toBe('X-Custom-Version');
+    });
+  });
+});

package/src/_collections/app-version-header.util.ts

@@ -0,0 +1,74 @@
+import * as Express from 'express';
+
+/**
+ * FR-292 (2026-08-08) — a DEPLOYOLT app-verzió kiírása MINDEN válasz headerébe.
+ *
+ * **Miért kell:** a böngészőben nyitva hagyott SPA a memóriájában tartja a bundle-t, és a
+ * deploy után is a RÉGI kódot futtatja, amíg a felhasználó újra nem tölt. Ez nem elméleti:
+ * egy órákig nyitva hagyott dashboard-fülön hiányzó gombokat / régi viselkedést mutat, és
+ * a felhasználó (jogosan) azt hiszi, hogy a funkció nincs kész.
+ *
+ * Az itteni megoldás **nem polling**: a szerver minden válaszra ráteszi a saját deployolt
+ * app-verzióját, a kliens pedig a MÁR MEGLÉVŐ hívásaiból olvassa ki (ngx oldalon a
+ * `DyNX_AppVersion_Interceptor`). Nulla extra kérés, nulla extra terhelés — a jelzés
+ * „ingyen" utazik azon, ami úgyis megy.
+ *
+ * **CORS:** cross-origin kliens csak akkor OLVASHATJA a headert, ha az szerepel az
+ * `Access-Control-Expose-Headers`-ben. Ezért a middleware a meglévő értékhez HOZZÁFŰZ
+ * (nem felülír) — ezért kell a CORS-mount UTÁN felszerelni.
+ */
+
+/** A deployolt app-verziót hordozó response-header neve (a kliens ezt olvassa). */
+export const DYNTS_APP_VERSION_HEADER: string = 'X-App-Version';
+
+/** Az `Access-Control-Expose-Headers` header neve — hogy ne szórjuk el string-literálként. */
+const EXPOSE_HEADERS_HEADER: string = 'Access-Control-Expose-Headers';
+
+/**
+ * Kiszámolja az `Access-Control-Expose-Headers` ÚJ értékét úgy, hogy a meglévő listát
+ * megtartja és a verzió-headert csak akkor fűzi hozzá, ha még nincs benne (idempotens).
+ *
+ * Tiszta függvény: Express nélkül unit-tesztelhető.
+ *
+ * @param currentValue a válaszon MÁR beállított érték (a CORS-middleware-től), ha van
+ * @param headerName a hozzáfűzendő header neve
+ */
+export function DyNTS_resolveExposeHeaders(currentValue: string | undefined, headerName: string): string {
+  if (!currentValue) {
+    return headerName;
+  }
+  const alreadyExposed: boolean = currentValue
+    .split(',')
+    .some((entry: string): boolean => entry.trim().toLowerCase() === headerName.toLowerCase());
+
+  return alreadyExposed ? currentValue : `${currentValue}, ${headerName}`;
+}
+
+/**
+ * Express-middleware, ami minden válaszra ráteszi a deployolt app-verziót.
+ *
+ * A verziót FÜGGVÉNYKÉNT kapja (nem értékként), mert a `DyNTS_global_settings.systemVersion`
+ * az app-params betöltésekor áll be — egy induláskor kiolvasott érték `unknown-version`
+ * maradhatna örökre.
+ *
+ * @param getAppVersion a deployolt app-verziót visszaadó getter
+ * @param headerName felülírható header-név (default: `X-App-Version`)
+ */
+export function DyNTS_createAppVersionHeaderMiddleware(
+  getAppVersion: () => string | undefined,
+  headerName: string = DYNTS_APP_VERSION_HEADER,
+): Express.RequestHandler {
+  return (_req: Express.Request, res: Express.Response, next: Express.NextFunction): void => {
+    const appVersion: string | undefined = getAppVersion();
+    // Ismeretlen verziónál NEM írunk headert: egy `unknown-version` jelzés rosszabb a
+    // semminél — a kliens „új verzió van" hamis riasztást adna belőle.
+    if (appVersion && appVersion !== 'unknown-version') {
+      res.setHeader(headerName, appVersion);
+      res.setHeader(
+        EXPOSE_HEADERS_HEADER,
+        DyNTS_resolveExposeHeaders(res.getHeader(EXPOSE_HEADERS_HEADER)?.toString(), headerName),
+      );
+    }
+    next();
+  };
+}

package/src/_models/interfaces/app-version-header-settings.interface.ts

@@ -0,0 +1,17 @@
+/**
+ * FR-292 (2026-08-08) — a deployolt app-verziót hordozó response-header beállításai.
+ *
+ * A szerver minden válaszra ráteszi a saját app-verzióját, a kliens (ngx oldalon a
+ * `DyNX_AppVersion_Interceptor`) pedig ebből veszi észre, hogy a betöltött bundle elavult.
+ * Nulla extra kérés: a jelzés a már meglévő API-forgalmon utazik.
+ */
+export interface DyNTS_AppVersionHeader_Settings {
+  /**
+   * Ki-/bekapcsolja a header-middleware-t. **Default: `true`** — informatív header, se PII,
+   * se belső részlet nincs benne, viszont nélküle minden app külön építené ugyanezt.
+   */
+  enabled?: boolean;
+
+  /** Felülírható header-név. Default: `X-App-Version`. */
+  headerName?: string;
+}

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

@@ -1,6 +1,7 @@
 import { DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
 import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
 import { DyNTS_SecurityHeaders_Settings } from './security-headers-settings.interface';
+import { DyNTS_AppVersionHeader_Settings } from './app-version-header-settings.interface';
 import { DyNTS_SocketSecurity } from '../../_modules/socket/_enums/socket-security.enum';
 import { DyNTS_GlobalLog_Settings } from './global-log-settings.interface';
 import { DyNTS_Environment_Settings } from './environment-settings.interface';
@@ -170,6 +171,13 @@ export interface DyNTS_Global_Settings {
    */
   securityHeaders?: DyNTS_SecurityHeaders_Settings;
 
+  /**
+   * FR-292 — a deployolt app-verzio kiirasa minden valasz headerebe (X-App-Version), hogy
+   * a bongeszoben NYITVA HAGYOTT SPA eszrevegye, ha kozben ujabb kliens-build ment ki.
+   * Default: enabled. Lasd {@link DyNTS_AppVersionHeader_Settings}.
+   */
+  appVersionHeader?: DyNTS_AppVersionHeader_Settings;
+
   /**
    * FR-193 — bedrock OOM korai-figyelmeztető heap-watchdog ({@link DyNTS_MemoryGuard}).
    * Ha `enabled`, a base `App` startup automatikusan feltelepíti. Periodikusan figyeli a

package/src/_modules/usage/usage.controller.spec.ts

@@ -77,5 +77,30 @@ describe('| DyNTS_Usage_Controller', () => {
     expect((getUsageDataEndpoint as any)?.tasks).toBeDefined();
     expect((getUsageDataEndpoint as any)?.tasks.length).toBeGreaterThan(0);
   });
+
+  /**
+   * BFR-FDPPAL-001 — optional-auth mód (`auth_settings.optional: true`): a `getAuthService()`
+   * `undefined`-ot ad; a setupEndpoints NEM halhat meg TypeError-ral (boot-crash / restart-loop),
+   * a védett getUsageData kimarad, a session-endpointok élnek.
+   */
+  describe('| optional-auth mód — nincs auth service (BFR-FDPPAL-001)', () => {
+    beforeEach(() => {
+      (DyNTS_GlobalService.getAuthService as jasmine.Spy).and.returnValue(undefined);
+    });
+
+    it('| setupEndpoints nem dob, a session-endpointok megvannak', () => {
+      expect(() => controller.setupEndpoints()).not.toThrow();
+
+      expect(controller.endpoints.find(ep => ep.name === 'newSession')).toBeDefined();
+      expect(controller.endpoints.find(ep => ep.name === 'updateUsage')).toBeDefined();
+      expect(controller.endpoints.find(ep => ep.name === 'closeSession')).toBeDefined();
+    });
+
+    it('| a védett getUsageData endpoint KIMARAD (auth nélkül nem szolgálható ki)', () => {
+      controller.setupEndpoints();
+
+      expect(controller.endpoints.find(ep => ep.name === 'getUsageData')).toBeUndefined();
+    });
+  });
 });
 

package/src/_modules/usage/usage.controller.ts

@@ -1,7 +1,7 @@
 
 import { Request, Response } from 'express';
 
-import { DyFM_HttpCallType, DyFM_RelativeDate } from '@futdevpro/fsm-dynamo';
+import { DyFM_HttpCallType, DyFM_Log, DyFM_RelativeDate } from '@futdevpro/fsm-dynamo';
 import {
   DyFM_usageModule_settings, DyFM_UsageSession
 } from '@futdevpro/fsm-dynamo/usage';
@@ -36,7 +36,8 @@ export class DyNTS_Usage_Controller extends DyNTS_Controller {
             let username: string;
             
             try {
-              username = this.authService.getUsernameFromRequest(req);
+              // BFR-FDPPAL-001: optional-auth módban nincs auth service — a session issuer ilyenkor 'unknown'
+              username = this.authService?.getUsernameFromRequest(req) ?? 'unknown';
             } catch {
               username = 'unknown';
             }
@@ -99,28 +100,41 @@ export class DyNTS_Usage_Controller extends DyNTS_Controller {
         ],
       }),
 
-      new DyNTS_Endpoint_Params({
-        name: 'getUsageData',
-        type: DyFM_HttpCallType.get,
-        endpoint: DyFM_usageModule_settings.endPoints.getUsageData,
-        preProcesses: [ this.authService.authenticate_tokenPerm_accUsageData ],
-        tasks: [
-          async (req: Request, res: Response, issuer: string): Promise<void> => {
-            const range: DyFM_RelativeDate = req.params.range as DyFM_RelativeDate;
-
-            const usageService = new DyNTS_Usage_DataService({
-              issuer: issuer,
-            });
-
-            await usageService.getUsage(range);
-
-            res.send(
-              usageService.simplifiedDailyUsage
-            );
-          },
-        ],
-      }),
     ];
+
+    // BFR-FDPPAL-001: optional-auth módban (`auth_settings.optional: true`) a `getAuthService()`
+    // `undefined`-ot ad — a védett usage-lekérdezést ilyenkor KIHAGYJUK (az usage-adat auth nélkül
+    // nem szolgálható ki), de a boot nem halhat meg TypeError-ral; a session-endpointok élnek.
+    if (this.authService) {
+      this.endpoints.push(
+        new DyNTS_Endpoint_Params({
+          name: 'getUsageData',
+          type: DyFM_HttpCallType.get,
+          endpoint: DyFM_usageModule_settings.endPoints.getUsageData,
+          preProcesses: [ this.authService.authenticate_tokenPerm_accUsageData ],
+          tasks: [
+            async (req: Request, res: Response, issuer: string): Promise<void> => {
+              const range: DyFM_RelativeDate = req.params.range as DyFM_RelativeDate;
+
+              const usageService = new DyNTS_Usage_DataService({
+                issuer: issuer,
+              });
+
+              await usageService.getUsage(range);
+
+              res.send(
+                usageService.simplifiedDailyUsage
+              );
+            },
+          ],
+        }),
+      );
+    } else {
+      DyFM_Log.warn(
+        'DyNTS_Usage_Controller: no auth service (optional-auth mode) - ' +
+        'the protected "getUsageData" endpoint is SKIPPED; session endpoints remain available.'
+      );
+    }
   }
 }
 

package/src/_services/base/data.service.spec.ts

@@ -725,5 +725,60 @@ describe('| DyNTS_DataService', () => {
       expect(r.changedFields).toEqual(['email']);
     });
   });
+
+  /**
+   * BFR-FDPTOKENSERVICE-011 — a validátor tömb-ága: egy OPCIONÁLIS `X[]`+`subObjectParams` mező
+   * `undefined` értéke (a normál „még nincs elem" eset) NEM szállhat el `forEach`-TypeError-ral.
+   * A required-hiányt a VP8-ág fogja — az `Array.isArray` őr nem gyengít semmit.
+   */
+  describe('| validateForSave — opcionális tömb-mező subObjectParams-szal (BFR-FDPTOKENSERVICE-011)', (): void => {
+    class WithOptArr extends DyFM_Metadata {
+      name?: string;
+      invoices?: { num?: string }[];
+    }
+
+    const buildParams = (required: boolean): DyFM_DataModel_Params<WithOptArr> =>
+      new DyFM_DataModel_Params<WithOptArr>({
+        dataName: 'with_opt_arr',
+        properties: {
+          invoices: {
+            key: 'invoices',
+            type: DyFM_BasicProperty_Type.array,
+            required: required,
+            subObjectParams: {
+              num: { key: 'num', type: DyFM_BasicProperty_Type.string, required: true },
+            },
+          },
+        },
+      });
+
+    it('| undefined opcionális tömb → NEM dob (a mentés nem bukhat a hiányzó elemeken)', async (): Promise<void> => {
+      const optSvc = new DyNTS_DataService<WithOptArr>(
+        Object.assign(new WithOptArr(), { name: 'x' }), buildParams(false), 'test-issuer',
+      );
+      await expectAsync(optSvc.validateForSave()).toBeResolved();
+    });
+
+    it('| tényleges tömbnél a sub-validáció VÁLTOZATLANUL fut (required sub-mező hiánya → 400)', async (): Promise<void> => {
+      const optSvc = new DyNTS_DataService<WithOptArr>(
+        Object.assign(new WithOptArr(), { name: 'x', invoices: [ {} ] }), buildParams(false), 'test-issuer',
+      );
+      let thrown: any = null;
+      try { await optSvc.validateForSave(); } catch (e) { thrown = e; }
+      expect(thrown).not.toBeNull();
+      expect(DyFM_Error.getErrorStatus(thrown)).toBe(400);
+    });
+
+    it('| required tömb hiánya továbbra is validációs 400 (az őr nem gyengít; hiányra a VP1 required-ág fut)', async (): Promise<void> => {
+      const reqSvc = new DyNTS_DataService<WithOptArr>(
+        Object.assign(new WithOptArr(), { name: 'x' }), buildParams(true), 'test-issuer',
+      );
+      let thrown: any = null;
+      try { await reqSvc.validateForSave(); } catch (e) { thrown = e; }
+      expect(thrown).not.toBeNull();
+      expect(DyFM_Error.getErrorStatus(thrown)).toBe(400);
+      expect(DyFM_Error.getErrorCode(thrown)).toContain('DyNTS-DS0-VP');
+    });
+  });
 });
 

package/src/_services/base/data.service.ts

@@ -1695,7 +1695,10 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
           });
         }
 
-        if (propertyParams.subObjectParams) {
+        // BFR-FDPTOKENSERVICE-011: csak TÉNYLEGES tömbnél szállunk le a sub-objektumokba — egy
+        // OPCIONÁLIS `X[]` mező `undefined` értéke (a normál „még nincs elem" eset) nem dönthet
+        // `forEach`-TypeError-ba; a required-hiányt a fenti VP8-ág fogja, ez az őr nem gyengít.
+        if (propertyParams.subObjectParams && Array.isArray(propertyValue)) {
           propertyValue.forEach((item: any): void => {
             this.validateDataByPropertyParams(item, propertyParams.subObjectParams, propertyParams);
           });

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

@@ -34,6 +34,8 @@ import { DyNTS_ClientSafeError_Util } from '../../_collections/client-safe-error
 import { DyNTS_getEnvironment_settings } from '../../_collections/get-environment-settings.util';
 import { DyNTS_createSecurityHeadersMiddleware } from '../../_collections/security-headers.util';
 import { DyNTS_createLoadShedMiddleware } from '../../_collections/load-shed.util';
+import { DyNTS_createAppVersionHeaderMiddleware } from '../../_collections/app-version-header.util';
+import { DyNTS_AppVersionHeader_Settings } from '../../_models/interfaces/app-version-header-settings.interface';
 import { DyNTS_SecurityHeaders_Settings } from '../../_models/interfaces/security-headers-settings.interface';
 import { startMongoReconnectGuard } from '../../_collections/mongo-reconnect-guard.util';
 import { DyNTS_resolveStaticCacheControlHeader } from '../../_collections/static-cache-control.util';
@@ -1296,6 +1298,9 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
     this.mountSecurityHeaders(this.openExpress);
     // FR-041 — CORS allowlist enforcement. No-op if getCorsSettings() is not overridden.
     this.mountCors(this.openExpress);
+    // FR-292 — a deployolt app-verzio minden valaszon. A CORS UTAN kell, mert az
+    // `Access-Control-Expose-Headers`-hoz HOZZAFUZ (kulonben a CORS felulirna).
+    this.mountAppVersionHeader(this.openExpress);
     // BFR-OVERSEER-009 — opt-in auto-load-shed 503 CRITICAL memória-nyomásnál (esszenciális utak kivételével).
     if (DyNTS_global_settings.memoryGuard?.loadShedEnabled) {
       this.openExpress.use(DyNTS_createLoadShedMiddleware());
@@ -1314,6 +1319,8 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
     this.mountSecurityHeaders(this.secureExpress);
     // FR-041 — CORS allowlist enforcement (same as open express).
     this.mountCors(this.secureExpress);
+    // FR-292 — a deployolt app-verzio minden valaszon (mint az open expressen).
+    this.mountAppVersionHeader(this.secureExpress);
     // BFR-OVERSEER-009 — opt-in auto-load-shed 503 (mint az open expressen).
     if (DyNTS_global_settings.memoryGuard?.loadShedEnabled) {
       this.secureExpress.use(DyNTS_createLoadShedMiddleware());
@@ -1682,6 +1689,25 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
     ));
   }
 
+  /**
+   * FR-292 — a deployolt app-verziot minden valaszra rateszi (`X-App-Version`), hogy a
+   * bongeszoben NYITVA HAGYOTT SPA eszrevegye, ha kozben ujabb kliens-build ment ki.
+   *
+   * Nem polling: a jelzes a MAR MENO API-hivasokon utazik. Az `enabled` default TRUE — egy
+   * informativ response-header, ami se PII-t, se belso reszletet nem szivarogtat, viszont
+   * enelkul minden app kulon-kulon epitene ugyanezt.
+   */
+  protected mountAppVersionHeader(express: Express.Application): void {
+    const settings: DyNTS_AppVersionHeader_Settings | undefined = DyNTS_global_settings.appVersionHeader;
+    if (settings?.enabled === false) {
+      return;
+    }
+    express.use(DyNTS_createAppVersionHeaderMiddleware(
+      (): string => DyNTS_global_settings.systemVersion,
+      settings?.headerName,
+    ));
+  }
+
   protected mountCors(express: Express.Application): void {
     const settings: DyNTS_Cors_Settings | undefined = this.getCorsSettings?.();
     if (!settings) {

package/src/index.ts

@@ -53,9 +53,11 @@ export * from './_models/interfaces/signed-url-verify-result.interface';
 export * from './_models/interfaces/static-client-settings.interface';
 export * from './_models/interfaces/cors-settings.interface';
 export * from './_models/interfaces/security-headers-settings.interface';
+export * from './_models/interfaces/app-version-header-settings.interface';
 export * from './_models/interfaces/db-query-options.interface';
 export * from './_models/interfaces/migration-entry.interface';
 export * from './_collections/security-headers.util';
+export * from './_collections/app-version-header.util';
 export * from './_collections/signed-url.util';
 export * from './_collections/client-safe-error.util';
 export * from './_collections/load-shed.util';