@futdevpro/nts-dynamo 1.15.151 → 1.15.153

package/spec/support/helpers/ts-node-helper.js

@@ -1,93 +1,93 @@
-require('ts-node').register({
-  transpileOnly: true,
-  compilerOptions: {
-    module: 'commonjs',
-    esModuleInterop: true,
-    allowSyntheticDefaultImports: true
-  }
-});
-
-// Set default timeout for all tests immediately
-// This ensures that failed tests timeout quickly (2 seconds) instead of running for too long
-// We set it both immediately and in a delayed callback to ensure it works even if spec files override it
-// NOTE: This is also set in jasmine.json and jasmine.coverage.json - keep all 3 in sync!
-const FORCE_TIMEOUT = 2000; // 2 seconds
-
-// Function to force timeout setting - agresszíven felülírja minden timeout beállítást
-const forceTimeout = () => {
-  if (typeof jasmine !== 'undefined') {
-    jasmine.DEFAULT_TIMEOUT_INTERVAL = FORCE_TIMEOUT;
-  }
-  if (typeof global !== 'undefined' && global.jasmine) {
-    global.jasmine.DEFAULT_TIMEOUT_INTERVAL = FORCE_TIMEOUT;
-  }
-  // Try to access jasmine through window if available (for browser environments)
-  if (typeof window !== 'undefined' && window.jasmine) {
-    window.jasmine.DEFAULT_TIMEOUT_INTERVAL = FORCE_TIMEOUT;
-  }
-};
-
-// Set timeout immediately if jasmine is available
-forceTimeout();
-
-// Agresszív timeout felülírás - folyamatosan felülírja minden 100ms-ben
-// Ez biztosítja, hogy még a spec fájlokban lévő timeout beállítások is felülírásra kerüljenek
-const aggressiveTimeoutInterval = setInterval(() => {
-  forceTimeout();
-}, 100);
-
-// Stop the aggressive interval after 10 seconds (enough time for all tests to start)
-setTimeout(() => {
-  clearInterval(aggressiveTimeoutInterval);
-}, 10000);
-
-// Hook into jasmine's environment if available
-const initTimeout = () => {
-  // Try both global and local jasmine
-  const jasmineObj = (typeof global !== 'undefined' && global.jasmine) || (typeof jasmine !== 'undefined' ? jasmine : null);
-  
-  if (jasmineObj && typeof jasmineObj.getEnv === 'function') {
-    try {
-      const env = jasmineObj.getEnv();
-      if (env) {
-        // Force timeout immediately
-        forceTimeout();
-        
-        // Add a global beforeEach that runs in every spec file to force timeout
-        env.beforeEach(() => {
-          forceTimeout();
-        });
-        // Also add afterEach to ensure timeout is set after each test
-        env.afterEach(() => {
-          forceTimeout();
-        });
-        // Add a reporter that forces timeout on every spec start and done
-        // This ensures that even if a spec file sets timeout, it gets overridden
-        env.addReporter({
-          specStarted: () => {
-            forceTimeout();
-          },
-          specDone: () => {
-            forceTimeout();
-          },
-          suiteStarted: () => {
-            forceTimeout();
-          },
-          suiteDone: () => {
-            forceTimeout();
-          }
-        });
-      }
-    } catch (e) {
-      // Ignore errors if jasmine is not fully initialized yet
-    }
-  }
-};
-
-// Try to initialize multiple times to catch late initialization
-initTimeout();
-setTimeout(initTimeout, 0);
-setTimeout(initTimeout, 50);
-setTimeout(initTimeout, 200);
-setTimeout(initTimeout, 1000);
-
+require('ts-node').register({
+  transpileOnly: true,
+  compilerOptions: {
+    module: 'commonjs',
+    esModuleInterop: true,
+    allowSyntheticDefaultImports: true
+  }
+});
+
+// Set default timeout for all tests immediately
+// This ensures that failed tests timeout quickly (2 seconds) instead of running for too long
+// We set it both immediately and in a delayed callback to ensure it works even if spec files override it
+// NOTE: This is also set in jasmine.json and jasmine.coverage.json - keep all 3 in sync!
+const FORCE_TIMEOUT = 2000; // 2 seconds
+
+// Function to force timeout setting - agresszíven felülírja minden timeout beállítást
+const forceTimeout = () => {
+  if (typeof jasmine !== 'undefined') {
+    jasmine.DEFAULT_TIMEOUT_INTERVAL = FORCE_TIMEOUT;
+  }
+  if (typeof global !== 'undefined' && global.jasmine) {
+    global.jasmine.DEFAULT_TIMEOUT_INTERVAL = FORCE_TIMEOUT;
+  }
+  // Try to access jasmine through window if available (for browser environments)
+  if (typeof window !== 'undefined' && window.jasmine) {
+    window.jasmine.DEFAULT_TIMEOUT_INTERVAL = FORCE_TIMEOUT;
+  }
+};
+
+// Set timeout immediately if jasmine is available
+forceTimeout();
+
+// Agresszív timeout felülírás - folyamatosan felülírja minden 100ms-ben
+// Ez biztosítja, hogy még a spec fájlokban lévő timeout beállítások is felülírásra kerüljenek
+const aggressiveTimeoutInterval = setInterval(() => {
+  forceTimeout();
+}, 100);
+
+// Stop the aggressive interval after 10 seconds (enough time for all tests to start)
+setTimeout(() => {
+  clearInterval(aggressiveTimeoutInterval);
+}, 10000);
+
+// Hook into jasmine's environment if available
+const initTimeout = () => {
+  // Try both global and local jasmine
+  const jasmineObj = (typeof global !== 'undefined' && global.jasmine) || (typeof jasmine !== 'undefined' ? jasmine : null);
+  
+  if (jasmineObj && typeof jasmineObj.getEnv === 'function') {
+    try {
+      const env = jasmineObj.getEnv();
+      if (env) {
+        // Force timeout immediately
+        forceTimeout();
+        
+        // Add a global beforeEach that runs in every spec file to force timeout
+        env.beforeEach(() => {
+          forceTimeout();
+        });
+        // Also add afterEach to ensure timeout is set after each test
+        env.afterEach(() => {
+          forceTimeout();
+        });
+        // Add a reporter that forces timeout on every spec start and done
+        // This ensures that even if a spec file sets timeout, it gets overridden
+        env.addReporter({
+          specStarted: () => {
+            forceTimeout();
+          },
+          specDone: () => {
+            forceTimeout();
+          },
+          suiteStarted: () => {
+            forceTimeout();
+          },
+          suiteDone: () => {
+            forceTimeout();
+          }
+        });
+      }
+    } catch (e) {
+      // Ignore errors if jasmine is not fully initialized yet
+    }
+  }
+};
+
+// Try to initialize multiple times to catch late initialization
+initTimeout();
+setTimeout(initTimeout, 0);
+setTimeout(initTimeout, 50);
+setTimeout(initTimeout, 200);
+setTimeout(initTimeout, 1000);
+

