@futdevpro/nts-dynamo 1.15.154 → 1.15.156

package/build/_services/core/auth.service.d.ts

@@ -1,130 +1,130 @@
-import { Request, Response } from 'express';
-import { DyNTS_SingletonService } from '../base/singleton.service';
-/**
- * Extend this class as an Auth Service implementation
- *
- * You should use singleton instance getting function by implementing a
- * static getInstance() function
- * @example
- * export class AuthService extends DyNTS_AuthService {
- *
- *   static getInstance(): AuthService {
- *     return AuthService.getSingletonInstance();
- *   }
- *   ...
- */
-export declare abstract class DyNTS_AuthService extends DyNTS_SingletonService {
-    readonly serviceName: string;
-    readonly defaultErrorUserMsg: string;
-    /**
-     * this function returns the 'authorization' header from the Request,
-     * or throws error, if its missing
-     *
-     * @param req
-     * @returns
-     */
-    getTokenFromRequest(req: Request): string;
-    /**
-     * You need to implement a token validation logic,
-     * when if the token is invalid, or the authentication fails, it sends or throws an error
-     *
-     * @example
-     *
-     * async authenticateToken(req: Request, res: Response, next: NextFunction) {
-     *   try {
-     *     let token = AuthService.getTokenFromRequest(req);
-     *     token = await AuthService.verifyToken(token);
-     *
-     *     DyFM_Log.success('token authenticated');
-     *     res.setHeader('authorization', `Bearer ${token}`);
-     *     next();
-     *   } catch (error) {
-     *     error = new DyFM_Error({
-     *       status: 401,
-     *       message: `authenticateToken (WB-ERROR)`,
-     *       addECToUserMsg: true,
-     *       userMessage: `Authorization failed.`,
-     *       error
-     *     });
-     *     DyFM_Log.error(error?.message, error);
-     *
-     *     res.status(error.status);
-     *     res.send(error);
-     *   }
-     * }
-     * */
-    abstract authenticate_token: (req: Request, res: Response) => Promise<void>;
-    /**
-     * You need to implement a token validation logic,
-     * when if the token is invalid, or the authentication fails, it sends or throws an error
-     *
-     * @param req
-     * @param res
-     * @param next
-     *
-     * @example
-     *
-     * async authenticate_tokenSelf(req: Request, res: Response, next: NextFunction): Promise<void> {
-     *   try {
-     *     let token = AuthService.getTokenFromRequest(req);
-     *     token = await AuthService.verifyTokenSelf(token, req?.params?.userId);
-     *     DyFM_Log.success('selftoken authenticated');
-     *
-     *     res.setHeader('authorization', `Bearer ${token}`);
-     *     next();
-     *   } catch (error) {
-     *     error = new DyFM_Error({
-     *       status: 401,
-     *       message: `authenticate_tokenSelf (WB-ERROR)`,
-     *       addECToUserMsg: true,
-     *       userMessage: `Authorization failed.`,
-     *       error
-     *     });
-     *     DyFM_Log.error(error?.message, error);
-     *
-     *     res.status(error.status);
-     *     res.send(error);
-     *   }
-     * }
-     *
-     */
-    abstract authenticate_tokenSelf: (req: Request, res: Response) => Promise<void>;
-    /**
-     * Authenticate Token for Permission to Access UsageData
-     * @param req
-     * @param res
-     * @param next
-     *
-     * @example
-     * You need to implement a token validation logic,
-     * when if the token is invalid, or the authentication fails, it sends or throws an error
-     *
-     * async authTokenPermAccUsageData(req: Request, res: Response, next: NextFunction): Promise<void> {
-     *   AuthService.authTokenAndPerm(req, res, next, Permission.accessUsageData);
-     * }
-     */
-    abstract authenticate_tokenPerm_accUsageData: (req: Request, res: Response) => Promise<void>;
-    /**
-     * The DynamoNTS System is using this to get issuer, that will be set on DBServices
-     * Don't throw error in this function, since it will be used in every request
-     * @param req
-     *
-     * @example
-     * getAccountIdFromRequest(req: Request): string {
-     *   try {
-     *     const authHeader = req.headers['authorization'];
-     *     const token = authHeader.split(' ')[1];
-     *     return this.getAccountIdFromToken(token);
-     *   } catch {
-     *     return undefined;
-     *   }
-     * }
-     */
-    abstract getIssuerFromRequest(req: Request): string;
-    /**
-     * Basic Module: UsageModule uses this function
-     * @param req
-     */
-    abstract getUsernameFromRequest(req: Request): string;
-}
+import { Request, Response } from 'express';
+import { DyNTS_SingletonService } from '../base/singleton.service';
+/**
+ * Extend this class as an Auth Service implementation
+ *
+ * You should use singleton instance getting function by implementing a
+ * static getInstance() function
+ * @example
+ * export class AuthService extends DyNTS_AuthService {
+ *
+ *   static getInstance(): AuthService {
+ *     return AuthService.getSingletonInstance();
+ *   }
+ *   ...
+ */
+export declare abstract class DyNTS_AuthService extends DyNTS_SingletonService {
+    readonly serviceName: string;
+    readonly defaultErrorUserMsg: string;
+    /**
+     * this function returns the 'authorization' header from the Request,
+     * or throws error, if its missing
+     *
+     * @param req
+     * @returns
+     */
+    getTokenFromRequest(req: Request): string;
+    /**
+     * You need to implement a token validation logic,
+     * when if the token is invalid, or the authentication fails, it sends or throws an error
+     *
+     * @example
+     *
+     * async authenticateToken(req: Request, res: Response, next: NextFunction) {
+     *   try {
+     *     let token = AuthService.getTokenFromRequest(req);
+     *     token = await AuthService.verifyToken(token);
+     *
+     *     DyFM_Log.success('token authenticated');
+     *     res.setHeader('authorization', `Bearer ${token}`);
+     *     next();
+     *   } catch (error) {
+     *     error = new DyFM_Error({
+     *       status: 401,
+     *       message: `authenticateToken (WB-ERROR)`,
+     *       addECToUserMsg: true,
+     *       userMessage: `Authorization failed.`,
+     *       error
+     *     });
+     *     DyFM_Log.error(error?.message, error);
+     *
+     *     res.status(error.status);
+     *     res.send(error);
+     *   }
+     * }
+     * */
+    abstract authenticate_token: (req: Request, res: Response) => Promise<void>;
+    /**
+     * You need to implement a token validation logic,
+     * when if the token is invalid, or the authentication fails, it sends or throws an error
+     *
+     * @param req
+     * @param res
+     * @param next
+     *
+     * @example
+     *
+     * async authenticate_tokenSelf(req: Request, res: Response, next: NextFunction): Promise<void> {
+     *   try {
+     *     let token = AuthService.getTokenFromRequest(req);
+     *     token = await AuthService.verifyTokenSelf(token, req?.params?.userId);
+     *     DyFM_Log.success('selftoken authenticated');
+     *
+     *     res.setHeader('authorization', `Bearer ${token}`);
+     *     next();
+     *   } catch (error) {
+     *     error = new DyFM_Error({
+     *       status: 401,
+     *       message: `authenticate_tokenSelf (WB-ERROR)`,
+     *       addECToUserMsg: true,
+     *       userMessage: `Authorization failed.`,
+     *       error
+     *     });
+     *     DyFM_Log.error(error?.message, error);
+     *
+     *     res.status(error.status);
+     *     res.send(error);
+     *   }
+     * }
+     *
+     */
+    abstract authenticate_tokenSelf: (req: Request, res: Response) => Promise<void>;
+    /**
+     * Authenticate Token for Permission to Access UsageData
+     * @param req
+     * @param res
+     * @param next
+     *
+     * @example
+     * You need to implement a token validation logic,
+     * when if the token is invalid, or the authentication fails, it sends or throws an error
+     *
+     * async authTokenPermAccUsageData(req: Request, res: Response, next: NextFunction): Promise<void> {
+     *   AuthService.authTokenAndPerm(req, res, next, Permission.accessUsageData);
+     * }
+     */
+    abstract authenticate_tokenPerm_accUsageData: (req: Request, res: Response) => Promise<void>;
+    /**
+     * The DynamoNTS System is using this to get issuer, that will be set on DBServices
+     * Don't throw error in this function, since it will be used in every request
+     * @param req
+     *
+     * @example
+     * getAccountIdFromRequest(req: Request): string {
+     *   try {
+     *     const authHeader = req.headers['authorization'];
+     *     const token = authHeader.split(' ')[1];
+     *     return this.getAccountIdFromToken(token);
+     *   } catch {
+     *     return undefined;
+     *   }
+     * }
+     */
+    abstract getIssuerFromRequest(req: Request): string;
+    /**
+     * Basic Module: UsageModule uses this function
+     * @param req
+     */
+    abstract getUsernameFromRequest(req: Request): string;
+}
 //# sourceMappingURL=auth.service.d.ts.map

