@futdevpro/nts-dynamo 1.9.32 → 1.9.34

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

@@ -16,7 +16,8 @@ import {
   DyFM_Array, DyFM_Error, DyFM_error_defaults, 
   DyFM_Error_Settings, 
   DyFM_ErrorLevel, DyFM_Log, second, DyFM_wait, 
-  DyFM_errorFlag
+  DyFM_errorFlag,
+  DyFM_delay
 } from '@futdevpro/fsm-dynamo';
 
 import { DyNTS_SingletonService } from '../base/singleton.service';
@@ -249,6 +250,8 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
 
   private _routingModules: DyNTS_RoutingModule[] = [];
 
+  protected readonly defaultReadyTimeout: number = 10 * second;
+
   override readonly defaultErrorUserMsg = 
     `We encountered an unhandled Server Error, ` +
     `\nplease contact the responsible development team.` +
@@ -270,10 +273,10 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
     
     process.on('unhandledRejection', (reason: object, p_passWhatIsThis: any): void => {
       DyFM_Log.H_error(
-        'Unhandled Rejection: ', p_passWhatIsThis.toString().split('at')[0], 
-        '\n    Rejection reason:', reason.toString().split('at')[0],
+        'Unhandled Rejection: ', p_passWhatIsThis?.toString()?.split('at')?.[0], 
+        '\n    Rejection reason:', reason?.toString()?.split('at')?.[0],
         '\n\n    Stack:', 
-        (reason as any).stack.replaceAll?.('\n    at', '\n      at')
+        (reason as any)?.stack?.replaceAll?.('\n    at', '\n      at'),
       );
 
       try {
@@ -309,11 +312,14 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
           `Application: "${this.params?.name}" start failed. (constructor asyncConstruct.catch)`
         );
       }
+
+      DyFM_Log.H_warn('T1000\n', error?.additionalContent);
     });
   }
 
   private async asyncConstruct(extended?: boolean): Promise<void> {
     if (this.fnLogs && this.deepLog) DyFM_Log.log('\nfn:. asyncConstruct');
+
     try {
       this.systemControls.app.init = true;
       this._params = this.getAppParams();  
@@ -400,289 +406,308 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
     } catch (error) {
       this.constructErrors.push(error);
 
-      DyFM_Log.error(
-        `${this._params.name} start failed (in asyncConstruct). `,
-        `\nERRORS:`, 
-        this.constructErrors,
-        '\nlast error:',
-        error
-      );
+      if (this.deepLog) {
+        if (DyNTS_global_settings.log_settings.highDetailedLogs) {
+          DyFM_Log.H_error(
+            `"${this._params.name}" start failed (in asyncConstruct (highDetailedLog)). `,
+            `\n\n    construct ERRORS:`, this.constructErrors,
+            '\n\nlast error:', error
+          );
+        } else {
+          DyFM_Log.H_error(
+            `"${this._params.name}" start failed (in asyncConstruct). `,
+            `\n\n    construct ERRORS:`, this.getSimplifiedConstructErrors(),
+            '\n\nlast error:', error instanceof DyFM_Error ? error.getErrorSimplified() : error
+          );
+        }
+      }
 
       throw new DyFM_Error({
-        ...this._getDefaultErrorSettings(
-          'asyncConstruct',
-          error
-        ),
+        ...this._getDefaultErrorSettings('asyncConstruct', error),
         
         errorCode: 'NTS-AS0-001',
         additionalContent: {
           constructErrors: this.constructErrors,
           systemControls: this.systemControls,
           systemReadies: {
-            app: this.systemControls.app.getReady(),
-            mongoose: this.systemControls.mongoose.getReady(),
-            httpServer: this.systemControls.httpServer.getReady(),
-            httpsServer: this.systemControls.httpsServer.getReady(),
+            app: this.systemControls.app.getIsReady(),
+            mongoose: this.systemControls.mongoose.getIsReady(),
+            httpServer: this.systemControls.httpServer.getIsReady(),
+            httpsServer: this.systemControls.httpsServer.getIsReady(),
           },
         },
       });
     }
   }
 
