@futdevpro/nts-dynamo 1.15.153 → 1.15.154

package/src/_services/core/global.service.ts

@@ -1,7 +1,4 @@
-
-
-
-import {
+import {
   DyFM_AnyError,
   DyFM_Array,
   DyFM_DataModel_Params,
@@ -9,25 +6,28 @@ import {
   DyFM_Error_Settings,
   DyFM_global_settings,
   DyFM_Log,
-  DyFM_Metadata
-} from '@futdevpro/fsm-dynamo';
-import { DyNTS_App_Params } from '../../_models/control-models/app-params.control-model';
-
-import {
-  DyNTS_GlobalErrorHandlerFn,
-  DyNTS_GlobalService_Settings
-} from '../../_models/interfaces/global-service-settings.interface';
-
-import { DyNTS_AuthService } from './auth.service';
-/* import { DyNTS_DBServiceCollection } from './db-service-collection.service'; */
-import { DyNTS_DBService } from '../base/db.service';
-import { DyNTS_EmailService } from './email.service';
-import { DyNTS_Service_Collection } from './service-collection.service';
-/* import { DyNTS_EmailServiceCollection } from './email-service-collection.service'; */
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
-import { DyNTS_SingletonService } from '../base/singleton.service';
-/* import { DyNTS_archiveFlag } from '../../_collections/archive-flag.const'; */
-import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
+  DyFM_Metadata
+} from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_AuthService } from './auth.service';
+import { DyNTS_EmailService } from './email.service';
+import { DyNTS_Service_Collection } from './service-collection.service';
+/* import { DyNTS_DBServiceCollection } from './db-service-collection.service'; */
+/* import { DyNTS_EmailServiceCollection } from './email-service-collection.service'; */
+import { DyNTS_DBService } from '../base/db.service';
+import { DyNTS_SingletonService } from '../base/singleton.service';
+/* import { DyNTS_archiveFlag } from '../../_collections/archive-flag.const'; */
+import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { DyNTS_App_Params } from '../../_models/control-models/app-params.control-model';
+import {
+  DyNTS_GlobalErrorHandlerFn,
+  DyNTS_GlobalService_Settings
+} from '../../_models/interfaces/global-service-settings.interface';
+import { DyNTS_SafeDiagnosticStage_Type } from '../../_modules/server/safe-diagnostic/safe-diagnostic-stage.type-enum';
+import {
+  DyNTS_SafeDiagnostic_ControlService
+} from '../../_modules/server/safe-diagnostic/safe-diagnostic.control-service';
 
 /**
  * This is the main Global/Core Service Collection used by DynamoNTS, 
@@ -74,10 +74,14 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
     `We encountered an unhandled Control Service Error, ` +
     `\nplease contact the responsible development team.`; 
 
-  static globalErrorHandler: DyNTS_GlobalErrorHandlerFn = 
-    async (error: DyFM_AnyError): Promise<void> => {
-      DyFM_Log.error(`Global Error Handler not set!\nError:`, error);
-    }
+  static globalErrorHandler: DyNTS_GlobalErrorHandlerFn = 
+    async (error: DyFM_AnyError): Promise<void> => {
+      DyNTS_SafeDiagnostic_ControlService.report({
+        code: 'DYNTS|GLOBAL|HANDLER_NOT_SET',
+        stage: DyNTS_SafeDiagnosticStage_Type.globalErrorHandler,
+        error: error,
+      });
+    };
     
   /**
    * You need to setup global Services through this function
@@ -179,16 +183,16 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
         return;
       }
 
-      try {
-        this.instance.dbServiceCollection[dbModel.dataName] = new DyNTS_DBService(dbModel);
-      } catch (error) {
-        if (error instanceof DyFM_Error && !DyFM_global_settings.log_settings.highDetailedLogs) {
-          error.logSimple(`Failed to create DyNTS_DBService (${dbModel.dataName}).`);
-        } else {
-          DyFM_Log.error(`Failed to create DyNTS_DBService (${dbModel.dataName}).`, error);
-        }
-        
-        throw new DyFM_Error({
+      try {
+        this.instance.dbServiceCollection[dbModel.dataName] = new DyNTS_DBService(dbModel);
+      } catch (error) {
+        DyNTS_SafeDiagnostic_ControlService.report({
+          code: 'DYNTS|GLOBAL|DB_SERVICE_CREATE_FAILED',
+          stage: DyNTS_SafeDiagnosticStage_Type.bootstrap,
+          error: error,
+        });
+        
+        throw new DyFM_Error({
           ...this.getDefaultErrorSettings('setDBServices', error, 'DyNTS_GlobalService'),
 
           additionalContent: {
@@ -265,7 +269,7 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
 
   private static async setErrorHandler(errorHandler?: DyNTS_GlobalErrorHandlerFn): Promise<void> {
     try {
-      DyNTS_GlobalService.globalErrorHandler = (async (error: any): Promise<void> => {
+      DyNTS_GlobalService.globalErrorHandler = (async (error: unknown): Promise<void> => {
         try {
           if (errorHandler) {
             await errorHandler(error);
@@ -280,22 +284,19 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
               'please check if it is using the same node_modules as the app)'
           );
 
-          DyFM_Error.logSimple(`Error caught by globalErrorHandler.`, error);
-        } catch (error) {
-          if (error instanceof DyFM_Error) {  
-            error.logSimple(
-              `NTS GLOBAL MULTILEVEL ERROR: ` +
-              `\nFailed to handle error on globalErrorHandler.`,
-            );
-          } else {
-            DyFM_Log.error(
-              `NTS GLOBAL MULTILEVEL ERROR: ` +
-              `\nFailed to handle error on globalErrorHandler.`,
-              (error as DyFM_Error)?.getErrorSimplified?.() ?? error
-            );
-          }
-        }
-      });
+          DyNTS_SafeDiagnostic_ControlService.report({
+            code: 'DYNTS|GLOBAL|UNHANDLED_ERROR',
+            stage: DyNTS_SafeDiagnosticStage_Type.globalErrorHandler,
+            error: error,
+          });
+        } catch (error) {
+          DyNTS_SafeDiagnostic_ControlService.report({
+            code: 'DYNTS|GLOBAL|HANDLER_FAILED',
+            stage: DyNTS_SafeDiagnosticStage_Type.globalErrorHandler,
+            error: error,
+          });
+        }
+      });
     } catch (error) {
       throw new DyFM_Error({
         ...this.getDefaultErrorSettings('setErrorHandler', error, 'DyNTS_GlobalService'),

package/src/_services/server/app-safe-diagnostic.spec.ts

@@ -0,0 +1,124 @@
+import { DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_App_Params } from '../../_models/control-models/app-params.control-model';
+import { DyNTS_Http_Settings } from '../../_models/control-models/http-settings.control-model';
+import { DyNTS_GlobalService_Settings } from '../../_models/interfaces/global-service-settings.interface';
+import { DyNTS_GlobalService } from '../core/global.service';
+import { DyNTS_App } from './app.server';
+
+class DyNTS_SafeDiagnosticTestApp extends DyNTS_App {
+  protected override asyncConstruct(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  /** Supplies the minimal valid application parameters for the boundary test. */
+  getAppParams(): DyNTS_App_Params {
+    return new DyNTS_App_Params({
+      name: 'SafeDiagnosticTestApp',
+      version: '1.0.0',
+      dbName: 'safe_diagnostic_test',
+    });
+  }
+
+  /** Keeps the test application independent from concrete global services. */
+  getGlobalServiceCollection(): DyNTS_GlobalService_Settings {
+    return {};
+  }
+
+  /** Keeps the test application independent from a listening HTTP server. */
+  getPortSettings(): DyNTS_Http_Settings {
+    return new DyNTS_Http_Settings();
+  }
+}
+
+class DyNTS_FailingBootstrapTestApp extends DyNTS_SafeDiagnosticTestApp {
+  protected override asyncConstruct(): Promise<void> {
+    return Promise.reject(new Error(DyNTS_FailingBootstrapTestApp.canary));
+  }
+
+  static readonly canary: string = 'mongodb://bootstrap-user:bootstrap-secret@private-host.example/database';
+}
+
+describe('| DyNTS_App safe process boundary', (): void => {
+  const rejectionCanary: string = 'mongodb://rejection-user:rejection-secret@private-host.example/database';
+  let originalHandler: typeof DyNTS_GlobalService.globalErrorHandler;
+  let initialListeners: NodeJS.UnhandledRejectionListener[];
+
+  beforeEach((): void => {
+    originalHandler = DyNTS_GlobalService.globalErrorHandler;
+    initialListeners = process.listeners('unhandledRejection');
+  });
+
+  afterEach((): void => {
+    DyNTS_GlobalService.globalErrorHandler = originalHandler;
+    process.listeners('unhandledRejection').forEach((listener: NodeJS.UnhandledRejectionListener): void => {
+      if (!initialListeners.includes(listener)) {
+        process.removeListener('unhandledRejection', listener);
+      }
+    });
+  });
+
+  it('| projects an unhandled rejection before logging or forwarding it', async (): Promise<void> => {
+    const logSpy: jasmine.Spy = spyOn(DyFM_Log, 'error');
+    const handlerSpy: jasmine.Spy = jasmine.createSpy('globalErrorHandler').and.resolveTo();
+
+    DyNTS_GlobalService.globalErrorHandler = handlerSpy;
+    new DyNTS_SafeDiagnosticTestApp();
+
+    const addedListeners: NodeJS.UnhandledRejectionListener[] = process
+      .listeners('unhandledRejection')
+      .filter((listener: NodeJS.UnhandledRejectionListener): boolean => !initialListeners.includes(listener));
+
+    expect(addedListeners.length).toBe(1);
+    addedListeners[0](new Error(rejectionCanary), Promise.resolve());
+    await Promise.resolve();
+
+    const serializedLogs: string = JSON.stringify(logSpy.calls.allArgs());
+    const serializedForwardedError: string = JSON.stringify(handlerSpy.calls.mostRecent().args[0]);
+
+    expect(serializedLogs).toContain('dynts-safe-diagnostic/1');
+    expect(serializedForwardedError).toContain('dynts-safe-diagnostic/1');
+    expect(serializedForwardedError).toContain('DYNTS-AS0-BASE-UR');
+    expect(handlerSpy.calls.mostRecent().args.length).toBe(1);
+    expect(serializedLogs).not.toContain(rejectionCanary);
+    expect(serializedLogs).not.toContain('rejection-secret');
+    expect(serializedForwardedError).not.toContain(rejectionCanary);
+    expect(serializedForwardedError).not.toContain('rejection-secret');
+  });
+
+  it('| projects a bootstrap rejection before logging, forwarding and exiting', async (): Promise<void> => {
+    const logSpy: jasmine.Spy = spyOn(DyFM_Log, 'error');
+    const handlerSpy: jasmine.Spy = jasmine.createSpy('globalErrorHandler').and.resolveTo();
+    const exitSpy: jasmine.Spy = spyOn(process, 'exit');
+
+    DyNTS_GlobalService.globalErrorHandler = handlerSpy;
+    new DyNTS_FailingBootstrapTestApp();
+    await new Promise<void>((resolve: () => void): NodeJS.Immediate => setImmediate(resolve));
+
+    const serializedLogs: string = JSON.stringify(logSpy.calls.allArgs());
+    const serializedForwardedError: string = JSON.stringify(handlerSpy.calls.mostRecent().args[0]);
+
+    expect(exitSpy).toHaveBeenCalledOnceWith(1);
+    expect(serializedLogs).toContain('dynts-safe-diagnostic/1');
+    expect(serializedForwardedError).toContain('dynts-safe-diagnostic/1');
+    expect(serializedForwardedError).toContain('DYNTS-AS0-BOOTSTRAP-FAILED');
+    expect(handlerSpy.calls.mostRecent().args.length).toBe(1);
+    expect(serializedLogs).not.toContain(DyNTS_FailingBootstrapTestApp.canary);
+    expect(serializedLogs).not.toContain('bootstrap-secret');
+    expect(serializedForwardedError).not.toContain(DyNTS_FailingBootstrapTestApp.canary);
+    expect(serializedForwardedError).not.toContain('bootstrap-secret');
+  });
+
+  it('| projects raw failures in the default global error handler', async (): Promise<void> => {
+    const logSpy: jasmine.Spy = spyOn(DyFM_Log, 'error');
+
+    await DyNTS_GlobalService.setServices({});
+    await DyNTS_GlobalService.globalErrorHandler(new Error(rejectionCanary));
+
+    const serializedLogs: string = JSON.stringify(logSpy.calls.allArgs());
+
+    expect(serializedLogs).toContain('dynts-safe-diagnostic/1');
+    expect(serializedLogs).not.toContain(rejectionCanary);
+    expect(serializedLogs).not.toContain('rejection-secret');
+  });
+});