package/build/_services/core/auth.service.js

@@ -1,60 +1,60 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyNTS_AuthService = void 0;
-const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
-const singleton_service_1 = require("../base/singleton.service");
-const global_settings_const_1 = require("../../_collections/global-settings.const");
-/**
- * Extend this class as an Auth Service implementation
- *
- * You should use singleton instance getting function by implementing a
- * static getInstance() function
- * @example
- * export class AuthService extends DyNTS_AuthService {
- *
- *   static getInstance(): AuthService {
- *     return AuthService.getSingletonInstance();
- *   }
- *   ...
- */
-class DyNTS_AuthService extends singleton_service_1.DyNTS_SingletonService {
-    serviceName = 'AuthService';
-    defaultErrorUserMsg = `We encountered an unhandled Auth Error, ` +
-        `\nplease contact the responsible development team.`;
-    /**
-     * this function returns the 'authorization' header from the Request,
-     * or throws error, if its missing
-     *
-     * @param req
-     * @returns
-     */
-    getTokenFromRequest(req) {
-        const authHeader = req?.headers?.['authorization'];
-        if (!authHeader) {
-            throw new fsm_dynamo_1.DyFM_Error({
-                status: 401,
-                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-GT0`,
-                addECToUserMsg: true,
-                message: 'AuthHeader missing!',
-                userMessage: this.defaultErrorUserMsg,
-                issuerService: this.serviceName,
-                confidentialContent: { headers: req?.headers },
-            });
-        }
-        const token = authHeader.split(' ')[1];
-        if (!token) {
-            throw new fsm_dynamo_1.DyFM_Error({
-                status: 401,
-                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-GT1`,
-                addECToUserMsg: true,
-                message: 'Token missing!',
-                userMessage: this.defaultErrorUserMsg,
-                issuerService: this.serviceName,
-                confidentialContent: { headers: req?.headers },
-            });
-        }
-        return token;
-    }
-}
-exports.DyNTS_AuthService = DyNTS_AuthService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyNTS_AuthService = void 0;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const singleton_service_1 = require("../base/singleton.service");
+const global_settings_const_1 = require("../../_collections/global-settings.const");
+/**
+ * Extend this class as an Auth Service implementation
+ *
+ * You should use singleton instance getting function by implementing a
+ * static getInstance() function
+ * @example
+ * export class AuthService extends DyNTS_AuthService {
+ *
+ *   static getInstance(): AuthService {
+ *     return AuthService.getSingletonInstance();
+ *   }
+ *   ...
+ */
+class DyNTS_AuthService extends singleton_service_1.DyNTS_SingletonService {
+    serviceName = 'AuthService';
+    defaultErrorUserMsg = `We encountered an unhandled Auth Error, ` +
+        `\nplease contact the responsible development team.`;
+    /**
+     * this function returns the 'authorization' header from the Request,
+     * or throws error, if its missing
+     *
+     * @param req
+     * @returns
+     */
+    getTokenFromRequest(req) {
+        const authHeader = req?.headers?.['authorization'];
+        if (!authHeader) {
+            throw new fsm_dynamo_1.DyFM_Error({
+                status: 401,
+                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-GT0`,
+                addECToUserMsg: true,
+                message: 'AuthHeader missing!',
+                userMessage: this.defaultErrorUserMsg,
+                issuerService: this.serviceName,
+                confidentialContent: { headers: req?.headers },
+            });
+        }
+        const token = authHeader.split(' ')[1];
+        if (!token) {
+            throw new fsm_dynamo_1.DyFM_Error({
+                status: 401,
+                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-AS0-GT1`,
+                addECToUserMsg: true,
+                message: 'Token missing!',
+                userMessage: this.defaultErrorUserMsg,
+                issuerService: this.serviceName,
+                confidentialContent: { headers: req?.headers },
+            });
+        }
+        return token;
+    }
+}
+exports.DyNTS_AuthService = DyNTS_AuthService;
 //# sourceMappingURL=auth.service.js.map

