@futdevpro/nts-dynamo 1.15.122 → 1.15.126

package/src/_collections/signed-url.util.spec.ts

@@ -0,0 +1,198 @@
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_SignedUrl_Util } from './signed-url.util';
+
+/**
+ * ALÁÍRT-URL primitív tesztjei (AAA).
+ *
+ * ⭐ **Az ARANY-VEKTOR az első teszt, és ez a legfontosabb:** a hex értéket a ma ÉLŐ algoritmusból
+ * generáltuk *(az `fdp-ftp-service` `FtpUrlSignature_Util` verify- és a `master-prompter`
+ * `FtpUrlSigner_Util` sign-oldala — bit-azonosak)*. Ha ez a teszt elpirosodik, az azt jelenti,
+ * hogy a bedrock util **elcsúszott** az élő rendszertől, és a **már kiadott URL-ek elromlanának**.
+ *
+ * ⚠️ `nowMs` **mindenhol injektálva** — a tesztben nincs `Date.now()`, tehát nincs flake.
+ */
+describe('| DyNTS_SignedUrl_Util', () => {
+  const SECRET: string = 'golden-vector-secret';
+  const BACKSLASH: string = String.fromCharCode(92);
+
+  // --- ARANY-VEKTOR (az élő algoritmusból generálva) ---
+  const GOLDEN_PATH: string = '/accounts/acc-1/invoices/INV-2026-001.pdf';
+  const GOLDEN_EXP: number = 1767225600000;
+  const GOLDEN_HEX: string = 'a6c2d1ddf0fe4614e3b6130d4e22a9ef085377f73088d3f79aab548e8056c165';
+
+  it('1 | ARANY-VEKTOR — a mai algoritmus hexét adja (bitre)', () => {
+    const signature: string = DyNTS_SignedUrl_Util.sign(GOLDEN_PATH, GOLDEN_EXP, SECRET);
+
+    expect(signature).toBe(GOLDEN_HEX);
+  });
+
+  it('2 | normalizePath — vezető /-ek le, backslash → slash', () => {
+    expect(DyNTS_SignedUrl_Util.normalizePath('///a' + BACKSLASH + 'b/c')).toBe('a/b/c');
+  });
+
+  it('3 | buildCanonicalString — `<path>\\n<exp>`', () => {
+    expect(DyNTS_SignedUrl_Util.buildCanonicalString('a/b', 123)).toBe('a/b\n123');
+  });
+
+  it('4 | sign determinisztikus — kétszeri hívás azonos', () => {
+    const first: string = DyNTS_SignedUrl_Util.sign(GOLDEN_PATH, GOLDEN_EXP, SECRET);
+    const second: string = DyNTS_SignedUrl_Util.sign(GOLDEN_PATH, GOLDEN_EXP, SECRET);
+
+    expect(first).toBe(second);
+  });
+
+  it('5 | verify — érvényes aláírásra { valid: true }', () => {
+    const result = DyNTS_SignedUrl_Util.verify({
+      filePath: GOLDEN_PATH, expMs: GOLDEN_EXP, signature: GOLDEN_HEX,
+      secret: SECRET, nowMs: GOLDEN_EXP - 1000,
+    });
+
+    expect(result.valid).toBeTrue();
+    expect(result.reason).toBeUndefined();
+  });
+
+  it('6 | verify — LEJÁRT aláírásra { valid: false, reason: expired }', () => {
+    const result = DyNTS_SignedUrl_Util.verify({
+      filePath: GOLDEN_PATH, expMs: GOLDEN_EXP, signature: GOLDEN_HEX,
+      secret: SECRET, nowMs: GOLDEN_EXP + 1,
+    });
+
+    expect(result.valid).toBeFalse();
+    expect(result.reason).toBe('expired');
+  });
+
+  it('7 | verify — HAMIS aláírásra { valid: false, reason: signature-mismatch }', () => {
+    // ugyanolyan HOSSZÚ, de más tartalmú hex — a timing-safe ág fut le, nem a hossz-guard
+    const forged: string = 'b'.repeat(GOLDEN_HEX.length);
+
+    const result = DyNTS_SignedUrl_Util.verify({
+      filePath: GOLDEN_PATH, expMs: GOLDEN_EXP, signature: forged,
+      secret: SECRET, nowMs: GOLDEN_EXP - 1000,
+    });
+
+    expect(result.valid).toBeFalse();
+    expect(result.reason).toBe('signature-mismatch');
+  });
+
+  it('8 | verify — ELTÉRŐ HOSSZÚ aláírásra NEM dob (timingSafeEqual guard)', () => {
+    const shortSignature: string = 'abc';
+
+    // Act + Assert: a lényeg, hogy NEM dob — a `timingSafeEqual` eltérő hosszra dobna.
+    expect((): void => {
+      const result = DyNTS_SignedUrl_Util.verify({
+        filePath: GOLDEN_PATH, expMs: GOLDEN_EXP, signature: shortSignature,
+        secret: SECRET, nowMs: GOLDEN_EXP - 1000,
+      });
+
+      expect(result.valid).toBeFalse();
+    }).not.toThrow();
+  });
+
+  it('9 | verify — hiányzó exp/sig esetén { valid: false, reason: missing-params }', () => {
+    const noSignature = DyNTS_SignedUrl_Util.verify({
+      filePath: GOLDEN_PATH, expMs: GOLDEN_EXP, signature: undefined,
+      secret: SECRET, nowMs: GOLDEN_EXP - 1000,
+    });
+    const noExp = DyNTS_SignedUrl_Util.verify({
+      filePath: GOLDEN_PATH, expMs: undefined, signature: GOLDEN_HEX,
+      secret: SECRET, nowMs: GOLDEN_EXP - 1000,
+    });
+
+    expect(noSignature.reason).toBe('missing-params');
+    expect(noExp.reason).toBe('missing-params');
+  });
+
+  it('10 | verify — ÜRES secrettel SOHA nem true', () => {
+    const result = DyNTS_SignedUrl_Util.verify({
+      filePath: GOLDEN_PATH, expMs: GOLDEN_EXP, signature: GOLDEN_HEX,
+      secret: '', nowMs: GOLDEN_EXP - 1000,
+    });
+
+    expect(result.valid).toBeFalse();
+    expect(result.reason).toBe('missing-secret');
+  });
+
+  it('11 | sign — ÜRES secretre DOB (DyNTS-SURL-SIGN-NOSEC), nem ad csendben üres aláírást', () => {
+    let caught: DyFM_Error | undefined;
+
+    try {
+      DyNTS_SignedUrl_Util.sign(GOLDEN_PATH, GOLDEN_EXP, '');
+    } catch (error) {
+      caught = error as DyFM_Error;
+    }
+
+    expect(caught).toBeDefined();
+    expect(caught?._errorCode).toBe('DyNTS-SURL-SIGN-NOSEC');
+  });
+
+  it('12 | buildSignedUrl — base végi /-ek levágva, query helyes', () => {
+    const url: string = DyNTS_SignedUrl_Util.buildSignedUrl({
+      baseUrl: 'https://ftp.example.com///',
+      filePath: '/accounts/acc-1/f.pdf',
+      ttlMs: 60_000,
+      secret: SECRET,
+      nowMs: 1_000_000,
+    });
+
+    const expectedSignature: string =
+      DyNTS_SignedUrl_Util.sign('accounts/acc-1/f.pdf', 1_060_000, SECRET);
+    expect(url).toBe(
+      `https://ftp.example.com/accounts/acc-1/f.pdf?exp=1060000&sig=${expectedSignature}`,
+    );
+  });
+
+  it('13 | PATH-MANIPULÁCIÓ — aláírt path ≠ kért path → érvénytelen', () => {
+    const signature: string = DyNTS_SignedUrl_Util.sign('accounts/acc-1/f.pdf', GOLDEN_EXP, SECRET);
+
+    const result = DyNTS_SignedUrl_Util.verify({
+      filePath: 'accounts/acc-2/f.pdf',        // MÁSIK account
+      expMs: GOLDEN_EXP, signature, secret: SECRET, nowMs: GOLDEN_EXP - 1000,
+    });
+
+    expect(result.valid).toBeFalse();
+    expect(result.reason).toBe('signature-mismatch');
+  });
+
+  it('14 | nowMs injektálás — determinisztikus lejárat-határ (nincs Date.now a tesztben)', () => {
+    const atBoundary = DyNTS_SignedUrl_Util.verify({
+      filePath: GOLDEN_PATH, expMs: GOLDEN_EXP, signature: GOLDEN_HEX,
+      secret: SECRET, nowMs: GOLDEN_EXP,        // exp === now → MÉG érvényes
+    });
+    const afterBoundary = DyNTS_SignedUrl_Util.verify({
+      filePath: GOLDEN_PATH, expMs: GOLDEN_EXP, signature: GOLDEN_HEX,
+      secret: SECRET, nowMs: GOLDEN_EXP + 1,    // egy ms-mal később → lejárt
+    });
+
+    expect(atBoundary.valid).toBeTrue();
+    expect(afterBoundary.reason).toBe('expired');
+  });
+
+  it('15 | buildSignedUrl — ÜRES/hibás baseUrl-re DOB (DyNTS-SURL-URL-BADBASE), nem épít félkész URL-t', () => {
+    let caught: DyFM_Error | undefined;
+
+    try {
+      DyNTS_SignedUrl_Util.buildSignedUrl({
+        baseUrl: '   ', filePath: 'a/b.pdf', ttlMs: 1000, secret: SECRET, nowMs: 1,
+      });
+    } catch (error) {
+      caught = error as DyFM_Error;
+    }
+
+    expect(caught).toBeDefined();
+    expect(caught?._errorCode).toBe('DyNTS-SURL-URL-BADBASE');
+  });
+
+  it('16 | sign — nem-pozitív/nem-szám expMs-re DOB (DyNTS-SURL-SIGN-BADEXP)', () => {
+    let caught: DyFM_Error | undefined;
+
+    try {
+      DyNTS_SignedUrl_Util.sign(GOLDEN_PATH, Number.NaN, SECRET);
+    } catch (error) {
+      caught = error as DyFM_Error;
+    }
+
+    expect(caught).toBeDefined();
+    expect(caught?._errorCode).toBe('DyNTS-SURL-SIGN-BADEXP');
+  });
+});

