@futdevpro/nts-dynamo 1.9.32 → 1.9.34

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

@@ -4,11 +4,14 @@ import { Request, Response } from 'express';
 
 import { 
   DyFM_Metadata, DyFM_DataModel_Params, DyFM_Log, DyFM_Error, DyFM_Array, 
-  DyFM_errorFlag
+  DyFM_errorFlag,
+  DyFM_AnyError,
+  DyFM_Error_Settings
 } 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';
 
@@ -48,13 +51,12 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
   authService: DyNTS_AuthService;
   dbServiceCollection: DyNTS_Service_Collection<DyNTS_DBService<any>>;
   emailServiceCollection: DyNTS_Service_Collection<DyNTS_EmailService>; 
+  
+  static readonly defaultErrorUserMsg: string = 
+    `We encountered an unhandled Control Service Error, ` +
+    `\nplease contact the responsible development team.`; 
 
-  static globalErrorHandler?: (
-    err: any, 
-    req?: Request, 
-    res?: Response, 
-    issuer?: string
-  ) => Promise<void>;
+  static globalErrorHandler?: DyNTS_GlobalErrorHandlerFn;
     
   /**
    * You need to setup global Services through this function
@@ -62,14 +64,36 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
   static async setServices(set: DyNTS_GlobalService_Settings): Promise<void> {
     this.getInstance();
 
+    try {
+      await this.setDBServices(set?.dbModels);
+
+      await this.setAuthService(set?.authService);
+
+      await this.setEmailServices(set?.emailServiceCollection);
+
+      await this.setErrorHandler(set?.errorHandler);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('setServices', error, 'DyNTS_GlobalService'),
+
+        errorCode: 'NTS-GS0-SS0',
+      });
+    }
+  }
+
+  private static async setDBServices(dbModels?: DyFM_DataModel_Params[]): Promise<void> {    
     try {
       this.instance.dbServiceCollection = {};
-      set.dbModels?.forEach((dbModel: DyFM_DataModel_Params): void => {
+      dbModels?.forEach((dbModel: DyFM_DataModel_Params): void => {
         if (!dbModel.constructed) {
           throw new DyFM_Error({
-            message: `DyNTS_GlobalService.setServices failed, ` +
-              `ERROR: dbModel is not constructed!`,
-            errorCode: 'NTS-GS0-SS1',
+            ...this.getDefaultErrorSettings(
+              'setDBServices', 
+              new Error(`dbModel is not constructed!`), 
+              'DyNTS_GlobalService'
+            ),
+            
+            errorCode: 'NTS-GS0-SDBS1',
             additionalContent: {
               dbModel: dbModel,
             },
@@ -82,23 +106,44 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
           DyFM_Log.error(`Failed to create DyNTS_DBService (${dbModel.dataName}).`, error);
           
           throw new DyFM_Error({
-            message: `Failed to create DyNTS_DBService (${dbModel.dataName}).`, 
-            issuerService: 'DyNTS_GlobalService',
-            error: error,
+            ...this.getDefaultErrorSettings('setDBServices', error, 'DyNTS_GlobalService'),
+
             additionalContent: {
               dbModel: dbModel,
             },
           });
         }
       });
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('setDBServices', error, 'DyNTS_GlobalService'),
+        
+        errorCode: 'NTS-GS0-SDBS0',
+      });
+    }
+  }
 
-      if (!set.authService) {
+  private static async setAuthService(authService?: DyNTS_AuthService): Promise<void> {
+    try {
+      if (!authService) {
         DyFM_Log.warn(`Authentication Service missing!`);
       } else {
-        this.instance.authService = set.authService;
+        this.instance.authService = authService;
       }
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('setAuthService', error, 'DyNTS_GlobalService'),
+        
+        errorCode: 'NTS-GS0-SAS0',
+      });
+    }
+  }
 
-      this.instance.emailServiceCollection = set.emailServiceCollection ?? {};
+  private static async setEmailServices(
+    emailServiceCollection?: DyNTS_Service_Collection<DyNTS_EmailService>
+  ): Promise<void> {    
+    try {
+      this.instance.emailServiceCollection = emailServiceCollection ?? {};
       await DyFM_Array.asyncForEach(
         Object.keys(this.instance.emailServiceCollection),
         async (key: string): Promise<void> => {
@@ -107,34 +152,51 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
           ).asyncPostConstruct();
         }
       );
-      
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('setEmailServices', error, 'DyNTS_GlobalService'),
+        
+        errorCode: 'NTS-GS0-SS4',
+      });
+    }
+  }
+
+  private static async setErrorHandler(errorHandler?: DyNTS_GlobalErrorHandlerFn): Promise<void> {
+    try {
       DyNTS_GlobalService.globalErrorHandler = 
-        set.errorHandler ?? 
+        errorHandler ?? 
         (async (error: any): Promise<void> => {
-          DyFM_Log.warn(
-            `globalErrorHandler not set! (set in app.getGlobalServiceCollection)`,
-            '\nwill use default-logging',
-          );
-
-          if (
-            DyNTS_global_settings.log_settings.highDetailedLogs ||
-            !(error instanceof DyFM_Error)
-          ) {
-            DyFM_Log.H_error(
-              `Error caught by globalErrorHandler.`,
-              `\n    ERROR:`, error
+          try {
+            DyFM_Log.warn(
+              `globalErrorHandler not set! (set in app.getGlobalServiceCollection)`,
+              '\nwill use default-logging',
             );
-          } else {
-            error.logSimple(
-              `Error caught by globalErrorHandler.`
+  
+            if (
+              DyNTS_global_settings.log_settings.highDetailedLogs ||
+              !(error instanceof DyFM_Error)
+            ) {
+              DyFM_Log.H_error(
+                `Error caught by globalErrorHandler.`,
+                `\n    ERROR:`, error
+              );
+            } else {
+              error.logSimple(
+                `Error caught by globalErrorHandler.`
+              );
+            }
+          } catch (error) {
+            DyFM_Log.error(
+              `NTS GLOBAL MULTILEVEL ERROR: \nFailed to handle error on globalErrorHandler.`,
+              error
             );
           }
         });
     } catch (error) {
       throw new DyFM_Error({
-        message: `Failed to setServices on DyNTS_GlobalService.`,
-        error: error,
-        errorCode: 'NTS-GS0-SS0',
+        ...this.getDefaultErrorSettings('setErrorHandler', error, 'DyNTS_GlobalService'),
+        
+        errorCode: 'NTS-GS0-SEH0',
       });
     }
   }
@@ -280,4 +342,21 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
                 ${names}\n`);
     }
   } */
