@futdevpro/nts-dynamo 1.9.40 → 1.9.41

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

@@ -23,16 +23,17 @@ export class DyNTS_Endpoint_Params {
   /* TODO: ENCRYPTION !!EZTET
   useEncryptionKey?: string; */
 
-  private pathParams: string[];
+  private readonly pathParams: string[];
 
-  private preProcesses: ((req: Request, res: Response) => Promise<void>)[];
-  private tasks: ((req: Request, res: Response, issuer?: string) => Promise<void>)[];
+  private readonly preProcesses: ((req: Request, res: Response) => Promise<void>)[];
+  private readonly tasks: ((req: Request, res: Response, issuer?: string) => Promise<void>)[];
 
-  private logRequest: boolean;
-  private logRequestsParams: boolean;
-  private logRequestsContent: boolean;
-  private logResponseContent: boolean;
-  private stack: string;
+  private readonly logRequest: boolean;
+  private readonly logRequestsParams: boolean;
+  private readonly logRequestsContent: boolean;
+  private readonly logResponseContent: boolean;
+  private readonly stack: string;
+  private readonly autoResolveCirculation: boolean;
 
   constructor(
     set: {
@@ -85,6 +86,10 @@ export class DyNTS_Endpoint_Params {
        * log settings for response content
        */
       logResponseContent?: boolean,
+      /**
+       * auto resolve circulation errors
+       */
+      autoResolveCirculation?: boolean,
     }
   ) {
     try {
@@ -101,6 +106,8 @@ export class DyNTS_Endpoint_Params {
         set.logRequestsContent ?? DyNTS_global_settings.log_settings.requestsContent;
       this.logResponseContent = 
         set.logResponseContent ?? DyNTS_global_settings.log_settings.responseContent;
+      this.autoResolveCirculation = 
+        set.autoResolveCirculation ?? DyNTS_global_settings.autoResolveEndpointCirculationErrors;
 
       if (!this.endpoint) {
         throw new DyFM_Error({
@@ -233,7 +240,8 @@ export class DyNTS_Endpoint_Params {
     req: Request, 
     res: Response, 
     error: Error | DyFM_Error, 
-    issuer: string
+    issuer: string,
+    autoSecondTry?: boolean
   ): Promise<void> {
     try {
       let msg: string = `Endpoint caught an error. '${this.name}' (${this.endpoint})`;
@@ -284,10 +292,27 @@ export class DyNTS_Endpoint_Params {
 
       try {
         JSON.stringify(error);
-      } catch (error) {
-        DyFM_Log.H_error(
-          'DyNTS_Endpoint_Params: error object is not serializable!', error
-        );
+      } catch (stringifyError) {
+        if (this.autoResolveCirculation) {
+          try {
+            error = DyFM_Shared.resolveCirculation(error);
+            JSON.stringify(error);
+          } catch (resolveError) {
+            DyFM_Log.H_error(
+              'DyNTS_Endpoint_Params: error object is not serializable, and not resolvable!'
+            );
+
+            error = new DyFM_Error({
+              error: new Error('UNRESOLVABLE UNSERIALIZABLE ERROR'),
+            });
+          }
+        } else {
+          DyFM_Log.H_error('DyNTS_Endpoint_Params: error object is not serializable!');
+
+          error = new DyFM_Error({
+            error: new Error('UNSERIALIZABLE ERROR'),
+          });
+        }
       }
 
       res.status((error as DyFM_Error)?.___status ?? 501);
@@ -310,21 +335,28 @@ export class DyNTS_Endpoint_Params {
 
       DyFM_Log.error('');
           
-    } catch (error) {
+    } catch (errorLvl2) {
       this.multiLevelError(
-        error,
-        { req, res, error, issuer }
+        errorLvl2,
+        { 
+          req: req, 
+          res: res, 
+          error: error, 
+          issuer: issuer, 
+          autoSecondTry: autoSecondTry, 
+        }
       );
     }
   }
 
   private multiLevelError(
-    error: any, 
+    errorLvl2: any, 
     errorInputs: { 
       req: Request, 
       res: Response, 
       error: Error | DyFM_Error, 
-      issuer: string 
+      issuer: string,
+      autoSecondTry: boolean
     }
   ): void {
     if (DyNTS_global_settings.log_settings.highDetailedLogs) {
@@ -333,7 +365,7 @@ export class DyNTS_Endpoint_Params {
           `(${this.name}, ${this.endpoint})` +
         `\n(DYNAMO MULTILEVEL ERROR means, that the ERROR HANDLING is ALSO FAILED, ` +
           `and the error message was not sent.)` + 
-        `\nERROR:`, error, 
+        `\nERROR:`, errorLvl2, 
         '\n'
       );
     } else {
@@ -347,32 +379,48 @@ export class DyNTS_Endpoint_Params {
 
     try {
       JSON.stringify(errorInputs.error);
-    } catch (error) {
-      DyFM_Log.error('error object is not serializable!');
-      let unresolvable;
+    } catch (errorLvl2Replication) {
+      DyFM_Log.error('  ...response object is not serializable!');
+      let resolvedError: any;
 
       try {
-        DyFM_Shared.resolveCirculation(errorInputs.error);
-      } catch (error) {
-        unresolvable = true;
-        DyFM_Log.error('error object is not resolvable!');
+        resolvedError = DyFM_Shared.resolveCirculation(errorInputs.error);
+      } catch (errorLvl3) {
+        DyFM_Log.error('  ...response object is not resolvable!');
+        DyFM_Log.error('  ...', errorLvl3);
       }
       
-      if (!unresolvable) {
-        DyFM_Log.error('error object is resolvable! (use DyFM_Shared.resolveCirculation)');
+      if (resolvedError) {
+        if (this.autoResolveCirculation && !errorInputs.autoSecondTry) {
+          this.error(
+            errorInputs.req, 
+            errorInputs.res, 
+            resolvedError,
+            errorInputs.issuer,
+            true
+          );
+
+          DyFM_Log.warn('  ...automatic circulation error resolution was successful!');
+
+          return;
+        } else {
+          DyFM_Log.error(
+            '  ...response object is resolvable! (use DyFM_Shared.resolveCirculation)'
+          );
+        }
       }
     }
 
     if (
       DyNTS_global_settings.log_settings.highDetailedLogs ||
-      !(error instanceof DyFM_Error)
+      !(errorLvl2 instanceof DyFM_Error)
     ) {
       DyFM_Log.H_error(
         `Endpoint "${this.endpoint}" caught an error and FAILED TO RESOLVE. (${this.name})`,
-        '\n    ERROR:', error
+        '\n    ERROR:', errorLvl2
       );
     } else {
-      error.logSimple(
+      errorLvl2.logSimple(
         `Endpoint "${this.endpoint}" caught an error and FAILED TO RESOLVE. (${this.name})`
       );
     }

package/src/_models/interfaces/global-settings.interface.ts

@@ -30,6 +30,11 @@ export interface DyNTS_Global_Settings {
    */
   systemShortCodeName?: string;
 
+  /**
+   * 
+   */
+  autoResolveEndpointCirculationErrors: boolean;
+
   /**
    * this setting will set which logs will be shown
    */

package/src/_modules/socket/_services/app-extended.server.ts

@@ -119,7 +119,7 @@ import { DyNTS_global_settings } from '../../../_collections/global-settings.con
  */
 export abstract class DyNTS_AppExtended extends DyNTS_App {
   
-  private systemControlsExt: DyNTS_AppExtSysControls = new DyNTS_AppExtSysControls();
+  private readonly systemControlsExt: DyNTS_AppExtSysControls = new DyNTS_AppExtSysControls();
   override get started(): boolean { return this.systemControlsExt.appExtended.started; }
   private httpsSocketSettingUpCount: number = 0;
   private httpSocketSettingUpCount: number = 0;
@@ -138,12 +138,12 @@ export abstract class DyNTS_AppExtended extends DyNTS_App {
    * ];
    */
   protected socketServices: DyNTS_SocketServerService<any>[];
-  private allSocketServers: SocketIO.Server[] = [];
+  private readonly allSocketServers: SocketIO.Server[] = [];
 
   constructor(){
-    super(true);
+    super(/* true */);
 
-    this.asyncConstructExt().catch((error: DyFM_AnyError): void => {
+    /* this.asyncConstructExt().catch((error: DyFM_AnyError): void => {
       if (
         DyNTS_global_settings.log_settings.highDetailedLogs ||
         !(error instanceof DyFM_Error)
@@ -159,13 +159,15 @@ export abstract class DyNTS_AppExtended extends DyNTS_App {
           `(DyNTS_AppExtended constructor catch)`
         );
       }
-    });
+    }); */
   }
 
-  private async asyncConstructExt(): Promise<void> {
+  protected override async asyncConstruct(extended = true): Promise<void> {
     if (this.fnLogs && this.deepLog) console.log('\nfn:. asyncConstruct-extended');
 
     try {
+      await super.asyncConstruct(true);
+
       this.systemControlsExt.appExtended.init = true;
     
       this.socketServices = this.getSocketServices();
@@ -194,7 +196,7 @@ export abstract class DyNTS_AppExtended extends DyNTS_App {
       DyFM_Log.H_success(`"${this.params.name}" started successfully.`);
       
     } catch (error) {
-      if (
+      /* if (
         DyNTS_global_settings.log_settings.highDetailedLogs ||
         !(error instanceof DyFM_Error)
       ) {
@@ -206,7 +208,7 @@ export abstract class DyNTS_AppExtended extends DyNTS_App {
         error.logSimple(
           `Extended Application: "${this.params?.name}" start failed. (asyncConstructExt catch)`
         );
-      }
+      } */
 
       throw new DyFM_Error({
         errorCode: 'NTS-AES-001',

package/src/_modules/socket/_services/socket-server.service.ts

@@ -678,13 +678,13 @@ export abstract class DyNTS_SocketServerService<
       if (DyNTS_global_settings.log_settings.socket_eventContent) {
         DyFM_Log.success(
           ` <--=  emitted socket(${this.params.name}) event: "${event}", ` +
-          `\n  presenceId: "${id}", sockets: ${presence.sockets.length}` +
-          `\n  content:`, content
+          `\n         presenceId: "${id}", sockets: ${presence.sockets.length}` +
+          `\n         content:`, content
         );
       } else {
         DyFM_Log.success(
           ` <--=  emitted socket(${this.params.name}) event: "${event}", ` +
-          `\n  presenceId: ${id}, sockets: ${presence.sockets.length}`
+          `\n         presenceId: ${id}, sockets: ${presence.sockets.length}`
         );
       }
     } catch (error) {

package/src/_services/base/data.service.ts

@@ -84,7 +84,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
         message: 
           `The dataService construction failed for "${dataParams?.dataName}". ` +
           `at "${this.serviceName}" (${this.constructor.name})` +
-          `\nMaybe you forgot to add the dbService to the GlobalService?\n\n`,
+          `\nMaybe you forgot to add the dbService to the GlobalService?`,
         level: DyFM_ErrorLevel.critical,        
       });
       /* DyFM_Log.error(

package/src/_services/base/singleton.service-base.ts

@@ -10,7 +10,8 @@ export class DyNTS_SingletonServiceBase {
   /// ---     ---     ---     SINGLETON     ---     ---     --- \\\
   protected static instance;
   
-  static getSingletonInstance() {
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  protected static getSingletonInstance() {
     if (!this.instance) {
       this.instance = new this();
     }

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

@@ -88,6 +88,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 +194,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 +295,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 +309,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 {