@futdevpro/nts-dynamo 1.15.157 → 1.15.163

package/spec/support/helpers/spec-reporter-loader.js

@@ -1,359 +0,0 @@
-// ============================================================================
-// EGYEDI SPEC REPORTER - JELENLEG KIKOMMENTEZVE
-// ============================================================================
-// Ez az egyedi spec reporter jelenleg kikommentezve van, és a default reporter
-// van használatban.
-//
-// ÚJRA AKTIVÁLÁS:
-// 1. spec/support/jasmine.json fájlban:
-//    - Kommentezd ki: "../spec/support/helpers/ts-node-helper.js"
-//    - Kommentezd be: "../spec/support/helpers/spec-reporter-loader.js"
-//
-// 2. scripts/run-coverage-tests.js fájlban:
-//    - Kommentezd ki: NODE_OPTIONS: `--require ${tsNodeRegister} --require ${tsNodeHelper}`
-//    - Kommentezd be: NODE_OPTIONS: `--require ${tsNodeRegister} --require ${tsNodeHelper} --require ${specReporterLoader}`
-//
-// Ez az egyedi reporter a következő funkciókat biztosítja:
-// - SpecNameReporter: Kiírja a spec nevét és statisztikákat minden tesztnél
-// - SlowTestReporter: Jelzi a lassú teszteket (>1 másodperc)
-// - FailedTestsReporter: Részletes hibajelentés a sikertelen tesztekről
-// - SpecReporter: Színes, formázott kimenet a jasmine-spec-reporter-rel
-// ============================================================================
-
-// A jasmine-spec-reporter betöltése és konfigurálása
-// Ez a fájl helper-ként töltődik be, így a Jasmine inicializálása után fut
-
-console.log('[spec-reporter-loader] Helper fájl betöltve');
-
-// Egyedi reporter, ami kiírja a spec nevét, amikor elindul
-class SpecNameReporter {
-  constructor() {
-    this.currentTestNumber = 0;
-    this.totalTests = 0;
-    this.successfulCount = 0;
-    this.failedCount = 0;
-    this.pendingCount = 0;
-    this.startTime = Date.now();
-  }
-
-  jasmineStarted(result) {
-    // Get total number of specs from the result
-    if (result && result.totalSpecsDefined !== undefined) {
-      this.totalTests = result.totalSpecsDefined;
-    }
-    this.startTime = Date.now();
-  }
-
-  specStarted(result) {
-    this.currentTestNumber++;
-    const stats = `[${this.currentTestNumber}/${this.totalTests || '?'}] (✓${this.successfulCount} ✗${this.failedCount} ⊘${this.pendingCount})`;
-    console.log(`▶ ${stats} ${result.fullName}`);
-  }
-
-  specDone(result) {
-    if (result.status === 'passed') {
-      this.successfulCount++;
-    } else if (result.status === 'failed') {
-      this.failedCount++;
-    } else if (result.status === 'pending' || result.status === 'disabled') {
-      this.pendingCount++;
-    }
-  }
-
-  jasmineDone(result) {
-    const duration = Date.now() - this.startTime;
-    const durationSeconds = (duration / 1000).toFixed(2);
-    
-    console.log('\n' + '='.repeat(80));
-    console.log('TEST SUMMARY');
-    console.log('='.repeat(80));
-    console.log(`Total: ${this.totalTests || '?'} specs`);
-    console.log(`✓ Successful: ${this.successfulCount}`);
-    console.log(`✗ Failed: ${this.failedCount}`);
-    console.log(`⊘ Pending: ${this.pendingCount}`);
-    console.log(`Duration: ${durationSeconds}s`);
-    console.log('='.repeat(80) + '\n');
-  }
-}
-
-// Slow test reporter - tracks tests that take longer than 1ms
-class SlowTestReporter {
-  constructor() {
-    this.slowTests = [];
-    this.testStartTimes = new Map();
-  }
-
-  specStarted(result) {
-    // Extract file name from fullName (format: "| Suite | Test" or "Suite | Test")
-    let file = 'Unknown';
-    if (result.fullName) {
-      const parts = result.fullName.split('|');
-      if (parts.length > 0) {
-        file = parts[0].trim() || 'Unknown';
-      }
-      // If it starts with |, try to get from description or suite
-      if (file === '' && result.description) {
-        file = result.description.split('|')[0]?.trim() || 'Unknown';
-      }
-    }
-    
-    this.testStartTimes.set(result.id, {
-      startTime: Date.now(),
-      fullName: result.fullName,
-      file: file
-    });
-  }
-
-  specDone(result) {
-    const testInfo = this.testStartTimes.get(result.id);
-    if (testInfo) {
-      const duration = Date.now() - testInfo.startTime;
-      if (duration > 1000) { // Only track tests longer than 1 second (1000ms)
-        this.slowTests.push({
-          file: testInfo.file,
-          test: result.fullName,
-          duration: duration
-        });
-      }
-      this.testStartTimes.delete(result.id);
-    }
-  }
-
-  jasmineDone(result) {
-    if (this.slowTests.length > 0) {
-      console.log('\n' + '='.repeat(80));
-      console.log('SLOW TESTS REPORT (tests taking longer than 1 second)');
-      console.log('='.repeat(80));
-      
-      // Group by file
-      const byFile = {};
-      this.slowTests.forEach(test => {
-        if (!byFile[test.file]) {
-          byFile[test.file] = [];
-        }
-        byFile[test.file].push(test);
-      });
-
-      // Sort files by total duration
-      const fileEntries = Object.entries(byFile).map(([file, tests]) => ({
-        file,
-        tests,
-        totalDuration: tests.reduce((sum, t) => sum + t.duration, 0)
-      })).sort((a, b) => b.totalDuration - a.totalDuration);
-
-      // Output report
-      fileEntries.forEach(({ file, tests, totalDuration }) => {
-        console.log(`\n${file} (total: ${totalDuration}ms)`);
-        tests.sort((a, b) => b.duration - a.duration).forEach(test => {
-          console.log(`  ${test.duration}ms - ${test.test}`);
-        });
-      });
-
-      console.log('\n' + '='.repeat(80));
-      console.log(`Total slow tests: ${this.slowTests.length}`);
-      console.log('='.repeat(80) + '\n');
-    }
-  }
-}
-
-// Failed tests reporter - tracks all failed tests
-class FailedTestsReporter {
-  constructor() {
-    this.failedTests = [];
-  }
-
-  specDone(result) {
-    if (result.status === 'failed') {
-      // Extract file name from fullName
-      let file = 'Unknown';
-      if (result.fullName) {
-        const parts = result.fullName.split('|');
-        if (parts.length > 0) {
-          file = parts[0].trim() || 'Unknown';
-        }
-        if (file === '' && result.description) {
-          file = result.description.split('|')[0]?.trim() || 'Unknown';
-        }
-      }
-
-      this.failedTests.push({
-        file: file,
-        test: result.fullName,
-        message: result.failedExpectations && result.failedExpectations.length > 0 
-          ? result.failedExpectations[0].message 
-          : 'Unknown error',
-        stack: result.failedExpectations && result.failedExpectations.length > 0 
-          ? result.failedExpectations[0].stack 
-          : undefined
-      });
-    }
-  }
-
-  jasmineDone() {
-    if (this.failedTests.length > 0) {
-      console.log('\n' + '='.repeat(80));
-      console.log('FAILED TESTS REPORT');
-      console.log('='.repeat(80));
-      
-      // Group by file
-      const byFile = {};
-      this.failedTests.forEach(test => {
-        if (!byFile[test.file]) {
-          byFile[test.file] = [];
-        }
-        byFile[test.file].push(test);
-      });
-
-      // Sort files by number of failures
-      const fileEntries = Object.entries(byFile).map(([file, tests]) => ({
-        file,
-        tests,
-        count: tests.length
-      })).sort((a, b) => b.count - a.count);
-
-      // Output report
-      fileEntries.forEach(({ file, tests, count }) => {
-        console.log(`\n${file} (${count} failure${count > 1 ? 's' : ''})`);
-        tests.forEach((test, index) => {
-          console.log(`\n  ${index + 1}. ✗ ${test.test}`);
-          const raw = test.message || 'Unknown';
-          const message = raw.length > 150 ? raw.substring(0, 150) + '...' : raw;
-          console.log(`     Message: ${(message || 'Unknown').split('\n')[0]}`);
-          
-          // Print stacktrace if available
-          if (test.stack) {
-            // Filter out node_modules and jasmine internals for cleaner stacktrace
-            const stackLines = test.stack.split('\n')
-              .filter(line => {
-                const lowerLine = line.toLowerCase();
-                return !lowerLine.includes('node_modules') && 
-                       !lowerLine.includes('jasmine') &&
-                       !lowerLine.includes('spec-reporter');
-              })
-              .slice(0, 10); // Limit to first 10 relevant lines
-            
-            if (stackLines.length > 0) {
-              console.log(`     Stack:`);
-              stackLines.forEach(line => {
-                console.log(`       ${line.trim()}`);
-              });
-            }
-          }
-        });
-      });
-
-      console.log('\n' + '='.repeat(80));
-      console.log(`Total failed tests: ${this.failedTests.length}`);
-      console.log('='.repeat(80) + '\n');
-    }
-  }
-}
-
-// A jasmine-spec-reporter betöltése
-const { SpecReporter } = require('jasmine-spec-reporter');
-
-// Helper fájlként töltődik be, így a Jasmine már inicializálva van
-const initReporters = () => {
-  const getJasmineEnv = () => {
-    // Módszer 1: globális jasmine objektum
-    if (typeof global !== 'undefined' && global.jasmine && typeof global.jasmine.getEnv === 'function') {
-      return global.jasmine.getEnv();
-    }
-    // Módszer 2: jasmine globális változó
-    if (typeof jasmine !== 'undefined' && typeof jasmine.getEnv === 'function') {
-      return jasmine.getEnv();
-    }
-    return null;
-  };
-
-  const env = getJasmineEnv();
-  if (env) {
-    console.log('[spec-reporter-loader] Jasmine környezet megtalálva, reporterek inicializálása...');
-    const slowTestReporter = new SlowTestReporter();
-    const failedTestsReporter = new FailedTestsReporter();
-    
-    const specNameReporter = new SpecNameReporter();
-    env.addReporter(specNameReporter);
-    env.addReporter(slowTestReporter);
-    env.addReporter(failedTestsReporter);
-    env.addReporter(new SpecReporter({
-      spec: {
-        displayPending: true,
-        displayDuration: true,
-        displaySuccessful: true,
-        displayFailed: true
-      },
-      suite: {
-        displayNumber: true
-      },
-      summary: {
-        displayDuration: true,
-        displayErrorMessages: true,
-        displayStacktrace: 'pretty',
-        displaySuccessful: true,
-        displayFailed: true
-      },
-      colors: {
-        enabled: true
-      }
-    }));
-    
-    // Ensure reports are printed before coverage report
-    // Order: slow tests, failed tests, then summary
-    env.addReporter({
-      jasmineDone: (result) => {
-        // Print slow tests report first
-        slowTestReporter.jasmineDone(result);
-        // Print failed tests report second
-        failedTestsReporter.jasmineDone(result);
-        // Print summary last (before coverage table)
-        specNameReporter.jasmineDone(result);
-      }
-    });
-    
-    console.log('[spec-reporter-loader] Reporterek sikeresen inicializálva');
-    return true;
-  }
-  return false;
-};
-
-// Próbáljuk meg azonnal
-if (!initReporters()) {
-  console.log('[spec-reporter-loader] Jasmine környezet még nem elérhető, várunk...');
-  
-  // Próbáljuk meg több időpontban is, hasonlóan a timeout-helper-hez
-  setTimeout(() => {
-    if (!initReporters()) {
-      setTimeout(() => {
-        if (!initReporters()) {
-          setTimeout(() => {
-            if (!initReporters()) {
-              // Ha még mindig nem sikerült, várunk és újra próbáljuk
-              let attempts = 0;
-              const maxAttempts = 100;
-              
-              const interval = setInterval(() => {
-                attempts++;
-                if (initReporters()) {
-                  clearInterval(interval);
-                  console.log('[spec-reporter-loader] Reporterek sikeresen inicializálva', attempts, 'próbálkozás után');
-                } else if (attempts >= maxAttempts) {
-                  clearInterval(interval);
-                  console.error('[spec-reporter-loader] Failed to initialize reporters after', maxAttempts, 'attempts');
-                  console.error('[spec-reporter-loader] Debug info:', {
-                    hasGlobal: typeof global !== 'undefined',
-                    hasJasmine: typeof jasmine !== 'undefined',
-                    globalJasmine: typeof global !== 'undefined' && global.jasmine,
-                    jasmineGetEnv: typeof jasmine !== 'undefined' && typeof jasmine.getEnv === 'function'
-                  });
-                }
-              }, 50);
-            }
-          }, 100);
-        }
-      }, 50);
-    }
-  }, 0);
-} else {
-  console.log('[spec-reporter-loader] Reporterek azonnal inicializálva');
-}

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

@@ -1,93 +0,0 @@
-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 +0,0 @@
-{
-  "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 +0,0 @@
-{
-  "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 +0,0 @@
-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 +0,0 @@
-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();
-  };
-}