-  async ready(timeout: number = 4 * second): Promise<void> {
-    if (this.fnLogs) DyFM_Log.log('\nfn:. ready');
-    let ready: boolean = false;
-    const start: number = +new Date();
+  // eslint-disable-next-line max-lines-per-function
+  async ready(timeout: number = this.defaultReadyTimeout): Promise<void> {
+    try {
+      if (this.fnLogs) DyFM_Log.log('\nfn:. ready');
+      
+      await DyFM_delay(100);
+
+      let ready: boolean = false;
+      const start: number = +new Date();
+
+      if (this.constructErrors.length) {
+        if (this.deepLog) {
+          if (DyNTS_global_settings.log_settings.highDetailedLogs) {
+            DyFM_Log.H_error(
+              `"${this._params.name}" start failed. (ready; constructErrors check 1)`,
+              `\n    construct ERRORS:`, this.constructErrors
+            );
+          } else {
+            DyFM_Log.H_error(
+              `"${this._params.name}" start failed. (ready; constructErrors check 1)`,
+              `\n    construct ERRORS:`, this.getSimplifiedConstructErrors(),
+            );
+          }
+        }
 
-    if (this.constructErrors.length) {
-      if (DyNTS_global_settings.log_settings.highDetailedLogs) {
-        DyFM_Log.H_error(
-          `${this._params.name} start failed. (ready check 1)`,
-          `\n    construct ERRORS:`, this.constructErrors
-        );
-      } else {
-        DyFM_Log.H_error(
-          `${this._params.name} start failed. (ready check 1)`,
-          `\n    construct ERRORS:`, 
-          this.constructErrors.map((error: any): any => {
-            if (error instanceof DyFM_Error) {
-              return error.getErrorSimplified();
-            } else {
-              return error;
-            }
-          }), 
-        );
+        throw new DyFM_Error({ 
+          ...this._getDefaultErrorSettings(
+            'ready',
+            new Error(`"${this._params.name}" start failed.`)
+          ),
+
+          errorCode: 'NTS-AS0-R01',
+          additionalContent: 
+            this.constructErrors.length === 1 ? 
+              { error: this.constructErrors[0] } : 
+              { errors: this.constructErrors },
+        });
       }
 
-      throw new DyFM_Error({ 
-        ...this._getDefaultErrorSettings(
-          'ready',
-          new Error(`${this._params.name} start failed.`)
-        ),
-
-        errorCode: 'NTS-AS0-R01',
-        additionalContent: 
-          this.constructErrors.length === 1 ? 
-            this.constructErrors[0] : 
-            { errors: this.constructErrors },
-      });
-    }
+      while (!ready && +new Date() - start < timeout) {
+        if (this.systemControls.app.init) {
+          ready = (
+            this.systemControls.mongoose.getIsReady() &&
+            this.systemControls.httpServer.getIsReady() &&
+            this.systemControls.httpsServer.getIsReady()
+          );
+        } else {
+          DyFM_Log.error(`"${this._params.name}" APP NOT INITIALIZED while trying to get ready.`);
+        }
 
-    while (!ready && +new Date() - start < timeout) {
-      if (this.systemControls.app.init) {
-        ready = (
-          this.systemControls.mongoose.getReady() &&
-          this.systemControls.httpServer.getReady() &&
-          this.systemControls.httpsServer.getReady()
-        );
-      } else {
-        DyFM_Log.error(`${this.params.name} APP NOT INITIALIZED while trying to get ready.`);
+        if (!ready) {
+          await DyFM_wait(100);
+        }
+      }
+
+      if (timeout < +new Date() - start) {
+        if (this.deepLog) {
+          if (DyNTS_global_settings.log_settings.highDetailedLogs) {
+            DyFM_Log.H_error(
+              `"${this._params.name}" start failed. (ready; TIMEOUT check)`,
+              `\n    construct ERRORS:`, this.constructErrors
+            );
+          } else {
+            DyFM_Log.H_error(
+              `"${this._params.name}" start failed. (ready; TIMEOUT check)`, 
+              `\n    construct ERRORS:`, this.getSimplifiedConstructErrors(),
+            );
+          }
+        }
+
+        throw new DyFM_Error({
+          ...this._getDefaultErrorSettings(
+            'ready',
+            new Error(`"${this._params.name}" start failed. TIMEOUT`)
+          ),
+
+          errorCode: 'NTS-AS0-R02',
+          additionalContent: {
+            constructErrors: this.constructErrors,
+            systemControls: this.systemControls,
+            systemReadies: {
+              mongoose: this.systemControls.mongoose.getIsReady(),
+              httpServer: this.systemControls.httpServer.getIsReady(),
+              httpsServer: this.systemControls.httpsServer.getIsReady(),
+            },
+          },
+        });
+      }
+
+      if (this.constructErrors.length) {
+        if (this.deepLog) {
+          if (DyNTS_global_settings.log_settings.highDetailedLogs) {
+            DyFM_Log.H_error(
+              `"${this._params.name}" start failed. (ready; constructErrors check 2)`,
+              `\n    construct ERRORS:`, this.constructErrors
+            );
+          } else {
+            DyFM_Log.H_error(
+              `"${this._params.name}" start failed. (ready; constructErrors check 2)`,
+              `\n    construct ERRORS:`, this.getSimplifiedConstructErrors(),
+            );
+          }
+        }
+        
+        throw new DyFM_Error({
+          ...this._getDefaultErrorSettings(
+            'ready',
+            new Error(`"${this._params.name}" start failed.`)
+          ),
+
+          errorCode: 'NTS-AS0-R03',
+          additionalContent: this.constructErrors,
+        });
       }
 
-      if (!ready) {
-        await DyFM_wait(100);
+      if (ready) {
+        this.systemControls.app.started = true;
+        
+        if (this.fnLogs && this.deepLog) DyFM_Log.log('\nfn:. ready: return');
+
+        return;
       }
-    }
 
-    if (timeout < +new Date() - start) {
-      if (DyNTS_global_settings.log_settings.highDetailedLogs) {
-        DyFM_Log.H_error(
-          `${this._params.name} start failed. TIMEOUT`,
-          `\n    construct ERRORS:`, this.constructErrors
-        );
-      } else {
-        DyFM_Log.H_error(
-          `${this._params.name} start failed. TIMEOUT`, 
-          `\n    construct ERRORS:`, 
-          this.constructErrors.map((error: any): any => {
-            if (error instanceof DyFM_Error) {
-              return error.getErrorSimplified();
-            } else {
-              return error;
-            }
-          }), 
-        );
+      this.systemControls.app.started = false;
+      
+      let msg: string = `"${this._params.name}" start failed. UNKNOWN`;
+
+      if (this.systemControls.mongoose.init && !this.systemControls.mongoose.started) {
+        msg += `\nMongoose start failed.`;
       }
 
-      throw new DyFM_Error({
-        ...this._getDefaultErrorSettings(
-          'ready',
-          new Error(`${this._params.name} start failed. TIMEOUT`)
-        ),
+      if (this.systemControls.httpServer.init && !this.systemControls.httpServer.started) {
+        msg += `\nHTTP Server start failed.`;
+      }
+
+      if (this.systemControls.httpsServer.init && !this.systemControls.httpsServer.started) {
+        msg += `\nHTTPS Server start failed.`;
+      }
 
-        errorCode: 'NTS-AS0-R02',
+      DyFM_Log.error(msg, this.constructErrors);
+
+      throw new DyFM_Error({ 
+        ...this._getDefaultErrorSettings('ready', new Error(msg)),
+
+        errorCode: 'NTS-AS0-R04',
         additionalContent: {
           constructErrors: this.constructErrors,
           systemControls: this.systemControls,
           systemReadies: {
-            mongoose: this.systemControls.mongoose.getReady(),
-            httpServer: this.systemControls.httpServer.getReady(),
-            httpsServer: this.systemControls.httpsServer.getReady(),
+            app: this.systemControls.app.getIsReady(),
+            mongoose: this.systemControls.mongoose.getIsReady(),
+            httpServer: this.systemControls.httpServer.getIsReady(),
+            httpsServer: this.systemControls.httpsServer.getIsReady(),
           },
         },
+        error: this.constructErrors?.[0] ?? new Error(),
       });
-    }
-
-    if (this.constructErrors.length) {
-      if (DyNTS_global_settings.log_settings.highDetailedLogs) {
-        DyFM_Log.H_error(
-          `${this._params.name} start failed. (ready check 2)`,
-          `\n    construct ERRORS:`, this.constructErrors
-        );
-      } else {
-        DyFM_Log.H_error(
-          `${this._params.name} start failed.  (ready check 2)`,
-          `\n    construct ERRORS:`, 
-          this.constructErrors.map((error: any): any => {
-            if (error instanceof DyFM_Error) {
-              return error.getErrorSimplified();
-            } else {
-              return error;
-            }
-          }), 
-        );
-      }
-      
+    } catch (error) {
       throw new DyFM_Error({
-        ...this._getDefaultErrorSettings(
-          'ready',
-          new Error(`${this._params.name} start failed.`)
-        ),
-
-        errorCode: 'NTS-AS0-R03',
-        additionalContent: this.constructErrors,
+        ...this._getDefaultErrorSettings('ready', error),
+        
+        errorCode: 'NTS-AS0-READY0',
       });
     }
+  }
 
-    if (ready) {
-      this.systemControls.app.started = true;
-      
-      if (this.fnLogs && this.deepLog) DyFM_Log.log('\nfn:. ready: return');
-
-      return;
-    }
-
-    this.systemControls.app.started = false;
-    
-    let msg: string = `${this._params.name} start failed. UNKNOWN`;
-
-    if (this.systemControls.mongoose.init && !this.systemControls.mongoose.started) {
-      msg += `\nMongoose start failed.`;
-    }
-
-    if (this.systemControls.httpServer.init && !this.systemControls.httpServer.started) {
-      msg += `\nHTTP Server start failed.`;
-    }
-
-    if (this.systemControls.httpsServer.init && !this.systemControls.httpsServer.started) {
-      msg += `\nHTTPS Server start failed.`;
-    }
-
-    DyFM_Log.error(msg, this.constructErrors);
-
-    throw new DyFM_Error({ 
-      ...this._getDefaultErrorSettings(
-        'ready',
-        new Error(msg)
-      ),
-
-      errorCode: 'NTS-AS0-R04',
-      additionalContent: {
-        constructErrors: this.constructErrors,
-        systemControls: this.systemControls,
-        systemReadies: {
-          app: this.systemControls.app.getReady(),
-          mongoose: this.systemControls.mongoose.getReady(),
-          httpServer: this.systemControls.httpServer.getReady(),
-          httpsServer: this.systemControls.httpsServer.getReady(),
-        },
-      },
-      error: this.constructErrors?.[0] ?? new Error(),
+  protected getSimplifiedConstructErrors(): string[] {
+    return this.constructErrors.map((error: any): any => {
+      if (error instanceof DyFM_Error) {
+        return error.getErrorSimplified();
+      } else {
+        return error;
+      }
     });
   }
 
   async stop(dontLog?: boolean): Promise<void> {
-    DyFM_Log.info('\nstoping server...\n');
-
-    await this.ready();
-
-    if (this.started) {
-
-      if (this.systemControls.mongoose.init) {
-        DyFM_Log.info(`\nstopping Mongoose....`);
+    try {
+      DyFM_Log.info('\nstopping server...\n');
 
-        let tryCount: number = 0;
+      await this.ready();
 
-        while (
-          !this.systemControls.mongoose.started && 
-          !this.constructErrors.length &&
-          tryCount++ < 10
-        ) {
-          DyFM_Log.warn(`Mongoose not even started yet....`);
-          await DyFM_wait(second);
-        }
-        this.systemControls.mongoose.started = false;
+      if (this.started) {
 
-        if (this.mongoose) {
-          await DyFM_Array.asyncForEach(
-            Object.keys(this.mongoose.models), 
-            async (modelName): Promise<void> => {
-              await this.mongoose.deleteModel(modelName);
-            }
-          );
+        if (this.systemControls.mongoose.init) {
+          DyFM_Log.info(`\nstopping Mongoose....`);
 
-          const disconnect: Promise<void> = new Promise((resolve): void => {
-            this.mongoose.connection.on('disconnecting', (): void => {
-              resolve();
-            });
-          });
-          
-          await this.mongoose.disconnect();
-          await this.mongoose.connection.close();
-          await disconnect;
+          let tryCount: number = 0;
 
           while (
-            this.mongoose.connection.readyState !== 0 && 
-            !this.constructErrors.length
+            !this.systemControls.mongoose.started && 
+            !this.constructErrors.length &&
+            tryCount++ < 10
           ) {
-            DyFM_Log.warn(`\nMongoose still not disconnected....`);
+            DyFM_Log.warn(`Mongoose not even started yet....`);
             await DyFM_wait(second);
           }
-        } else {
-          DyFM_Log.error(`\nMongoose not found.`);
+          this.systemControls.mongoose.started = false;
+
+          if (this.mongoose) {
+            await DyFM_Array.asyncForEach(
+              Object.keys(this.mongoose.models), 
+              async (modelName): Promise<void> => {
+                this.mongoose.deleteModel(modelName);
+              }
+            );
+
+            const disconnect: Promise<void> = new Promise((resolve): void => {
+              this.mongoose.connection.on('disconnecting', (): void => {
+                resolve();
+              });
+            });
+            
+            await this.mongoose.disconnect();
+            await this.mongoose.connection.close();
+            await disconnect;
+
+            while (
+              this.mongoose.connection.readyState !== 0 && 
+              !this.constructErrors.length
+            ) {
+              DyFM_Log.warn(`\nMongoose still not disconnected....`);
+              await DyFM_wait(second);
+            }
+          } else {
+            DyFM_Log.error(`\nMongoose not found.`);
+          }
+          this.systemControls.mongoose.init = false;
         }
-        this.systemControls.mongoose.init = false;
-      }
 
-      if (this.systemControls.httpServer.init) {
-        this.systemControls.httpServer.started = false;
+        if (this.systemControls.httpServer.init) {
+          this.systemControls.httpServer.started = false;
 
-        if (this.httpServer) {
-          await new Promise((resolve): void => {
-            this.httpServer.close(resolve);
-          });
-        } else {
-          DyFM_Log.error(`\nHTTP Server not found.`);
+          if (this.httpServer) {
+            await new Promise((resolve): void => {
+              this.httpServer.close(resolve);
+            });
+          } else {
+            DyFM_Log.error(`\nHTTP Server not found.`);
+          }
+          this.systemControls.httpServer.init = false;
         }
-        this.systemControls.httpServer.init = false;
-      }
 
-      if (this.systemControls.httpsServer.init) {
-        this.systemControls.httpsServer.started = false;
+        if (this.systemControls.httpsServer.init) {
+          this.systemControls.httpsServer.started = false;
 
-        if (this.httpsServer) {
-          await new Promise((resolve): void => {
-            this.httpsServer.close(resolve);
-          });
-        } else {
-          DyFM_Log.error(`\nHTTPS Server not found.`);
+          if (this.httpsServer) {
+            await new Promise((resolve): void => {
+              this.httpsServer.close(resolve);
+            });
+          } else {
+            DyFM_Log.error(`\nHTTPS Server not found.`);
+          }
+          this.systemControls.httpsServer.init = false;
         }
-        this.systemControls.httpsServer.init = false;
-      }
 
-      if (!dontLog) {
-        DyFM_Log.H_log(`${this._params.name} stopped successfully.`);
+        await DyFM_wait(second);
+
+        if (!dontLog) {
+          DyFM_Log.H_log(`"${this._params.name}" stopped successfully.`);
+        }
       }
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings('stop', error),
+        
+        errorCode: 'NTS-AS0-STOP0',
+      });
     }
   }
 
@@ -692,66 +717,77 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
   private async startDB(): Promise<void> {
     if (this.fnLogs && this.deepLog) DyFM_Log.log('\nfn:. startDB');
 
-    await new Promise<void>(
-      (resolve, reject): void => {
-        this.systemControls.mongoose.init = true;
+    try {
+      await new Promise<void>(
+        (resolve, reject): void => {
+          this.systemControls.mongoose.init = true;
 
-        this.mongoose.connection
-          .once('open', (): void => {
-            this.systemControls.mongoose.started = true;
-            DyFM_Log.success('\nConnected to MongoDB\n');
+          this.mongoose.connection
+            .once('open', (): void => {
+              this.systemControls.mongoose.started = true;
+              DyFM_Log.success('\nConnected to MongoDB\n');
 
-            resolve();
-          })
-          .on('error', (error): void => {
-            if (!this.systemControls.mongoose.started) {
-              this.constructErrors.push(error);
-  
-              if (this.debugLog) DyFM_Log.error(
-                '\nUnable to connect to MongoDB server, ERROR: ', 
-                error
-              );
+              resolve();
+            })
+            .on('error', (error): void => {
+              if (!this.systemControls.mongoose.started) {
+                this.constructErrors.push(error);
 
-              const d_error: DyFM_Error = new DyFM_Error({
-                ...this._getDefaultErrorSettings(
-                  'startDB',
+                if (this.debugLog) DyFM_Log.error(
+                  '\nUnable to connect to MongoDB server, ERROR: ', 
                   error
-                ),
-  
-                errorCode: 'NTS-AS0-SDB1',
-                message: `Unable to start connection to MongoDB server, ERROR: ${error}`,
-              });
+                );
 
-              DyNTS_GlobalService.globalErrorHandler?.(d_error);
-              reject(d_error);
+                const d_error: DyFM_Error = new DyFM_Error({
+                  ...this._getDefaultErrorSettings('startDB', error),
+    
+                  errorCode: 'NTS-AS0-SDB1',
+                  message: `Unable to start connection to MongoDB server, ERROR: ${error}`,
+                });
 
-            } else {  
-              if (this.debugLog) DyFM_Log.error('\nMongoDB ERROR: ', error);
+                DyNTS_GlobalService.globalErrorHandler?.(d_error);
 
-              const d_error: DyFM_Error = new DyFM_Error({
-                ...this._getDefaultErrorSettings(
-                  'mongoose.connection.on(error)',
-                  error
-                ),
-  
-                errorCode: 'NTS-AS0-SDB2',
-                message: `MongoDB ERROR: ${error}`,
-                level: DyFM_ErrorLevel.critical,
-              });
+                reject(d_error);
 
-              DyNTS_GlobalService.globalErrorHandler?.(d_error);
-            }
-          });
+              } else {  
+                if (this.debugLog) DyFM_Log.error('\nMongoDB ERROR: ', error);
 
-        this.mongoose.connect(
-          this._params.dbUri, 
-          {
-            useNewUrlParser: true,
-            useUnifiedTopology: true,
+                const d_error: DyFM_Error = new DyFM_Error({
+                  ...this._getDefaultErrorSettings('mongoose.connection.on(error)', error),
+    
+                  errorCode: 'NTS-AS0-SDB2',
+                  message: `MongoDB ERROR: ${error}`,
+                  level: DyFM_ErrorLevel.critical,
+                });
+
+                DyNTS_GlobalService.globalErrorHandler?.(d_error);
+              }
+            });
+
+          try {
+            this.mongoose.connect(
+              this._params.dbUri, 
+              {
+                useNewUrlParser: true,
+                useUnifiedTopology: true,
+              }
+            );
+          } catch (error) {
+            throw new DyFM_Error({
+              ...this._getDefaultErrorSettings('startDB', error),
+              
+              errorCode: 'NTS-AS0-SDB3',
+            });
           }
-        );
-      }
-    );
+        }
+      );
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings('startDB', error),
+        
+        errorCode: 'NTS-AS0-SDB0',
+      });
+    }
   }
 
   /**
@@ -760,79 +796,87 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
   private async initExpresses(): Promise<void> {
     if (this.fnLogs && this.deepLog) DyFM_Log.log('\nfn:. initExpresses');
 
-    if (this._security && this._security !== DyNTS_RouteSecurity.secure) {
-      if (!this._portSettings.httpPort) {
-        let errorMsg: string =
-          `\nYou have open routes, but httpPort is not set!` +
-          `\nsecurity: ${this._security}` +
-          `\nset httpPort in DynamoBEServer - setupRoutingModules() to enable secure routes.`;
-        
-        errorMsg += '\n\nThe routes setted to use open server:';
-        this._routingModules.forEach((module: DyNTS_RoutingModule): void => {
-          if (module.security != DyNTS_RouteSecurity.secure) {
-            errorMsg += `\n  ${module.route} (security: ${module.security})`;
-            errorMsg += `\n  subroutes using open sever:`;
-            module.endpoints.forEach((endpoint: DyNTS_Endpoint_Params): void => {
-              if (endpoint.security != DyNTS_RouteSecurity.secure) {
-                errorMsg += `\n    ${endpoint.endpoint} (security: ${endpoint.security})`;
-              }
-            });
-          }
-        });
+    try {
+      if (this._security && this._security !== DyNTS_RouteSecurity.secure) {
+        if (!this._portSettings.httpPort) {
+          let errorMsg: string =
+            `\nYou have open routes, but httpPort is not set!` +
+            `\nsecurity: ${this._security}` +
+            `\nset httpPort in DynamoBEServer - setupRoutingModules() to enable secure routes.`;
+          
+          errorMsg += '\n\nThe routes setted to use open server:';
+          this._routingModules.forEach((module: DyNTS_RoutingModule): void => {
+            if (module.security != DyNTS_RouteSecurity.secure) {
+              errorMsg += `\n  ${module.route} (security: ${module.security})`;
+              errorMsg += `\n  subroutes using open sever:`;
+              module.endpoints.forEach((endpoint: DyNTS_Endpoint_Params): void => {
+                if (endpoint.security != DyNTS_RouteSecurity.secure) {
+                  errorMsg += `\n    ${endpoint.endpoint} (security: ${endpoint.security})`;
+                }
+              });
+            }
+          });
 
-        const error = new Error('Open routes cannot be established!');
-        const errorStack: string[] = error.stack.split('\n');
+          const error = new Error('Open routes cannot be established!');
+          const errorStack: string[] = error.stack.split('\n');
 
-        errorStack.splice(1, 2);
-        error.stack = errorStack.join('\n');
+          errorStack.splice(1, 2);
+          error.stack = errorStack.join('\n');
 
-        DyFM_Log.error(errorMsg);
+          DyFM_Log.error(errorMsg);
 
-        throw error;
+          throw error;
+        }
+
+        await this.initOpenExpress();
       }
 
-      await this.initOpenExpress();
-    }
+      if (this._security && this._security !== DyNTS_RouteSecurity.open) {
+        if (!this._cert || !this._portSettings.httpsPort) {
+          let errorMsg: string =
+            `\nYou have secure routes, but the certification paths or httpsPort are not set!` +
+            `\nsecurity: ${this._security}` +
+            `\nset...` +
+            `\n(missing exact howto...)` +
+            /* `\n  httpsPort and` +
+            `\n  cert: {` +
+            `\n    keyPath: FileSystem.PathLike,` +
+            `\n    certPath: FileSystem.PathLike,` +
+            `\n  }` + */
+            `\nin DynamoBEServer - getRoutingModules() to enable secure routes.`;        
+
+          errorMsg += '\n\nThe routes setted to use secure server:';
+          this._routingModules.forEach((module: DyNTS_RoutingModule): void => {
+            if (module.security && module.security !== DyNTS_RouteSecurity.open) {
+              errorMsg += `\n  ${module.route} (security: ${module.security})`;
+              errorMsg += `\n  subroutes using secure sever:`;
+              module.endpoints.forEach((endpoint: DyNTS_Endpoint_Params): void => {
+                if (endpoint.security && endpoint.security !== DyNTS_RouteSecurity.open) {
+                  errorMsg += `\n    ${endpoint.endpoint} (security: ${endpoint.security})`;
+                }
+              });
+            }
+          });
 
-    if (this._security && this._security !== DyNTS_RouteSecurity.open) {
-      if (!this._cert || !this._portSettings.httpsPort) {
-        let errorMsg: string =
-          `\nYou have secure routes, but the certification paths or httpsPort are not set!` +
-          `\nsecurity: ${this._security}` +
-          `\nset...` +
-          `\n(missing exact howto...)` +
-          /* `\n  httpsPort and` +
-          `\n  cert: {` +
-          `\n    keyPath: FileSystem.PathLike,` +
-          `\n    certPath: FileSystem.PathLike,` +
-          `\n  }` + */
-          `\nin DynamoBEServer - getRoutingModules() to enable secure routes.`;        
-
-        errorMsg += '\n\nThe routes setted to use secure server:';
-        this._routingModules.forEach((module: DyNTS_RoutingModule): void => {
-          if (module.security && module.security !== DyNTS_RouteSecurity.open) {
-            errorMsg += `\n  ${module.route} (security: ${module.security})`;
-            errorMsg += `\n  subroutes using secure sever:`;
-            module.endpoints.forEach((endpoint: DyNTS_Endpoint_Params): void => {
-              if (endpoint.security && endpoint.security !== DyNTS_RouteSecurity.open) {
-                errorMsg += `\n    ${endpoint.endpoint} (security: ${endpoint.security})`;
-              }
-            });
-          }
-        });
+          const error = new Error('Secure routes cannot be established!');
+          const errorStack: string[] = error.stack.split('\n');
 
-        const error = new Error('Secure routes cannot be established!');
-        const errorStack: string[] = error.stack.split('\n');
+          errorStack.splice(1, 2);
+          error.stack = errorStack.join('\n');
 
-        errorStack.splice(1, 2);
-        error.stack = errorStack.join('\n');
+          DyFM_Log.error(errorMsg);
 
-        DyFM_Log.error(errorMsg);
+          throw error;
+        }
 
-        throw error;
+        await this.initSecureExpress();
       }
-
-      await this.initSecureExpress();
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings('initExpresses', error),
+        
+        errorCode: 'NTS-AS0-IE0',
+      });
     }
   }
 
@@ -868,6 +912,7 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
    */
   private async startExpresses(): Promise<void> {
     if (this.fnLogs && this.deepLog) DyFM_Log.log('\nfn:. startExpresses');
+
     try {
       if (this._security && this._security !== DyNTS_RouteSecurity.open) {
         await new Promise<void>((resolve, reject): void => {
@@ -886,10 +931,7 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
               
               if (!this.systemControls.httpsServer.started) {
                 const d_error: DyFM_Error = new DyFM_Error({
-                  ...this._getDefaultErrorSettings(
-                    'startExpresses',
-                    error
-                  ),
+                  ...this._getDefaultErrorSettings('startExpresses', error),
 
                   errorCode: 'NTS-AS0-SE1',
                   message: `HTTPS (secure) start server ERROR`,
@@ -902,10 +944,7 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
 
               } else {
                 const d_error: DyFM_Error = new DyFM_Error({
-                  ...this._getDefaultErrorSettings(
-                    'httpsServer.on(error)',
-                    error
-                  ),
+                  ...this._getDefaultErrorSettings('httpsServer.on(error)', error),
 
                   errorCode: 'NTS-AS0-SE2',
                   message: `HTTPS (secure) server ERROR`,
@@ -917,10 +956,7 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
             })
             .on('uncaughtException', (exception): void => {
               const d_error: DyFM_Error = new DyFM_Error({
-                ...this._getDefaultErrorSettings(
-                  'httpsServer.on(uncaughtException)',
-                  exception
-                ),
+                ...this._getDefaultErrorSettings('httpsServer.on(uncaughtException)', exception),
 
                 errorCode: 'NTS-AS0-SE3',
                 message: `HTTPS (secure) server uncaughtException`,
@@ -954,10 +990,7 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
 
               if (!this.systemControls.httpServer.started) {
                 const d_error: DyFM_Error = new DyFM_Error({
-                  ...this._getDefaultErrorSettings(
-                    'startExpresses',
-                    error
-                  ),
+                  ...this._getDefaultErrorSettings('startExpresses', error),
 
                   errorCode: 'NTS-AS0-SE3',
                   message: `HTTP (open) start server ERROR`,
@@ -970,10 +1003,7 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
 
               } else {
                 const d_error: DyFM_Error = new DyFM_Error({
-                  ...this._getDefaultErrorSettings(
-                    'httpServer.on(error)',
-                    error
-                  ),
+                  ...this._getDefaultErrorSettings('httpServer.on(error)', error),
 
                   errorCode: 'NTS-AS0-SE4',
                   message: `HTTP (open) server ERROR`,
@@ -985,10 +1015,7 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
             })
             .on('uncaughtException', (exception): void => {
               const d_error: DyFM_Error = new DyFM_Error({
-                ...this._getDefaultErrorSettings(
-                  'httpServer.on(uncaughtException)',
-                  exception
-                ),
+                ...this._getDefaultErrorSettings('httpServer.on(uncaughtException)', exception),
 
                 errorCode: 'NTS-AS0-SE5',
                 message: `HTTP (open) server uncaughtException`,
@@ -1004,9 +1031,11 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
         });
       }
     } catch (error) {
-      DyFM_Log.error(`startExpresses failed...`, error);
-
-      throw error;
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings('startExpresses', error),
+        
+        errorCode: 'NTS-AS0-SE0',
+      });
     }
   }
 
@@ -1017,10 +1046,7 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
     try {
       if (error) {
         const d_error: DyFM_Error = new DyFM_Error({
-          ...this._getDefaultErrorSettings(
-            'expressErrorHandling',
-            error
-          ),
+          ...this._getDefaultErrorSettings('expressErrorHandling', error),
 
           errorCode: 'NTS-AS0-EEH1',
           message: `Express ERROR`,
@@ -1053,96 +1079,106 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
    * 
    */
   private async mountSecureRoutes (): Promise<void> {
-    if (this.fnLogs && this.deepLog) DyFM_Log.log('\nfn:. mountSecureRoutes');
-    
-    this.openExpress.use(
-      (error, req, res, next): Promise<void> => this.expressErrorHandling(error, req, res, next)
-    );
-
-    await DyFM_Array.asyncForEach(
-      this._routingModules, 
-      async (module: DyNTS_RoutingModule): Promise<void> => {
-        if (module.security !== DyNTS_RouteSecurity.open) {
-          if (this.logSetup) { 
-            DyFM_Log.log(`route mount (secure): ${module.route}`);
-          }
-          
-          const existingRoutes: DyNTS_RoutingModule[] = this._routingModules.filter(
-            (mod: DyNTS_RoutingModule): boolean => mod.route === module.route
-          );
+    try {
+      if (this.fnLogs && this.deepLog) DyFM_Log.log('\nfn:. mountSecureRoutes');
+      
+      this.openExpress.use(
+        (error, req, res, next): Promise<void> => this.expressErrorHandling(error, req, res, next)
+      );
 
-          if (1 < existingRoutes.length) {
-            const error: Error = new Error(`ROUTE DUPLICATION: ${module.route}`);
-            const errorStack: string[] = error.stack.split('\n');
+      await DyFM_Array.asyncForEach(
+        this._routingModules, 
+        async (module: DyNTS_RoutingModule): Promise<void> => {
+          if (module.security !== DyNTS_RouteSecurity.open) {
+            if (this.logSetup) { 
+              DyFM_Log.log(`route mount (secure): ${module.route}`);
+            }
+            
+            const existingRoutes: DyNTS_RoutingModule[] = this._routingModules.filter(
+              (mod: DyNTS_RoutingModule): boolean => mod.route === module.route
+            );
 
-            errorStack.splice(1, 4);
-            error.stack = errorStack.join('\n');
-    
-            DyFM_Log.error(`ROUTE DUPLICATION: ${module.route}`, error);
+            if (1 < existingRoutes.length) {
+              const error: Error = new Error(`ROUTE DUPLICATION: ${module.route}`);
+              const errorStack: string[] = error.stack.split('\n');
 
-            throw new DyFM_Error({
-              ...this._getDefaultErrorSettings(
-                'mountSecureRoutes',
-                error
-              ),
+              errorStack.splice(1, 4);
+              error.stack = errorStack.join('\n');
+      
+              DyFM_Log.error(`ROUTE DUPLICATION: ${module.route}`, error);
 
-              errorCode: 'NTS-AS0-MSR1',
-              message: `ROUTE DUPLICATION: ${module.route}`,
-            });
-          }
+              throw new DyFM_Error({
+                ...this._getDefaultErrorSettings('mountSecureRoutes', error),
 
-          this.secureExpress.use(module.route, module.secureRouter);
+                errorCode: 'NTS-AS0-MSR1',
+                message: `ROUTE DUPLICATION: ${module.route}`,
+              });
+            }
+
+            this.secureExpress.use(module.route, module.secureRouter);
+          }
         }
-      }
-    );
+      );
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings('mountSecureRoutes', error),
+
+        errorCode: 'NTS-AS0-MSR0',
+      });
+    }
   }
 
   /**
    * 
    */
   private async mountOpenRoutes(): Promise<void> {
-    if (this.fnLogs && this.deepLog) DyFM_Log.log('\nfn:. mountOpenRoutes');
-
-    this.openExpress.use(
-      (error, req, res, next): Promise<void> => this.expressErrorHandling(error, req, res, next)
-    );
-
-    await DyFM_Array.asyncForEach(
-      this._routingModules, 
-      async (module: DyNTS_RoutingModule): Promise<void> => {
-        if (module.security !== DyNTS_RouteSecurity.secure) {
-          if (this.logSetup) {
-            DyFM_Log.log(`route mount (open): ${module.route}`);
-          }
-
-          const existingRoutes: DyNTS_RoutingModule[] = this._routingModules.filter(
-            (mod: DyNTS_RoutingModule): boolean => mod.route === module.route
-          );
-
-          if (1 < existingRoutes.length) {
-            const error: Error = new Error(`ROUTE DUPLICATION: ${module.route}`);
-            const errorStack: string[] = error.stack.split('\n');
-
-            errorStack.splice(1, 4);
-            error.stack = errorStack.join('\n');
-    
-            DyFM_Log.error(`ROUTE DUPLICATION: ${module.route}`, error);
-
-            throw new DyFM_Error({
-              ...this._getDefaultErrorSettings(
-                'mountOpenRoutes',
-                error
-              ),
-
-              errorCode: 'NTS-AS0-MOR1',
-              message: `ROUTE DUPLICATION: ${module.route}`,
-            });
+    try {
+      if (this.fnLogs && this.deepLog) DyFM_Log.log('\nfn:. mountOpenRoutes');
+  
+      this.openExpress.use(
+        (error, req, res, next): Promise<void> => this.expressErrorHandling(error, req, res, next)
+      );
+  
+      await DyFM_Array.asyncForEach(
+        this._routingModules, 
+        async (module: DyNTS_RoutingModule): Promise<void> => {
+          if (module.security !== DyNTS_RouteSecurity.secure) {
+            if (this.logSetup) {
+              DyFM_Log.log(`route mount (open): ${module.route}`);
+            }
+  
+            const existingRoutes: DyNTS_RoutingModule[] = this._routingModules.filter(
+              (mod: DyNTS_RoutingModule): boolean => mod.route === module.route
+            );
+  
+            if (1 < existingRoutes.length) {
+              const error: Error = new Error(`ROUTE DUPLICATION: ${module.route}`);
+              const errorStack: string[] = error.stack.split('\n');
+  
+              errorStack.splice(1, 4);
+              error.stack = errorStack.join('\n');
+      
+              DyFM_Log.error(`ROUTE DUPLICATION: ${module.route}`, error);
+  
+              throw new DyFM_Error({
+                ...this._getDefaultErrorSettings('mountOpenRoutes', error),
+  
+                errorCode: 'NTS-AS0-MOR1',
+                message: `ROUTE DUPLICATION: ${module.route}`,
+              });
+            }
+            
+            this.openExpress.use(module.route, module.openRouter);
           }
-          
-          this.openExpress.use(module.route, module.openRouter);
         }
-      }
-    );
+      );
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings('mountOpenRoutes', error),
+        
+        errorCode: 'NTS-AS0-MOR0',
+      });
+    }
   }
 
   /**