@futdevpro/nts-dynamo 1.15.154 → 1.15.156

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futdevpro/nts-dynamo",
-  "version": "01.15.154",
+  "version": "01.15.156",
   "description": "Dynamic NodeTS (NodeJS-Typescript), MongoDB Backend System Framework by Future Development Program Ltd.",
   "DyBu_settings": {
     "packageType": "server-package",
@@ -411,16 +411,16 @@
     "better-sqlite3": "~12.4.1",
     "@futdevpro/fsm-dynamo": "1.16.40",
     "@types/express": "4.17.21",
-    "@types/geoip-lite": "~1.4.1",
+    "@types/geoip-lite": "~1.4.4",
     "@types/node": "~24.1.0",
-    "axios": ">=1.8.1 <2",
-    "body-parser": "~1.20.2",
+    "axios": ">=1.19.0 <2",
+    "body-parser": ">=1.20.6 <2",
     "discord.js": "~14.24.2",
-    "dotenv": "~16.5.0",
-    "express": "4.21.2",
-    "geoip-lite": "~1.4.7",
-    "mongoose": "~8.10.1",
-    "nodemailer": ">=6.9.4 <8",
+    "dotenv": ">=16.6.1 <17",
+    "express": ">=4.22.1 <5",
+    "geoip-lite": ">=2.0.3 <3",
+    "mongoose": ">=8.24.1 <9",
+    "nodemailer": ">=9.0.5 <10",
     "openai": "~5.23.2",
     "rxjs": "7.8.1",
     "ts-node": "~10.9.2"
@@ -438,6 +438,12 @@
     "discord.js": {
       "optional": true
     },
+    "@types/geoip-lite": {
+      "optional": true
+    },
+    "geoip-lite": {
+      "optional": true
+    },
     "openai": {
       "optional": true
     }

package/src/_models/control-models/app-params.control-model.spec.ts

@@ -1,9 +1,9 @@
 
-import { DyFM_EnvironmentFlag, DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
-
-import { DyNTS_App_Params } from './app-params.control-model';
+import { DyFM_EnvironmentFlag, DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+
+import { DyNTS_App_Params } from './app-params.control-model';
 
 describe('| DyNTS_App_Params', () => {
   let originalEnv: any;
@@ -209,21 +209,21 @@ describe('| DyNTS_App_Params', () => {
     expect(logSpy).toHaveBeenCalled();
   });
 
-  it('| should warn without logging a malformed credential-bearing dbUri', () => {
-    const logSpy = spyOn(DyFM_Log, 'warn');
-    const canary: string = 'mongodb://canary-user:canary-secret@localhost:27017//testdb';
-
-    const params: DyNTS_App_Params = {
-      name: 'TestApp',
-      version: '1.0.0',
-      dbName: 'testdb',
-      dbUri: canary,
-    };
-
-    new DyNTS_App_Params(params);
-
-    expect(logSpy).toHaveBeenCalled();
-    expect(JSON.stringify(logSpy.calls.allArgs())).not.toContain(canary);
-    expect(JSON.stringify(logSpy.calls.allArgs())).not.toContain('canary-secret');
-  });
-});
+  it('| should warn without logging a malformed credential-bearing dbUri', () => {
+    const logSpy = spyOn(DyFM_Log, 'warn');
+    const canary: string = 'mongodb://canary-user:canary-secret@localhost:27017//testdb';
+
+    const params: DyNTS_App_Params = {
+      name: 'TestApp',
+      version: '1.0.0',
+      dbName: 'testdb',
+      dbUri: canary,
+    };
+
+    new DyNTS_App_Params(params);
+
+    expect(logSpy).toHaveBeenCalled();
+    expect(JSON.stringify(logSpy.calls.allArgs())).not.toContain(canary);
+    expect(JSON.stringify(logSpy.calls.allArgs())).not.toContain('canary-secret');
+  });
+});

package/src/_models/control-models/app-params.control-model.ts

@@ -1,8 +1,8 @@
-import { ConnectOptions } from 'mongoose';
-
-import { DyFM_Log, DyFM_String } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { ConnectOptions } from 'mongoose';
+
+import { DyFM_Log, DyFM_String } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
 
 /**
  * This will hold and set the basic settings of an application
@@ -84,11 +84,11 @@ export class DyNTS_App_Params {
         this.dbUri = set.dbUri;
       }
 
-      if (this.dbUri.split('//').length > 2) {
-        DyFM_Log.warn(
-          'DyNTS_App_Params.constructor: dbUri should not contain more than one "//".'
-        );
-      }
+      if (this.dbUri.split('//').length > 2) {
+        DyFM_Log.warn(
+          'DyNTS_App_Params.constructor: dbUri should not contain more than one "//".'
+        );
+      }
 
       this.dbOptions = set.dbOptions ?? {
         directConnection: true,

package/src/_models/control-models/endpoint-params.control-model.spec.ts

@@ -438,14 +438,14 @@ describe('| DyNTS_Endpoint_Params', () => {
       expect(logInfoSpy).toHaveBeenCalled();
     });
 
-    it('| should handle issuer retrieval error', async () => {
-      (DyNTS_GlobalService.getAuthService as jasmine.Spy).and.returnValue({
-        getIssuerFromRequest: () => { throw new Error('Auth error'); },
-      } as any);
-      const logWarnSpy = spyOn(DyFM_Log, 'warn');
-      const taskSpy = jasmine.createSpy('task').and.callFake(async (req: Request, res: Response, issuer: string) => {
-        res.send({ success: true });
-      });
+    it('| should handle issuer retrieval error', async () => {
+      (DyNTS_GlobalService.getAuthService as jasmine.Spy).and.returnValue({
+        getIssuerFromRequest: () => { throw new Error('Auth error'); },
+      } as any);
+      const logErrorSpy: jasmine.Spy = spyOn(DyFM_Log, 'error');
+      const taskSpy = jasmine.createSpy('task').and.callFake(async (req: Request, res: Response, issuer: string) => {
+        res.send({ success: true });
+      });
       const params = new DyNTS_Endpoint_Params({
         name: 'testEndpoint',
         type: DyFM_HttpCallType.get,
@@ -454,12 +454,15 @@ describe('| DyNTS_Endpoint_Params', () => {
         logRequest: false,
       });
 
-      const execution = params.getFullExecution();
-      await execution(mockRequest as Request, mockResponse as Response);
-
-      expect(logWarnSpy).toHaveBeenCalled();
-      expect(taskSpy).toHaveBeenCalledWith(mockRequest, mockResponse, 'unknown-issuer');
-    });
+      const execution = params.getFullExecution();
+      await execution(mockRequest as Request, mockResponse as Response);
+
+      expect(logErrorSpy).toHaveBeenCalledWith(
+        '[DyNTS safe diagnostic]',
+        jasmine.objectContaining({ code: 'DYNTS|ENDPOINT|ISSUER_RESOLUTION_FAILURE' })
+      );
+      expect(taskSpy).toHaveBeenCalledWith(mockRequest, mockResponse, 'unknown-issuer');
+    });
 
     it('| should handle DyFM_Error with status code', async () => {
       const error = new DyFM_Error({
@@ -541,7 +544,7 @@ describe('| DyNTS_Endpoint_Params', () => {
     });
 
     // FR-067: axios-style HTTP errors (with `status` field) — wrap-status onorzes.
-    it('| FR-067: should preserve downstream HTTP status when wrapping axios-style error', async () => {
+    it('| FR-067: should preserve downstream HTTP status when wrapping axios-style error', async () => {
       const error = Object.assign(new Error('Upstream 502'), { status: 502 });
       const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.reject(error));
       const params = new DyNTS_Endpoint_Params({
@@ -557,8 +560,90 @@ describe('| DyNTS_Endpoint_Params', () => {
       await execution(mockRequest as Request, mockResponse as Response);
       await new Promise(resolve => setTimeout(resolve, 50));
 
-      expect(statusSpy).toHaveBeenCalledWith(502);
-    });
+      expect(statusSpy).toHaveBeenCalledWith(502);
+    });
+
+    it(
+      '| BFR-CTM-018: projects endpoint and handler failures without logging or responding raw content',
+      async (): Promise<void> => {
+        const errorCanary: string = 'raw-message secret workbook-cell@example.test';
+        const handlerCanary: string = 'handler-stack bearer-private-token';
+        const requestCanary: string = 'private-sheet-name';
+        const originalHighDetailedLogs: boolean = DyNTS_global_settings.log_settings.highDetailedLogs;
+        const originalGlobalErrorHandler: typeof DyNTS_GlobalService.globalErrorHandler =
+          DyNTS_GlobalService.globalErrorHandler;
+        const logErrorSpy: jasmine.Spy = spyOn(DyFM_Log, 'error');
+        const logSpies: jasmine.Spy[] = [
+          logErrorSpy,
+          spyOn(DyFM_Log, 'H_error'),
+          spyOn(DyFM_Log, 'info'),
+          spyOn(DyFM_Log, 'testError'),
+          spyOn(DyFM_Log, 'warn'),
+        ];
+        const endpointError: Error & { status: number } = Object.assign(new Error(errorCanary), { status: 503 });
+        const taskSpy: jasmine.Spy = jasmine.createSpy('task').and.rejectWith(endpointError);
+        const globalErrorHandlerSpy: jasmine.Spy = jasmine.createSpy('globalErrorHandler').and.rejectWith(
+          new Error(handlerCanary)
+        );
+        const params: DyNTS_Endpoint_Params = new DyNTS_Endpoint_Params({
+          name: 'privacyEndpoint',
+          type: DyFM_HttpCallType.post,
+          endpoint: '/private/:sheetId',
+          tasks: [taskSpy],
+          logRequest: true,
+          logRequestsParams: false,
+          logRequestsContent: false,
+          logResponseContent: true,
+        });
+        mockRequest = {
+          body: { workbookValue: requestCanary },
+          headers: { authorization: `Bearer ${requestCanary}` },
+          originalUrl: `/private/${requestCanary}?token=${requestCanary}`,
+          params: { sheetId: requestCanary },
+          query: { token: requestCanary },
+        };
+        DyNTS_GlobalService.globalErrorHandler = globalErrorHandlerSpy;
+        DyNTS_global_settings.log_settings.highDetailedLogs = true;
+
+        try {
+          await params.getFullExecution()(mockRequest as Request, mockResponse as Response);
+        } finally {
+          DyNTS_GlobalService.globalErrorHandler = originalGlobalErrorHandler;
+          DyNTS_global_settings.log_settings.highDetailedLogs = originalHighDetailedLogs;
+        }
+
+        const serializedLogs: string = JSON.stringify(
+          logSpies.flatMap((logSpy: jasmine.Spy): readonly unknown[][] => logSpy.calls.allArgs())
+        );
+        const serializedResponse: string = JSON.stringify(sendSpy.calls.mostRecent().args[0]);
+
+        expect(globalErrorHandlerSpy).toHaveBeenCalledWith(
+          endpointError,
+          mockRequest as Request,
+          mockResponse as Response,
+          'test-issuer'
+        );
+        expect(logErrorSpy).toHaveBeenCalledWith(
+          '[DyNTS safe diagnostic]',
+          jasmine.objectContaining({
+            code: 'DYNTS|ENDPOINT|FAILURE',
+            stage: 'endpoint',
+            status: 503,
+          })
+        );
+        expect(logErrorSpy).toHaveBeenCalledWith(
+          '[DyNTS safe diagnostic]',
+          jasmine.objectContaining({ code: 'DYNTS|ENDPOINT|GLOBAL_HANDLER_FAILURE' })
+        );
+        expect(statusSpy).toHaveBeenCalledWith(503);
+        expect(serializedLogs).not.toContain(errorCanary);
+        expect(serializedLogs).not.toContain(handlerCanary);
+        expect(serializedLogs).not.toContain(requestCanary);
+        expect(serializedResponse).not.toContain(errorCanary);
+        expect(serializedResponse).not.toContain(handlerCanary);
+        expect(serializedResponse).not.toContain(requestCanary);
+      }
+    );
 
     it('| should handle production environment error response', async () => {
       const originalEnv = DyNTS_global_settings.env_settings.environment;