@futdevpro/nts-dynamo 1.15.133 → 1.15.135

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

@@ -47,6 +47,13 @@ import { DyNTS_DBService } from './db.service';
  *
  * Explicit `fields: ['_id']`-vel meg vizsgaltathato, ha valamiert kell.
  */
+/**
+ * BFR-OVERSEER-011 (b): e dokumentum-szám fölött a searchData memóriabeli lapozása warn-t ad —
+ * a teljes-kollekció-betöltés hívóhelyei incidens ELŐTT láthatóvá válnak (mérve: 5 hívóhely,
+ * GC-thrash, ~11 óra akadozó CI).
+ */
+const DyNTS_SEARCHDATA_INMEMORY_WARN_THRESHOLD: number = 1000;
+
 const COMPARE_DATA_METADATA_SKIP_FIELDS: ReadonlySet<string> = new Set<string>([
   '_id',
   '__created',
@@ -1695,7 +1702,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);
           });
@@ -1780,9 +1790,20 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
   /**
    * Search the data list based on the search query
    * Sorts and filters the data list based on the search query
-   * 
+   *
+   * ⚠️ **BFR-OVERSEER-011 — a lapozás MEMÓRIÁBAN történik, a `pageSize` NEM DB-limit!**
+   * A metódus a TELJES (elő-szűrt) kollekciót betölti (`findDataList`/`getAll` limit nélkül),
+   * memóriában rendez/szűr, és CSAK UTÁNA `slice`-ol — egy `searchData({ pageSize: 1 })` is a
+   * teljes kollekciót húzza a heap-be (mért incidens: GC-thrash + event-loop-megállás nagy
+   * kollekción). **Mikor MIT használj:**
+   * - lapozott lekérdezés nagy kollekción → `DyNTS_DBService.findWithPaging(filter, page, pageSize, sort)`
+   *   (DB-szintű `.skip().limit()`);
+   * - „legfrissebb N" → `findDataList(filter, undefined, { projection, sort, limit })`;
+   * - `searchData` CSAK kis/korlátos kollekcióra vagy már memóriában lévő `dataList`-re való
+   *   (komplex, memóriabeli szűrés/rendezés).
+   *
    * NOTE: For more simple and with better performance and if you don't need sorting, use findDataList instead.
-   * 
+   *
    * @example
    * ```ts
    * const searchResult = await this.searchData({
@@ -1860,6 +1881,18 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
         } else {
           dataList = await this.getAll();
         }
+
+        // BFR-OVERSEER-011 (b) runtime-guard: a memóriabeli lapozás a TELJES kollekciót húzza be —
+        // nagy halmazon ez GC-thrash-t okoz (mért incidens: ~43k dok/host, event-loop-megállás).
+        // A warn a hívóhelyet AZONNAL felszínre hozza, incidens előtt.
+        if (dataList.length > DyNTS_SEARCHDATA_INMEMORY_WARN_THRESHOLD) {
+          DyFM_Log.warn(
+            `searchData('${this.dataParams.dataName}'): ${dataList.length} docs loaded INTO MEMORY for ` +
+            `in-memory paging (pageSize is NOT a DB-limit!). For paged queries use ` +
+            `DyNTS_DBService.findWithPaging(); for "latest N" use findDataList(filter, undefined, ` +
+            `{ projection, sort, limit }).`
+          );
+        }
       } else {
         if (Object.keys(preFilter).length) {
           DyFM_Log.H_warn(