package/spec/support/jasmine.coverage.json

@@ -1,24 +1,24 @@
-{
-  "reporters": [
-    {
-      "name": "jasmine-json-reporter",
-      "options": {
-        "pretty": true
-      }
-    }
-  ],
-  "spec_dir": "src/",
-  "spec_files": [
-    "**/*.spec.ts",
-    "**/*[sS]pec.ts"
-  ],
-  "helpers": [
-    "../../spec/support/helpers/ts-node-helper.js"
-  ],
-  "env": {
-    "stopSpecOnExpectationFailure": false,
-    "random": true,
-    "defaultTimeoutInterval": 2000
-  }
-}
-
+{
+  "reporters": [
+    {
+      "name": "jasmine-json-reporter",
+      "options": {
+        "pretty": true
+      }
+    }
+  ],
+  "spec_dir": "src/",
+  "spec_files": [
+    "**/*.spec.ts",
+    "**/*[sS]pec.ts"
+  ],
+  "helpers": [
+    "../../spec/support/helpers/ts-node-helper.js"
+  ],
+  "env": {
+    "stopSpecOnExpectationFailure": false,
+    "random": true,
+    "defaultTimeoutInterval": 2000
+  }
+}
+

package/spec/support/jasmine.json

@@ -1,24 +1,24 @@
-{
-  "reporters": [
-    {
-      "name": "jasmine-json-reporter",
-      "options": {
-        "pretty": true
-      }
-    }
-  ],
-  "spec_dir": "build/",
-  "spec_files": [
-    "**/*.spec.ts",
-    "**/*.spec.js",
-    "**/*[sS]pec.ts"
-  ],
-  "helpers": [
-    "../spec/support/helpers/ts-node-helper.js"
-  ],
-  "env": {
-    "stopSpecOnExpectationFailure": false,
-    "random": true,
-    "defaultTimeoutInterval": 2000
-  }
-}
+{
+  "reporters": [
+    {
+      "name": "jasmine-json-reporter",
+      "options": {
+        "pretty": true
+      }
+    }
+  ],
+  "spec_dir": "build/",
+  "spec_files": [
+    "**/*.spec.ts",
+    "**/*.spec.js",
+    "**/*[sS]pec.ts"
+  ],
+  "helpers": [
+    "../spec/support/helpers/ts-node-helper.js"
+  ],
+  "env": {
+    "stopSpecOnExpectationFailure": false,
+    "random": true,
+    "defaultTimeoutInterval": 2000
+  }
+}

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

@@ -1,108 +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');
-    });
-  });
-});
+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

@@ -1,74 +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();
-  };
-}
+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();
+  };
+}