@futdevpro/nts-dynamo 1.9.40 → 1.9.42

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

@@ -52,6 +52,7 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
 
   authService: DyNTS_AuthService;
   dbServiceCollection: DyNTS_Service_Collection<DyNTS_DBService<any>>;
+  /* dataServiceCollection: DyNTS_Service_Collection<any>; */
   emailServiceCollection: DyNTS_Service_Collection<DyNTS_EmailService>; 
   
   static readonly defaultErrorUserMsg: string = 
@@ -88,6 +89,22 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
       this.instance.dbServiceCollection = {};
 
       dbModels?.forEach((dbModel: DyFM_DataModel_Params): void => {
+        if (!dbModel) {
+          throw new DyFM_Error({
+            ...this.getDefaultErrorSettings(
+              'setDBServices', 
+              new Error(`given dbModel is empty!`), 
+              'DyNTS_GlobalService'
+            ),
+            
+            errorCode: 'NTS-GS0-SDBS2',
+            additionalContent: {
+              dbModels: dbModels,
+              dbModelNames: dbModels.map((dbModel: DyFM_DataModel_Params) => dbModel.dataName),
+            },
+          });
+        }
+
         if (dbModel.addArchive) {
           const archiveModel: DyFM_DataModel_Params = new DyFM_DataModel_Params({
             ...dbModel,
@@ -178,35 +195,39 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
 
   private static async setErrorHandler(errorHandler?: DyNTS_GlobalErrorHandlerFn): Promise<void> {
     try {
-      DyNTS_GlobalService.globalErrorHandler = 
-        errorHandler ?? 
-        (async (error: any): Promise<void> => {
-          try {
-            DyFM_Log.warn(
-              `globalErrorHandler not set! (set in app.getGlobalServiceCollection)`,
-              '\nwill use default-logging',
+      DyNTS_GlobalService.globalErrorHandler = (async (error: any): Promise<void> => {
+        try {
+          if (errorHandler) {
+            await errorHandler(error);
+
+            return;
+          }
+
+          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?.replaceAll?.('at', '  at') ?? error
             );
-  
-            if (
-              DyNTS_global_settings.log_settings.highDetailedLogs ||
-              !(error instanceof DyFM_Error)
-            ) {
-              DyFM_Log.H_error(
-                `Error caught by globalErrorHandler.`,
-                `\n    ERROR:`, error?.replaceAll?.('at', '  at') ?? error
-              );
-            } else /* if (!error.___logged) */ {
-              error.logSimple(
-                `Error caught by globalErrorHandler.`
-              );
-            }
-          } catch (error) {
-            DyFM_Log.error(
-              `NTS GLOBAL MULTILEVEL ERROR: \nFailed to handle error on globalErrorHandler.`,
-              error
+          } else /* if (!error.___logged) */ {
+            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({
         ...this.getDefaultErrorSettings('setErrorHandler', error, 'DyNTS_GlobalService'),
@@ -275,15 +296,11 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
     if (collection[key]) {
       return collection[key] as DyNTS_DBService<T>;
     } else {
-      let keys: string = `${Object.keys(collection)}`;
-
-      keys = keys.replace(/,/g, '\n                ');
-
       throw new Error(
         `\n  DyNTS_GlobalService.getDBService failed, ERROR: ` +
-        `\n    no dbService on collection with this key: ${key}!` +
+        `\n    no dbService on collection with this key: "${key}"!` +
         `\n      The available dbServices on collection:` +
-        `\n        ${keys}\n`
+        `\n        ${Object.keys(collection).join(', ')}\n`
       );
     }
   }
@@ -293,12 +310,14 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
    * @returns 
    */
   static getEmailServiceCollection(): DyNTS_Service_Collection<DyNTS_EmailService> {
-    if (!this.instance?.emailServiceCollection) {
+    if (!this.instance.emailServiceCollection) {
       throw new Error(
         `\n  Unique Email Service Collection missing!` + 
         `\n    Please create a Unique Email Service Collection extending ` +
           `DynamoBEEmailServiceCollection, ` + 
-        `\n      and Setup with DyNTS_GlobalServiceC.setServices(...)\n`
+        `\n      and Setup with DyNTS_GlobalServiceC.setServices(...)\n` +
+        `\n      available emailServiceCollection: ` +
+        `${Object().keys(this.instance.emailServiceCollection).join(', ')}\n`
       );
     }
 

package/src/_services/route/routing-module.service.ts

@@ -65,7 +65,7 @@ export class DyNTS_RoutingModule {
   security: DyNTS_RouteSecurity;
   route: string;
 
-  private controllers: DyNTS_Controller[];
+  private readonly controllers: DyNTS_Controller[];
   endpoints: DyNTS_Endpoint_Params[] = [];
 
   openRouter: Router = Router();
@@ -93,13 +93,29 @@ export class DyNTS_RoutingModule {
         `routing module setup done: ${this.route} security: ${this.security}\n`
       );
     } catch (error) {
+      /* if (
+        DyNTS_global_settings.log_settings.highDetailedLogs ||
+        !(error instanceof DyFM_Error)
+      ) {
+        DyFM_Log.H_error(
+          `Routing module setup failed (${this.route}).`,
+          `\n    ERROR:`, error
+        );
+      } else {
+        error.logSimple(
+          `Routing module setup failed (${this.route}).` +
+          '\nmessages:\n' + error._messages.join('        \n')
+        );
+      } */
+
       /* DyFM_Log.error(`\nRouting module setup failed (${this.route})`, error); */
       throw new DyFM_Error({
         ...this.getDefaultErrorSettings(
-          'constructor', 
-          new Error(`Routing module setup failed (${this.route}).`)
+          'DyNTS_RoutingModule.constructor', 
+          error
         ),
 
+        message: `Routing module setup failed (${this.route}).`,
         errorCode: 'NTS-RMS-000',
         additionalContent: set,
       });
@@ -117,9 +133,12 @@ export class DyNTS_RoutingModule {
         throw new DyFM_Error({
           ...this.getDefaultErrorSettings(
             'setupRoutes', 
-            new Error(`DynamoBEController setup failed. Please check the setupEndpoints() method.`)
+            error
           ),
 
+          message: 
+            `DyNTS_Controller setup failed. (${controller?.constructor?.name}) ` +
+            `Please check the setupEndpoints() method.`,
           errorCode: 'NTS-RMS-SR1',
           level: DyFM_ErrorLevel.critical,
         });

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

@@ -268,14 +268,14 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
   }
   debugLog: boolean = DyNTS_global_settings.log_settings.server_debug;
 
-  constructor(extended?: boolean){
+  constructor(/* extended?: boolean */){
     super();
     
     process.on(
       'unhandledRejection', 
       (reason_theError: object, p_passWhatIsThis_maybeThePromise: any): void => {
         DyFM_Log.H_error(
-          'Unhandled Rejection: ', (p_passWhatIsThis_maybeThePromise as Promise<any>)?.toString(), 
+          'Unhandled Rejection:', (p_passWhatIsThis_maybeThePromise as Promise<any>)?.toString(), 
           '\n    Rejection reason:', (reason_theError as Error)?.stack?.split('at')?.[0],
           /* '\n    ErrorCode:', (reason as any)?.code, */
           '\n\n    Stack:', 
@@ -286,7 +286,10 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
           DyNTS_GlobalService.globalErrorHandler?.(
             new DyFM_Error({
               errorCode: 'NTS-AS0-BASE-UR',
-              message: 'Unhandled Rejection!',
+              message: 
+                `Unhandled Rejection!: "${(reason_theError as Error)?.stack?.split('at')?.[0]}"`,
+              userMessage: this.defaultErrorUserMsg,
+              addECToUserMsg: true,
               error: reason_theError as Error,
               additionalContent: { 
                 reason: reason_theError, 
@@ -295,14 +298,20 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
               level: DyFM_ErrorLevel.critical,
             })
           );
-
         } catch (error) {
           DyFM_Log.error('globalErrorHandler (MULTILEVEL) ERROR:', error);
         }
       }
     );
 
-    this.asyncConstruct(extended).catch((error: any): void => {
+    this.asyncConstruct(/* extended */).catch((error: any): void => {
+      if (error instanceof DyFM_Error) {
+        DyFM_Log.H_warn(
+          '(constructor asyncConstruct.catch) additional error content:\n', 
+          error?.additionalContent
+        );
+      }
+
       if (
         DyNTS_global_settings.log_settings.highDetailedLogs ||
         !(error instanceof DyFM_Error)
@@ -313,15 +322,15 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
         );
       } else {
         error.logSimple(
-          `Application: "${this.params?.name}" start failed. (constructor asyncConstruct.catch)`
+          `Application: "${this.params?.name}" start failed. (constructor asyncConstruct.catch)` +
+          '\n      all error messages (from this stack):\n\n"' + 
+          error._messages.join('"\n\n"') + '"\n\n'
         );
       }
-
-      DyFM_Log.H_warn('asyncConstruct error\n', error?.additionalContent);
     });
   }
 
-  private async asyncConstruct(extended?: boolean): Promise<void> {
+  protected async asyncConstruct(extended?: boolean): Promise<void> {
     if (this.fnLogs && this.deepLog) DyFM_Log.log('\nfn:. asyncConstruct');
 
     try {