+
+  protected static getDefaultErrorSettings(
+    fnName: string, 
+    error: DyFM_AnyError,
+    issuer: string
+  ): DyFM_Error_Settings {
+    return {
+      status: (error as DyFM_Error)?.___status ?? 500,
+      message: (error as Error)?.message ?? 
+        `${fnName} was UNSUCCESSFUL (${DyNTS_global_settings.systemShortCodeName})`,
+      addECToUserMsg: !(error as DyFM_Error)?.__userMessage,
+      userMessage: (error as DyFM_Error)?.__userMessage ?? this.defaultErrorUserMsg,
+      issuer: issuer,
+      issuerService: this.constructor?.name,
+      error: error,
+    };
+  }
 }

package/src/_services/server/app.server.spec.ts

@@ -1,5 +1,5 @@
 
-import { DyFM_Log, DyFM_delay } from '@futdevpro/fsm-dynamo';
+import { DyFM_Error, DyFM_Log, DyFM_delay } from '@futdevpro/fsm-dynamo';
 import { DyNTS_AppBase_Mock, DyNTS_AppFull_Mock } from '../../_modules/mock/app-server.mock';
 
 describe('DyNTS_App AND DyNTS_AppExtended?;', (): void => {
@@ -15,15 +15,23 @@ describe('DyNTS_App AND DyNTS_AppExtended?;', (): void => {
         await DyFM_delay(100);
         
         await app.ready();
+
+        await DyFM_delay(100);
       } catch (error) {
-        DyFM_Log.test('error', error);
+        DyFM_Log.test('test beforeEach error:', (error as DyFM_Error)?._message);
       }
     });
 
     afterEach(async (): Promise<void> => {
-      await app.stop();
+      try {
+        await DyFM_delay(100);
+        
+        await app.stop();
 
-      await DyFM_delay(100);
+        app = null;
+      } catch (error) {
+        DyFM_Log.test('test afterEach error:', (error as DyFM_Error)?._message);
+      }
     });
 
     it('should be created', (): void => {
@@ -41,16 +49,27 @@ describe('DyNTS_App AND DyNTS_AppExtended?;', (): void => {
     beforeEach(async (): Promise<void> => {
       try {
         app = new DyNTS_AppFull_Mock();
+
+        await DyFM_delay(100);
+        
         await app.ready();
+
+        await DyFM_delay(100);
       } catch (error) {
-        DyFM_Log.test('error', error);
+        DyFM_Log.test('test beforeEach error:', (error as DyFM_Error)?._message);
       }
     });
 
     afterEach(async (): Promise<void> => {
-      await app.stop();
+      try {
+        await DyFM_delay(100);
+        
+        await app.stop();
 
-      await DyFM_delay(100);
+        app = null;
+      } catch (error) {
+        DyFM_Log.test('test afterEach error:', (error as DyFM_Error)?._message);
+      }
     });
 
     it('should be created', (): void => {