package/build/_services/core/collection-growth-monitor.service.d.ts

@@ -1,77 +1,77 @@
-import { DyNTS_SingletonServiceBase } from '../base/singleton.service-base';
-/**
- * FR-258 / SR-4 — Collection Growth Monitor (proactive companion to DyNTS_MemoryGuard).
- *
- * The MemoryGuard is REACTIVE: it fires when the heap is already near OOM. This monitor is
- * PROACTIVE: it periodically samples each registered collection's document count (via the cheap,
- * scan-free `estimatedDocumentCount()`) and raises a warning into the Errors-sink BEFORE a bloated
- * collection can be loaded into heap and GC-thrash the process (the 2026-06-23 overseer incident:
- * `cdp_report_details_archiveds` reached 3 GB / `pipeline_jobs` 2 GB, unbounded).
- *
- * It pairs with SR-1/SR-2 (declarative retention TTL): TTL keeps collections bounded; this monitor
- * surfaces the ones that AREN'T (no retention declared, or growing faster than retention prunes) so
- * an operator can add `retention` before it becomes an OOM. Pure observation — never deletes.
- *
- * Like the MemoryGuard it is a singleton, idempotent, fully non-fatal (a monitoring layer must never
- * crash a server), and its timer is `unref()`-ed so it can't keep the process alive on its own.
- */
-export interface DyNTS_CollectionGrowthMonitor_Config {
-    /** Master switch. Default: `DyNTS_global_settings.collectionGrowthMonitor.enabled` (true). */
-    enabled?: boolean;
-    /** Poll cadence in ms. Default: 300000 (5 min) — collection growth is slow, no need to poll often. */
-    pollIntervalMs?: number;
-    /** Warn when a collection's document count exceeds this. Default: 250000. */
-    sizeThresholdDocCount?: number;
-    /** Warn when a collection grew by more than this percent since the previous poll. Default: 50. */
-    growthRateThresholdPct?: number;
-    /** Re-alert cooldown per collection per alert-kind, in ms (anti-flood). Default: 3600000 (1 h). */
-    reAlertCooldownMs?: number;
-}
-/** One growth finding to surface to the Errors-sink. */
-export interface DyNTS_CollectionGrowthAlert {
-    kind: 'size' | 'growth';
-    dataName: string;
-    message: string;
-    detail: Record<string, unknown>;
-}
-interface CollectionSnapshot {
-    docCount: number;
-    atMs: number;
-}
-export declare class DyNTS_CollectionGrowthMonitor extends DyNTS_SingletonServiceBase {
-    static getInstance(): DyNTS_CollectionGrowthMonitor;
-    private timer;
-    private installed;
-    private pollIntervalMs;
-    private sizeThresholdDocCount;
-    private growthRateThresholdPct;
-    private reAlertCooldownMs;
-    private readonly lastSnapshotByCollection;
-    /** Last time we alerted, keyed by `${dataName}:${kind}` — for the anti-flood cooldown. */
-    private readonly lastAlertAtByKey;
-    protected constructor();
-    /**
-     * Start the monitor. Idempotent (a second call is a no-op). `config` overrides
-     * `DyNTS_global_settings.collectionGrowthMonitor`, which overrides the built-in defaults. NEVER
-     * throws — every error is try/catch-ed and descriptively logged.
-     */
-    install(config?: DyNTS_CollectionGrowthMonitor_Config): void;
-    /**
-     * Pure decision core (unit-tested): given a fresh count + the previous snapshot, return the alerts
-     * to raise. NEVER does I/O. A `size` alert fires when `count > sizeThreshold`; a `growth` alert
-     * fires when the collection grew by more than `growthRatePct` since the last snapshot (needs a
-     * non-zero previous count).
-     */
-    static evaluateGrowth(dataName: string, count: number, last: CollectionSnapshot | undefined, sizeThreshold: number, growthRatePct: number, retentionTtlSec?: number): DyNTS_CollectionGrowthAlert[];
-    /**
-     * One poll cycle: sample every registered collection's `estimatedDocumentCount()` (scan-free) and
-     * raise cooldown-gated warnings. Fully non-fatal — a failure on one collection never aborts the rest.
-     */
-    private poll;
-    /** Raise one alert to the Errors-sink, gated by the per-(collection,kind) cooldown to avoid flooding. */
-    private emitAlert;
-    /** Test-only teardown: stop the timer + clear state so specs don't leak between runs. */
-    _teardownForTesting(): void;
-}
-export {};
+import { DyNTS_SingletonServiceBase } from '../base/singleton.service-base';
+/**
+ * FR-258 / SR-4 — Collection Growth Monitor (proactive companion to DyNTS_MemoryGuard).
+ *
+ * The MemoryGuard is REACTIVE: it fires when the heap is already near OOM. This monitor is
+ * PROACTIVE: it periodically samples each registered collection's document count (via the cheap,
+ * scan-free `estimatedDocumentCount()`) and raises a warning into the Errors-sink BEFORE a bloated
+ * collection can be loaded into heap and GC-thrash the process (the 2026-06-23 overseer incident:
+ * `cdp_report_details_archiveds` reached 3 GB / `pipeline_jobs` 2 GB, unbounded).
+ *
+ * It pairs with SR-1/SR-2 (declarative retention TTL): TTL keeps collections bounded; this monitor
+ * surfaces the ones that AREN'T (no retention declared, or growing faster than retention prunes) so
+ * an operator can add `retention` before it becomes an OOM. Pure observation — never deletes.
+ *
+ * Like the MemoryGuard it is a singleton, idempotent, fully non-fatal (a monitoring layer must never
+ * crash a server), and its timer is `unref()`-ed so it can't keep the process alive on its own.
+ */
+export interface DyNTS_CollectionGrowthMonitor_Config {
+    /** Master switch. Default: `DyNTS_global_settings.collectionGrowthMonitor.enabled` (true). */
+    enabled?: boolean;
+    /** Poll cadence in ms. Default: 300000 (5 min) — collection growth is slow, no need to poll often. */
+    pollIntervalMs?: number;
+    /** Warn when a collection's document count exceeds this. Default: 250000. */
+    sizeThresholdDocCount?: number;
+    /** Warn when a collection grew by more than this percent since the previous poll. Default: 50. */
+    growthRateThresholdPct?: number;
+    /** Re-alert cooldown per collection per alert-kind, in ms (anti-flood). Default: 3600000 (1 h). */
+    reAlertCooldownMs?: number;
+}
+/** One growth finding to surface to the Errors-sink. */
+export interface DyNTS_CollectionGrowthAlert {
+    kind: 'size' | 'growth';
+    dataName: string;
+    message: string;
+    detail: Record<string, unknown>;
+}
+interface CollectionSnapshot {
+    docCount: number;
+    atMs: number;
+}
+export declare class DyNTS_CollectionGrowthMonitor extends DyNTS_SingletonServiceBase {
+    static getInstance(): DyNTS_CollectionGrowthMonitor;
+    private timer;
+    private installed;
+    private pollIntervalMs;
+    private sizeThresholdDocCount;
+    private growthRateThresholdPct;
+    private reAlertCooldownMs;
+    private readonly lastSnapshotByCollection;
+    /** Last time we alerted, keyed by `${dataName}:${kind}` — for the anti-flood cooldown. */
+    private readonly lastAlertAtByKey;
+    protected constructor();
+    /**
+     * Start the monitor. Idempotent (a second call is a no-op). `config` overrides
+     * `DyNTS_global_settings.collectionGrowthMonitor`, which overrides the built-in defaults. NEVER
+     * throws — every error is try/catch-ed and descriptively logged.
+     */
+    install(config?: DyNTS_CollectionGrowthMonitor_Config): void;
+    /**
+     * Pure decision core (unit-tested): given a fresh count + the previous snapshot, return the alerts
+     * to raise. NEVER does I/O. A `size` alert fires when `count > sizeThreshold`; a `growth` alert
+     * fires when the collection grew by more than `growthRatePct` since the last snapshot (needs a
+     * non-zero previous count).
+     */
+    static evaluateGrowth(dataName: string, count: number, last: CollectionSnapshot | undefined, sizeThreshold: number, growthRatePct: number, retentionTtlSec?: number): DyNTS_CollectionGrowthAlert[];
+    /**
+     * One poll cycle: sample every registered collection's `estimatedDocumentCount()` (scan-free) and
+     * raise cooldown-gated warnings. Fully non-fatal — a failure on one collection never aborts the rest.
+     */
+    private poll;
+    /** Raise one alert to the Errors-sink, gated by the per-(collection,kind) cooldown to avoid flooding. */
+    private emitAlert;
+    /** Test-only teardown: stop the timer + clear state so specs don't leak between runs. */
+    _teardownForTesting(): void;
+}
+export {};
 //# sourceMappingURL=collection-growth-monitor.service.d.ts.map