package/src/_collections/signed-url.util.ts

@@ -0,0 +1,170 @@
+import * as Crypto from 'crypto';
+
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_SignedUrl_VerifyResult } from '../_models/interfaces/signed-url-verify-result.interface';
+
+/**
+ * ALÁÍRT-URL primitív (HMAC-SHA256) — a böngésző-kiszolgálás (`<img src>`, nincs Bearer)
+ * auth-mechanizmusának generikus magja.
+ *
+ * A forrás-rendszer (ahol megvan a user auth-kontextusa) aláírja a `path + exp` kanonikus
+ * stringet a MEGOSZTOTT titokkal, és egy `…/<path>?exp=<ms>&sig=<hex>` URL-t ad ki; a kiszolgáló
+ * oldal ugyanezzel a titokkal validál. Az **aláírás maga a tamper-proof izoláció**: a path
+ * bármilyen módosítása érvényteleníti.
+ *
+ * ⚠️ **A SZERZŐDÉS BITRE KÖTÖTT — nem tervezési szabadság.** Ez az util a ma ÉLŐ algoritmust
+ * viszi tovább (az `fdp-ftp-service` verify- és a `master-prompter` sign-oldaláról mérve),
+ * hogy a **már kiadott URL-ek** ne romoljanak el:
+ *
+ * | Elem | Érték |
+ * |---|---|
+ * | Algoritmus | `HMAC-SHA256(secret, canonicalString)` → **hex** |
+ * | Kanonikus string | `` `<normalizedPath>\n<expMs>` `` — csak path + lejárat |
+ * | `normalizePath` | vezető `/`-ek le (`/^\/+/`), `\` → `/` |
+ * | Query | `?exp=<ms>&sig=<hex>` |
+ * | Összevetés | `Crypto.timingSafeEqual`, **előtte hossz-guard** |
+ * | Lejárat | `expMs < now` → érvénytelen; **nincs** beépített max-TTL (a hívó dönt) |
+ *
+ * **Miért `dynamo-nts` és nem `fsm-dynamo`:** node-`crypto` kell (`createHmac` +
+ * **`timingSafeEqual`**); izomorf rétegben a timing-safe összevetés elveszne, és a sign/verify
+ * két csomagba vágása pont azt a bitre-egyezést veszélyeztetné, amiért ez az util készül.
+ *
+ * **Két tudatos eltérés a mai duplikátumoktól:**
+ * 1. `sign`/`buildSignedUrl` üres secretre **DOB** — a mai forrás-oldal üres stringet ad vissza,
+ *    ami **csendes hiba**: a hívó észrevétlenül aláírás nélküli URL-t kaphat. A bedrock **hangos**;
+ *    a fallback-döntés a hívóé, de **tudatosan**.
+ * 2. `verify` **SOHA nem dob** — strukturált `{ valid, reason }`-t ad, hogy a gate-ek egységes,
+ *    szivárgás-mentes választ tudjanak adni.
+ */
+export class DyNTS_SignedUrl_Util {
+
+  /**
+   * Path normalizálás az aláíráshoz/validáláshoz: vezető `/`-ek le, `\` → `/`.
+   * A kanonikus string első fele — a két oldalnak **bit-azonosan** kell normalizálnia.
+   */
+  static normalizePath(filePath: string): string {
+    return (filePath ?? '').replace(/^\/+/, '').replace(/\\/g, '/');
+  }
+
+  /**
+   * A HMAC bemenete: `` `<normalizedPath>\n<expMs>` ``.
+   * **Publikus**, hogy tesztelhető és auditálható legyen (az arany-vektor erre épül).
+   */
+  static buildCanonicalString(filePath: string, expMs: number): string {
+    return `${DyNTS_SignedUrl_Util.normalizePath(filePath)}\n${expMs}`;
+  }
+
+  /**
+   * HMAC-SHA256 hex digest a kanonikus stringen.
+   *
+   * @throws `DyNTS-SURL-SIGN-NOSEC` — üres secret *(⚠️ NEM ad csendben üres aláírást)*
+   * @throws `DyNTS-SURL-SIGN-BADEXP` — nem-szám / nem-pozitív `expMs`
+   */
+  static sign(filePath: string, expMs: number, secret: string): string {
+    DyNTS_SignedUrl_Util._assertSecret(secret, filePath);
+    DyNTS_SignedUrl_Util._assertExp(expMs, filePath);
+
+    return Crypto
+      .createHmac('sha256', secret)
+      .update(DyNTS_SignedUrl_Util.buildCanonicalString(filePath, expMs), 'utf8')
+      .digest('hex');
+  }
+
+  /**
+   * Timing-safe aláírás-ellenőrzés + lejárat. ⚠️ **SOHA nem dob** — a hívó gate-nek egységes,
+   * szivárgás-mentes választ kell tudnia adni.
+   *
+   * `nowMs` injektálható → determinisztikus teszt (nincs `Date.now()` a tesztben).
+   */
+  static verify(params: {
+    filePath: string;
+    expMs: number | undefined;
+    signature: string | undefined;
+    secret: string;
+    nowMs?: number;
+  }): DyNTS_SignedUrl_VerifyResult {
+    if (!params.secret) {
+      return { valid: false, reason: 'missing-secret' };
+    }
+    if (!params.signature || typeof params.expMs !== 'number' || !Number.isFinite(params.expMs)) {
+      return { valid: false, reason: 'missing-params' };
+    }
+
+    const now: number = typeof params.nowMs === 'number' ? params.nowMs : Date.now();
+    if (params.expMs < now) {
+      return { valid: false, reason: 'expired' };
+    }
+
+    const expected: string = DyNTS_SignedUrl_Util.sign(params.filePath, params.expMs, params.secret);
+
+    // ⚠️ A `timingSafeEqual` ELTÉRŐ HOSSZÚ bufferre DOB — ezért kell a hossz-guard.
+    // A hossz nem titok: a hex digest hossza fix.
+    const signatureBuffer: Buffer = Buffer.from(params.signature, 'utf8');
+    const expectedBuffer: Buffer = Buffer.from(expected, 'utf8');
+    if (signatureBuffer.length !== expectedBuffer.length) {
+      return { valid: false, reason: 'signature-mismatch' };
+    }
+    if (!Crypto.timingSafeEqual(signatureBuffer, expectedBuffer)) {
+      return { valid: false, reason: 'signature-mismatch' };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Teljes aláírt URL: `` `<base>/<normalizedPath>?exp=<ms>&sig=<hex>` `` — a `base` végi
+   * `/`-ei levágva.
+   *
+   * @throws `DyNTS-SURL-URL-BADBASE` — üres/hibás `baseUrl` *(⚠️ NEM épít félkész URL-t)*
+   * @throws `DyNTS-SURL-SIGN-NOSEC` — üres secret
+   */
+  static buildSignedUrl(params: {
+    baseUrl: string;
+    filePath: string;
+    ttlMs: number;
+    secret: string;
+    nowMs?: number;
+  }): string {
+    const base: string = (params.baseUrl ?? '').trim().replace(/\/+$/, '');
+    if (!base) {
+      throw new DyFM_Error({
+        status: 500,
+        errorCode: 'DyNTS-SURL-URL-BADBASE',
+        message: 'Signed URL: "baseUrl" is empty or invalid — refusing to build a half-formed URL.',
+        additionalContent: { filePath: params.filePath },
+      });
+    }
+
+    const now: number = typeof params.nowMs === 'number' ? params.nowMs : Date.now();
+    const expMs: number = now + params.ttlMs;
+    const normalizedPath: string = DyNTS_SignedUrl_Util.normalizePath(params.filePath);
+    const signature: string = DyNTS_SignedUrl_Util.sign(normalizedPath, expMs, params.secret);
+
+    return `${base}/${normalizedPath}?exp=${expMs}&sig=${signature}`;
+  }
+
+  /** Üres secret → hangos hiba. ⚠️ A titok SOHA nem kerül a hiba-kontextusba. */
+  private static _assertSecret(secret: string, filePath: string): void {
+    if (!secret) {
+      throw new DyFM_Error({
+        status: 500,
+        errorCode: 'DyNTS-SURL-SIGN-NOSEC',
+        message: 'Signed URL: signing secret is not configured — refusing to sign silently.',
+        additionalContent: { filePath: DyNTS_SignedUrl_Util.normalizePath(filePath) },
+      });
+    }
+  }
+
+  /** Nem-szám / nem-pozitív lejárat → hangos hiba (a csendes `NaN`-os aláírás rosszabb). */
+  private static _assertExp(expMs: number, filePath: string): void {
+    if (typeof expMs !== 'number' || !Number.isFinite(expMs) || expMs <= 0) {
+      throw new DyFM_Error({
+        status: 500,
+        errorCode: 'DyNTS-SURL-SIGN-BADEXP',
+        message: 'Signed URL: "expMs" must be a finite positive number (epoch millis).',
+        additionalContent: { filePath: DyNTS_SignedUrl_Util.normalizePath(filePath), expMs: `${expMs}` },
+      });
+    }
+  }
+}

package/src/_models/interfaces/signed-url-verify-result.interface.ts

@@ -0,0 +1,13 @@
+/**
+ * Az aláírt-URL ellenőrzés (`DyNTS_SignedUrl_Util.verify`) strukturált eredménye.
+ *
+ * ⚠️ A `reason` **logba** való — a HTTP-válaszba **NEM** szivárogtatható: az elutasítás oka
+ * támadónak információ *(pl. „expired" vs. „signature-mismatch" megkülönböztetése)*.
+ *
+ * ⭐ **Miért strukturált eredmény és nem kivétel:** a `verify` SOHA nem dob, hogy a hívó gate-ek
+ * egységes, szivárgás-mentes választ tudjanak adni — a `reason` a **belső** diagnosztika.
+ */
+export interface DyNTS_SignedUrl_VerifyResult {
+  valid: boolean;
+  reason?: 'missing-secret' | 'missing-params' | 'expired' | 'signature-mismatch';
+}

package/src/index.ts

@@ -49,12 +49,14 @@ export * from './_models/interfaces/environment-settings.interface';
 export * from './_models/interfaces/global-service-settings.interface';
 export * from './_models/interfaces/global-settings.interface';
 export * from './_models/interfaces/routing-module-settings.interface';
+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/db-query-options.interface';
 export * from './_models/interfaces/migration-entry.interface';
 export * from './_collections/security-headers.util';
+export * from './_collections/signed-url.util';
 export * from './_collections/client-safe-error.util';
 export * from './_collections/load-shed.util';
 export * from './_services/core/event-loop-diag.service';

package/build/_modules/ftp/_collections/ftp-url-signer.util.d.ts

@@ -1,37 +0,0 @@
-/**
- * FTP signed-URL ALÁÍRÓ (deep/generikus — `@futdevpro/nts-dynamo`).
- *
- * A böngésző-serve (`<img src>` / letöltő-link) nem tud Bearer-headert küldeni, ezért az
- * `fdp-ftp-service` HTTP-kiszolgálása rövid-/közép-életű **aláírt URL**-lel auth-ol. Ez az util a
- * megosztott titokkal HMAC-SHA256-tal aláírja a `path + exp`-et, és előállítja a serve-URL-t.
- *
- * ⚠️ Az algoritmusnak **BIT-RE egyeznie kell** az `fdp-ftp-service` `FtpUrlSignature_Util`-jával
- * (kanonikus string: `<normalizedPath>\n<expMs>`; normalizálás: leading-slash le + `\`→`/`), különben
- * az ftp elutasítja a signature-t.
- *
- * **PURE (ADR-004):** ez a modul NEM importál `fdp-templates`-et — a `secret`/`serveBaseUrl` a hívó-
- * (consumer-) oldalról jön paraméterként. Így minden FDP-server újrahasználhatja, egyetlen példányban.
- */
-export declare class DyNTS_FtpUrlSigner_Util {
-    /** Path normalizálás — pontosan az ftp-serve normalizálása (leading-slash le, `\`→`/`). */
-    static normalizePath(filePath: string): string;
-    /**
-     * Kanonikus UPLOAD-cél string: `accountId/folderPath/fileName`. A szerver-szerver (app→ftp) upload
-     * ezt írja alá → az ftp ugyanígy építi + validálja. Bit-azonos kell legyen a két oldalon.
-     */
-    static uploadTarget(accountId: string, folderPath: string, fileName: string): string;
-    /** HMAC-SHA256 a `<normalizedPath>\n<expMs>`-en → hex (az ftp ezt validálja). */
-    static sign(filePath: string, expMs: number, secret: string): string;
-    /**
-     * Teljes aláírt serve-URL egy ftp-path-ból: `<serveBaseUrl>/<normalizedPath>?exp=<ms>&sig=<hex>`.
-     * Üres `secret` → üres string (a gate inaktív; a hívó dönt a fallback-ről). `nowMs` injektálható teszthez.
-     */
-    static buildSignedServeUrl(params: {
-        serveBaseUrl: string;
-        ftpPath: string;
-        ttlMs: number;
-        secret: string;
-        nowMs?: number;
-    }): string;
-}
-//# sourceMappingURL=ftp-url-signer.util.d.ts.map

package/build/_modules/ftp/_collections/ftp-url-signer.util.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ftp-url-signer.util.d.ts","sourceRoot":"","sources":["../../../../src/_modules/ftp/_collections/ftp-url-signer.util.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,qBAAa,uBAAuB;IAElC,2FAA2F;IAC3F,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAI9C;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAIpF,iFAAiF;IACjF,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAQpE;;;OAGG;IACH,MAAM,CAAC,mBAAmB,CAAC,MAAM,EAAE;QACjC,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,GAAG,MAAM;CASX"}

package/build/_modules/ftp/_collections/ftp-url-signer.util.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyNTS_FtpUrlSigner_Util = void 0;
-const tslib_1 = require("tslib");
-const Crypto = tslib_1.__importStar(require("crypto"));
-/**
- * FTP signed-URL ALÁÍRÓ (deep/generikus — `@futdevpro/nts-dynamo`).
- *
- * A böngésző-serve (`<img src>` / letöltő-link) nem tud Bearer-headert küldeni, ezért az
- * `fdp-ftp-service` HTTP-kiszolgálása rövid-/közép-életű **aláírt URL**-lel auth-ol. Ez az util a
- * megosztott titokkal HMAC-SHA256-tal aláírja a `path + exp`-et, és előállítja a serve-URL-t.
- *
- * ⚠️ Az algoritmusnak **BIT-RE egyeznie kell** az `fdp-ftp-service` `FtpUrlSignature_Util`-jával
- * (kanonikus string: `<normalizedPath>\n<expMs>`; normalizálás: leading-slash le + `\`→`/`), különben
- * az ftp elutasítja a signature-t.
- *
- * **PURE (ADR-004):** ez a modul NEM importál `fdp-templates`-et — a `secret`/`serveBaseUrl` a hívó-
- * (consumer-) oldalról jön paraméterként. Így minden FDP-server újrahasználhatja, egyetlen példányban.
- */
-class DyNTS_FtpUrlSigner_Util {
-    /** Path normalizálás — pontosan az ftp-serve normalizálása (leading-slash le, `\`→`/`). */
-    static normalizePath(filePath) {
-        return filePath.replace(/^\/+/, '').replace(/\\/g, '/');
-    }
-    /**
-     * Kanonikus UPLOAD-cél string: `accountId/folderPath/fileName`. A szerver-szerver (app→ftp) upload
-     * ezt írja alá → az ftp ugyanígy építi + validálja. Bit-azonos kell legyen a két oldalon.
-     */
-    static uploadTarget(accountId, folderPath, fileName) {
-        return `${accountId}/${folderPath}/${fileName}`;
-    }
-    /** HMAC-SHA256 a `<normalizedPath>\n<expMs>`-en → hex (az ftp ezt validálja). */
-    static sign(filePath, expMs, secret) {
-        const normalizedPath = DyNTS_FtpUrlSigner_Util.normalizePath(filePath);
-        return Crypto
-            .createHmac('sha256', secret)
-            .update(`${normalizedPath}\n${expMs}`, 'utf8')
-            .digest('hex');
-    }
-    /**
-     * Teljes aláírt serve-URL egy ftp-path-ból: `<serveBaseUrl>/<normalizedPath>?exp=<ms>&sig=<hex>`.
-     * Üres `secret` → üres string (a gate inaktív; a hívó dönt a fallback-ről). `nowMs` injektálható teszthez.
-     */
-    static buildSignedServeUrl(params) {
-        if (!params.secret) {
-            return '';
-        }
-        const now = typeof params.nowMs === 'number' ? params.nowMs : Date.now();
-        const expMs = now + params.ttlMs;
-        const normalizedPath = DyNTS_FtpUrlSigner_Util.normalizePath(params.ftpPath);
-        const sig = DyNTS_FtpUrlSigner_Util.sign(normalizedPath, expMs, params.secret);
-        const base = params.serveBaseUrl.replace(/\/+$/, '');
-        return `${base}/${normalizedPath}?exp=${expMs}&sig=${sig}`;
-    }
-}
-exports.DyNTS_FtpUrlSigner_Util = DyNTS_FtpUrlSigner_Util;
-//# sourceMappingURL=ftp-url-signer.util.js.map

package/build/_modules/ftp/_collections/ftp-url-signer.util.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ftp-url-signer.util.js","sourceRoot":"","sources":["../../../../src/_modules/ftp/_collections/ftp-url-signer.util.ts"],"names":[],"mappings":";;;;AAAA,uDAAiC;AAEjC;;;;;;;;;;;;;GAaG;AACH,MAAa,uBAAuB;IAElC,2FAA2F;IAC3F,MAAM,CAAC,aAAa,CAAC,QAAgB;QACnC,OAAO,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAC1D,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAiB,EAAE,UAAkB,EAAE,QAAgB;QACzE,OAAO,GAAG,SAAS,IAAI,UAAU,IAAI,QAAQ,EAAE,CAAC;IAClD,CAAC;IAED,iFAAiF;IACjF,MAAM,CAAC,IAAI,CAAC,QAAgB,EAAE,KAAa,EAAE,MAAc;QACzD,MAAM,cAAc,GAAW,uBAAuB,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAC/E,OAAO,MAAM;aACV,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC;aAC5B,MAAM,CAAC,GAAG,cAAc,KAAK,KAAK,EAAE,EAAE,MAAM,CAAC;aAC7C,MAAM,CAAC,KAAK,CAAC,CAAC;IACnB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,mBAAmB,CAAC,MAM1B;QACC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YAAC,OAAO,EAAE,CAAC;QAAC,CAAC;QAClC,MAAM,GAAG,GAAW,OAAO,MAAM,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;QACjF,MAAM,KAAK,GAAW,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC;QACzC,MAAM,cAAc,GAAW,uBAAuB,CAAC,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACrF,MAAM,GAAG,GAAW,uBAAuB,CAAC,IAAI,CAAC,cAAc,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;QACvF,MAAM,IAAI,GAAW,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QAC7D,OAAO,GAAG,IAAI,IAAI,cAAc,QAAQ,KAAK,QAAQ,GAAG,EAAE,CAAC;IAC7D,CAAC;CACF;AA3CD,0DA2CC"}

package/build/_modules/ftp/_services/ftp-service.api-service.d.ts

@@ -1,63 +0,0 @@
-/**
- * FTP-kliens KONFIG (a consumer adja át — PURE: nincs fdp-templates-függés).
- * A `fdp-ftp-service` URL-jei + a megosztott aláíró-titok a hívó-oldalról jönnek.
- */
-export interface DyNTS_FtpService_Config {
-    /** az `fdp-ftp-service` API base-URL a szerver-szerver feltöltéshez (pl. `FDP_ftpServiceApiEnv_settings.baseUrl.fromBE`). */
-    apiBaseUrl: string;
-    /** a publikus serve-host az aláírt letöltő-URL-ekhez (pl. `FDP_ftpServiceApiEnv_settings.baseUrl.siteAddress`). */
-    serveBaseUrl: string;
-    /** a megosztott HMAC-titok (env-var `FTP_URL_SIGNING_SECRET`, MÁR létező). Üres → a serve-gate inaktív. */
-    signingSecret: string;
-    /** az upload-endpoint (default `/files/upload`). */
-    uploadFileEndpoint?: string;
-}
-/** FTP-feltöltés bemenete. */
-export interface DyNTS_FtpService_UploadFile_Input {
-    accountId: string;
-    folderPath: string;
-    fileName: string;
-    fileBuffer: Buffer;
-}
-/** FTP-feltöltés válasza. */
-export interface DyNTS_FtpService_UploadFile_Response {
-    filePath: string;
-    ftpPath: string;
-}
-/**
- * FTP Service API kliens (deep/generikus — `@futdevpro/nts-dynamo`).
- * @description A szerver-oldali FTP-KLIENS: a meglévő `fdp-ftp-service` tároló-szervert HÍVJA — fájlt tölt
- *   fel (signed upload), és aláírt serve-URL-t épít. **NEM tartalmaz FTP-szervert.** A korábban az
- *   MP-be / token-service-be duplikált FTP-kliens EGYETLEN, flotta-közös kiváltása.
- *
- *   **PURE (ADR-004):** a config (URL-ek + titok) a `DyNTS_FtpService_Config`-ból, a hívó adja át —
- *   nincs `fdp-templates`-import. Nem singleton: minden consumer a saját config-jával példányosít.
- *
- * @example
- * ```ts
- * const ftp: DyNTS_FtpService_ApiService = new DyNTS_FtpService_ApiService({
- *   apiBaseUrl: FDP_ftpServiceApiEnv_settings.baseUrl.fromBE,
- *   serveBaseUrl: FDP_ftpServiceApiEnv_settings.baseUrl.siteAddress,
- *   signingSecret: process.env.FTP_URL_SIGNING_SECRET || '',
- * });
- * const { ftpPath } = await ftp.uploadFile({ accountId, folderPath: 'invoices/<userId>', fileName, fileBuffer });
- * const url: string = ftp.buildSignedServeUrl(ftpPath);
- * ```
- */
-export declare class DyNTS_FtpService_ApiService {
-    private readonly config;
-    constructor(config: DyNTS_FtpService_Config);
-    private get uploadFileEndpoint();
-    /**
-     * Fájl feltöltése az `fdp-ftp-service`-re (signed, szerver-szerver).
-     * @description A kanonikus upload-célt + lejáratot HMAC-aláírjuk a megosztott titokkal; az ftp ezt
-     *   validálja (a signature a KONKRÉT account+path-hoz köt — más account-ra nem replay-elhető).
-     */
-    uploadFile(input: DyNTS_FtpService_UploadFile_Input): Promise<DyNTS_FtpService_UploadFile_Response>;
-    /**
-     * Aláírt serve-URL egy `ftpPath`-ból (böngésző-letöltéshez). Üres titok → üres string (gate inaktív).
-     * @param ttlMs opcionális egyedi élettartam; default 30 nap.
-     */
-    buildSignedServeUrl(ftpPath: string, ttlMs?: number): string;
-}
-//# sourceMappingURL=ftp-service.api-service.d.ts.map

package/build/_modules/ftp/_services/ftp-service.api-service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ftp-service.api-service.d.ts","sourceRoot":"","sources":["../../../../src/_modules/ftp/_services/ftp-service.api-service.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,6HAA6H;IAC7H,UAAU,EAAE,MAAM,CAAC;IACnB,mHAAmH;IACnH,YAAY,EAAE,MAAM,CAAC;IACrB,2GAA2G;IAC3G,aAAa,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,8BAA8B;AAC9B,MAAM,WAAW,iCAAiC;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,6BAA6B;AAC7B,MAAM,WAAW,oCAAoC;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,2BAA2B;IAEtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;gBAErC,MAAM,EAAE,uBAAuB;IAI3C,OAAO,KAAK,kBAAkB,GAE7B;IAED;;;;OAIG;IACG,UAAU,CAAC,KAAK,EAAE,iCAAiC,GAAG,OAAO,CAAC,oCAAoC,CAAC;IA8BzG;;;OAGG;IACH,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAgC,GAAG,MAAM;CAQtF"}

package/build/_modules/ftp/_services/ftp-service.api-service.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyNTS_FtpService_ApiService = void 0;
-const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
-const api_service_1 = require("../../../_services/core/api.service");
-const api_call_params_control_model_1 = require("../../../_models/control-models/api-call-params.control-model");
-const ftp_url_signer_util_1 = require("../_collections/ftp-url-signer.util");
-/** A signed UPLOAD-aláírás érvényessége (10 perc) — a szerver-szerver app→ftp feltöltés szinkron, rövid ablak elég. */
-const FTP_SIGNED_UPLOAD_TTL_MS = 10 * 60 * 1000;
-/** A signed SERVE-URL alap-élettartama (30 nap) — a felhasználó később is letölti a fájlt. */
-const FTP_SIGNED_SERVE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
-/**
- * FTP Service API kliens (deep/generikus — `@futdevpro/nts-dynamo`).
- * @description A szerver-oldali FTP-KLIENS: a meglévő `fdp-ftp-service` tároló-szervert HÍVJA — fájlt tölt
- *   fel (signed upload), és aláírt serve-URL-t épít. **NEM tartalmaz FTP-szervert.** A korábban az
- *   MP-be / token-service-be duplikált FTP-kliens EGYETLEN, flotta-közös kiváltása.
- *
- *   **PURE (ADR-004):** a config (URL-ek + titok) a `DyNTS_FtpService_Config`-ból, a hívó adja át —
- *   nincs `fdp-templates`-import. Nem singleton: minden consumer a saját config-jával példányosít.
- *
- * @example
- * ```ts
- * const ftp: DyNTS_FtpService_ApiService = new DyNTS_FtpService_ApiService({
- *   apiBaseUrl: FDP_ftpServiceApiEnv_settings.baseUrl.fromBE,
- *   serveBaseUrl: FDP_ftpServiceApiEnv_settings.baseUrl.siteAddress,
- *   signingSecret: process.env.FTP_URL_SIGNING_SECRET || '',
- * });
- * const { ftpPath } = await ftp.uploadFile({ accountId, folderPath: 'invoices/<userId>', fileName, fileBuffer });
- * const url: string = ftp.buildSignedServeUrl(ftpPath);
- * ```
- */
-class DyNTS_FtpService_ApiService {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    get uploadFileEndpoint() {
-        return this.config.uploadFileEndpoint ?? '/files/upload';
-    }
-    /**
-     * Fájl feltöltése az `fdp-ftp-service`-re (signed, szerver-szerver).
-     * @description A kanonikus upload-célt + lejáratot HMAC-aláírjuk a megosztott titokkal; az ftp ezt
-     *   validálja (a signature a KONKRÉT account+path-hoz köt — más account-ra nem replay-elhető).
-     */
-    async uploadFile(input) {
-        const expMs = Date.now() + FTP_SIGNED_UPLOAD_TTL_MS;
-        const uploadTarget = ftp_url_signer_util_1.DyNTS_FtpUrlSigner_Util.uploadTarget(input.accountId, input.folderPath, input.fileName);
-        const sig = ftp_url_signer_util_1.DyNTS_FtpUrlSigner_Util.sign(uploadTarget, expMs, this.config.signingSecret);
-        return await api_service_1.DyNTS_ApiService.startApiCall(new api_call_params_control_model_1.DyNTS_ApiCall_Params({
-            name: 'uploadFile (DyNTS_FtpService)',
-            type: fsm_dynamo_1.DyFM_HttpCallType.post,
-            baseUrl: this.config.apiBaseUrl,
-            endpoint: this.uploadFileEndpoint,
-            httpOptions: new api_call_params_control_model_1.DyNTS_HttpOptions({
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-            }),
-        }), {
-            body: {
-                accountId: input.accountId,
-                folderPath: input.folderPath,
-                fileName: input.fileName,
-                fileBuffer: input.fileBuffer.toString('base64'),
-                exp: expMs,
-                sig: sig,
-            },
-        });
-    }
-    /**
-     * Aláírt serve-URL egy `ftpPath`-ból (böngésző-letöltéshez). Üres titok → üres string (gate inaktív).
-     * @param ttlMs opcionális egyedi élettartam; default 30 nap.
-     */
-    buildSignedServeUrl(ftpPath, ttlMs = FTP_SIGNED_SERVE_TTL_MS) {
-        return ftp_url_signer_util_1.DyNTS_FtpUrlSigner_Util.buildSignedServeUrl({
-            serveBaseUrl: this.config.serveBaseUrl,
-            ftpPath: ftpPath,
-            ttlMs: ttlMs,
-            secret: this.config.signingSecret,
-        });
-    }
-}
-exports.DyNTS_FtpService_ApiService = DyNTS_FtpService_ApiService;
-//# sourceMappingURL=ftp-service.api-service.js.map

package/build/_modules/ftp/_services/ftp-service.api-service.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ftp-service.api-service.js","sourceRoot":"","sources":["../../../../src/_modules/ftp/_services/ftp-service.api-service.ts"],"names":[],"mappings":";;;AAAA,sDAA0D;AAE1D,qEAAuE;AACvE,iHAAwH;AACxH,6EAA8E;AAE9E,uHAAuH;AACvH,MAAM,wBAAwB,GAAW,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AACxD,8FAA8F;AAC9F,MAAM,uBAAuB,GAAW,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AA+BjE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAa,2BAA2B;IAErB,MAAM,CAA0B;IAEjD,YAAY,MAA+B;QACzC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED,IAAY,kBAAkB;QAC5B,OAAO,IAAI,CAAC,MAAM,CAAC,kBAAkB,IAAI,eAAe,CAAC;IAC3D,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,UAAU,CAAC,KAAwC;QACvD,MAAM,KAAK,GAAW,IAAI,CAAC,GAAG,EAAE,GAAG,wBAAwB,CAAC;QAC5D,MAAM,YAAY,GAAW,6CAAuB,CAAC,YAAY,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;QACrH,MAAM,GAAG,GAAW,6CAAuB,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QAEjG,OAAO,MAAM,8BAAgB,CAAC,YAAY,CACxC,IAAI,oDAAoB,CAAC;YACvB,IAAI,EAAE,+BAA+B;YACrC,IAAI,EAAE,8BAAiB,CAAC,IAAI;YAC5B,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU;YAC/B,QAAQ,EAAE,IAAI,CAAC,kBAAkB;YACjC,WAAW,EAAE,IAAI,iDAAiB,CAAC;gBACjC,OAAO,EAAE;oBACP,cAAc,EAAE,kBAAkB;iBACnC;aACF,CAAC;SACH,CAAC,EACF;YACE,IAAI,EAAE;gBACJ,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,QAAQ,EAAE,KAAK,CAAC,QAAQ;gBACxB,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC;gBAC/C,GAAG,EAAE,KAAK;gBACV,GAAG,EAAE,GAAG;aACT;SACF,CACF,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,mBAAmB,CAAC,OAAe,EAAE,QAAgB,uBAAuB;QAC1E,OAAO,6CAAuB,CAAC,mBAAmB,CAAC;YACjD,YAAY,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY;YACtC,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,KAAK;YACZ,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa;SAClC,CAAC,CAAC;IACL,CAAC;CACF;AA3DD,kEA2DC"}