@futdevpro/nts-dynamo 1.7.16 → 1.7.20

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

@@ -1,25 +1,40 @@
 
-import Mongoose = require("mongoose");
-import Express = require("express");
+import Mongoose = require('mongoose');
+import Express = require('express');
+/* import Mongoose from 'mongoose';
+import Express from 'express'; */
 
 import * as Http from 'http';
 import * as Https from 'https';
 import * as FileSystem from 'fs';
 import * as BodyParser from 'body-parser';
 
-import { Dynamo_Array, Dynamo_Error, dynamo_error_default, Dynamo_Log, second, wait } from '@futdevpro/fsm-dynamo';
+/* import { version } from '../../../package.json'; */
+
+import { 
+  Dynamo_Array, Dynamo_Error, dynamo_error_default, 
+  Dynamo_ErrorLevel, Dynamo_Log, second, wait 
+} from '@futdevpro/fsm-dynamo';
 
 import { DynamoNTS_SingletonService } from '../base/singleton.service';
 import { DynamoNTS_RouteSecurity } from '../../_enums/route-security.enum';
 import { DynamoNTS_RoutingModule } from '../route/routing-module.service';
 import { DynamoNTS_GlobalService } from '../core/global.service';
 import { DynamoNTS_HttpSettings } from '../../_models/control-models/http-settings.control-model';
-import { DynamoNTS_CertificationSettings } from '../../_models/interfaces/certification-settings.interface';
-import { DynamoNTS_GlobalServiceSettings } from '../../_models/interfaces/global-service-settings.interface';
+import { 
+  DynamoNTS_CertificationSettings 
+} from '../../_models/interfaces/certification-settings.interface';
+import { 
+  DynamoNTS_GlobalServiceSettings 
+} from '../../_models/interfaces/global-service-settings.interface';
 import { dynamoNTS_globalSettings } from '../../_constants/global-settings.const';
 import { DynamoNTS_AppParams } from '../../_models/control-models/app-params.control-model';
-import { DynamoNTS_EndpointParams } from '../../_models/control-models/endpoint-params.control-model';
-import { DynamoNTS_AppSystemControls } from '../../_models/control-models/app-system-controls.control-model';
+import { 
+  DynamoNTS_EndpointParams 
+} from '../../_models/control-models/endpoint-params.control-model';
+import { 
+  DynamoNTS_AppSystemControls 
+} from '../../_models/control-models/app-system-controls.control-model';
 
 
 /**
@@ -118,7 +133,8 @@ import { DynamoNTS_AppSystemControls } from '../../_models/control-models/app-sy
  * // A commonly used basic service, 
  * // which is necessary fur certain functions (such as registering call issuers)
  * // 
- * // This will handle Authentication Token checking/refreshing, checking issuer's identifier and routeParams, 
+ * // This will handle Authentication Token checking/refreshing, 
+ * // checking issuer's identifier and routeParams, 
  * // handling JWT Token, or maybe with OAuth2 or other commonly used security procedures
  * //
  * // You can create one with this Dynamo Object:
@@ -181,25 +197,45 @@ import { DynamoNTS_AppSystemControls } from '../../_models/control-models/app-sy
 export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
   protected systemControls: DynamoNTS_AppSystemControls = new DynamoNTS_AppSystemControls();
-  get started(): boolean { return this.systemControls.app.started; }
-  protected get superStarted(): boolean { return this.systemControls.app.started; }
+  get started(): boolean { 
+    return this.systemControls.app.started; 
+  }
+  protected get superStarted(): boolean { 
+    return this.systemControls.app.started; 
+  }
   protected constructErrors: (Error | Dynamo_Error)[] = [];
-
-  get serverName(): string { return this.params.name; }
+  
+  /* removed since cant use version from package.json
+  private readonly _ntsVersion: string = 'v01.07.18';
+  protected get ntsVersion(): string { 
+    return this._ntsVersion; 
+  } */
+
+  get serverName(): string { 
+    return this.params.name; 
+  }
 
   private _params: DynamoNTS_AppParams;
-  protected get params(): DynamoNTS_AppParams { return this._params; }
+  protected get params(): DynamoNTS_AppParams { 
+    return this._params; 
+  }
   
   protected mongoose = Mongoose;
 
   private _security: DynamoNTS_RouteSecurity;
-  protected get security(): DynamoNTS_RouteSecurity { return this._security; }
+  protected get security(): DynamoNTS_RouteSecurity { 
+    return this._security; 
+  }
 
-  protected _portSettings: DynamoNTS_HttpSettings;
-  protected get portSettings(): DynamoNTS_HttpSettings { return this._portSettings; }
+  protected _portSettings: DynamoNTS_HttpSettings = new DynamoNTS_HttpSettings();
+  protected get portSettings(): DynamoNTS_HttpSettings { 
+    return this._portSettings; 
+  }
 
   private _cert?: DynamoNTS_CertificationSettings;
-  protected get cert(): DynamoNTS_CertificationSettings { return this._cert; }
+  protected get cert(): DynamoNTS_CertificationSettings { 
+    return this._cert; 
+  }
 
   protected openExpress: Express.Application;
   private secureExpress: Express.Application;
@@ -227,9 +263,9 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   constructor(extended?: boolean){
     super();
     
-    process.on('unhandledRejection', (reason: object, p: any) => {
+    process.on('unhandledRejection', (reason: object, p_passWhatIsThis: any): void => {
       Dynamo_Log.highlightedError(
-        'Unhandled Rejection at: ', p, 
+        'Unhandled Rejection at: ', p_passWhatIsThis, 
         '\nRejection reason:', reason
       );
 
@@ -238,8 +274,9 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           new Dynamo_Error({
             errorCode: 'NTS-AS0-BASE-UR',
             message: 'Unhandled Rejection!',
-            error: new Error(p),
-            additionalContent: { reason, p },
+            error: new Error(p_passWhatIsThis),
+            additionalContent: { reason, p: p_passWhatIsThis },
+            level: Dynamo_ErrorLevel.critical,
           })
         );
 
@@ -248,7 +285,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
       }
     });
 
-    this.asyncConstruct(extended).catch((error: any) => {
+    this.asyncConstruct(extended).catch((error: any): void => {
       Dynamo_Log.error(
         `\nApplication: ${this._params.name} start failed.` +
         `\n`, error
@@ -257,22 +294,21 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   }
 
   private async asyncConstruct(extended?: boolean): Promise<void> {
-    if (this.logFn && this.deepLog) console.log('\nfn:. asyncConstruct');
+    if (this.logFn && this.deepLog) Dynamo_Log.log('\nfn:. asyncConstruct');
     try {
-      console.log(
+      this.systemControls.app.init = true;
+      this._params = this.getAppParams();  
+      Dynamo_Log.log(
         `\n\n\n\n\n\n\n\n\n\n` +
         `Starting ${this._params?.name}... `
       );
 
-      this.systemControls.app.init = true;
-      this._params = this.getAppParams();  
-
       if (!this._params) {
         throw new Error('getAppParams() must return a DynamoNTS_AppParams object!');
       }
       
       process.stdout.write(
-        String.fromCharCode(27) + "]0;" + 
+        String.fromCharCode(27) + ']0;' + 
         this._params?.name + 
         String.fromCharCode(7)
       );
@@ -284,7 +320,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
       this.logSetup = dynamoNTS_globalSettings.logSetup;
       
       this.globalService = DynamoNTS_GlobalService.getInstance();
-      DynamoNTS_GlobalService.setServices(this.getGlobalServiceCollection());
+      await DynamoNTS_GlobalService.setServices(this.getGlobalServiceCollection());
       DynamoNTS_GlobalService.setParams(this.params);
 
       if (this.getPortSettings) {
@@ -299,10 +335,10 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
         this._routingModules = this.getRoutingModules();
       }
 
-      await this.createEntries?.();
-
       await this.startDB();
 
+      await this.createEntries?.();
+
       this.setSecurity();
           
       if (this._routingModules?.length) {
@@ -312,12 +348,13 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
         if (this._security !== DynamoNTS_RouteSecurity.secure) {
           await this.mountOpenRoutes();
         }
+
         if (this._security !== DynamoNTS_RouteSecurity.open && this._cert) {
           await this.mountSecureRoutes();
         }
 
         if (this.logSetup) {
-          console.log(`\nRoutes mounted.... server using security: ${this._security}`);
+          Dynamo_Log.log(`\nRoutes mounted.... server using security: ${this._security}`);
         }
       }
 
@@ -332,14 +369,16 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
         await this.ready();
 
         if (this.params.title) {
-          console.log(this.params.title);
-          console.log(`Version: ${this.params.version}`);
+          Dynamo_Log.success(this.params.title);
         }
+        Dynamo_Log.info(`Version: ${this.params.version}`);
+        /* Dynamo_Log.info(`NTS Version: ${this.ntsVersion}`); */
         Dynamo_Log.H_success(`${this.params.name} started successfully.`);
       }
     } catch (error) {
       this.constructErrors.push(error);
       Dynamo_Log.error(`${this._params.name} start failed. ERRORS`, this.constructErrors);
+
       throw new Dynamo_Error({
         ...this._getDefaultErrorSettings(
           'asyncConstruct',
@@ -362,12 +401,13 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   }
 
   async ready(timeout: number = 4 * second): Promise<void> {
-    if (this.logFn) console.log('\nfn:. ready');
+    if (this.logFn) Dynamo_Log.log('\nfn:. ready');
     let ready: boolean = false;
     const start: number = +new Date();
 
     if (this.constructErrors.length) {
       Dynamo_Log.error(`${this._params.name} start failed. ERRORS`, this.constructErrors);
+
       throw new Dynamo_Error({ 
         ...this._getDefaultErrorSettings(
           'ready',
@@ -375,7 +415,10 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
         ),
 
         errorCode: 'NTS-AS0-R1',
-        additionalContent: this.constructErrors.length === 1 ? this.constructErrors[0] : { errors: this.constructErrors },
+        additionalContent: 
+          this.constructErrors.length === 1 ? 
+            this.constructErrors[0] : 
+            { errors: this.constructErrors },
       });
     }
 
@@ -397,6 +440,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
     if (timeout < +new Date() - start) {
       Dynamo_Log.error(`${this._params.name} start failed. TIMEOUT`, this.constructErrors);
+
       throw new Dynamo_Error({
         ...this._getDefaultErrorSettings(
           'ready',
@@ -433,23 +477,28 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
     if (ready) {
       this.systemControls.app.started = true;
       
-      if (this.logFn && this.deepLog) console.log('\nfn:. ready: return');
+      if (this.logFn && this.deepLog) Dynamo_Log.log('\nfn:. ready: return');
+
       return;
     } else {
       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.`;
       }
 
       Dynamo_Log.error(msg, this.constructErrors);
+
       throw new Dynamo_Error({ 
         ...this._getDefaultErrorSettings(
           'ready',
@@ -473,18 +522,52 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   }
 
   async stop(dontLog?: boolean): Promise<void> {
-    if (this.logFn) console.log('\nfn:. stop');
+    Dynamo_Log.info('\nstoping server...\n');
+
+    await this.ready();
+
     if (this.started) {
 
       if (this.systemControls.mongoose.init) {
+        Dynamo_Log.info(`\nstopping Mongoose....`);
+
+        let tryCount: number = 0;
+
+        while (
+          !this.systemControls.mongoose.started && 
+          !this.constructErrors.length &&
+          tryCount++ < 10
+        ) {
+          Dynamo_Log.warn(`Mongoose not even started yet....`);
+          await wait(second);
+        }
         this.systemControls.mongoose.started = false;
 
         if (this.mongoose) {
-          await Dynamo_Array.asyncForEach(Object.keys(this.mongoose.models), async (modelName) => {
-            await this.mongoose.deleteModel(modelName);
+          await Dynamo_Array.asyncForEach(
+            Object.keys(this.mongoose.models), 
+            async (modelName): Promise<void> => {
+              await 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
+          ) {
+            Dynamo_Log.warn(`\nMongoose still not disconnected....`);
+            await wait(second);
+          }
         } else {
           Dynamo_Log.error(`\nMongoose not found.`);
         }
@@ -493,8 +576,9 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
       if (this.systemControls.httpServer.init) {
         this.systemControls.httpServer.started = false;
+
         if (this.httpServer) {
-          await new Promise((resolve) => {
+          await new Promise((resolve): void => {
             this.httpServer.close(resolve);
           });
         } else {
@@ -505,8 +589,9 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
       if (this.systemControls.httpsServer.init) {
         this.systemControls.httpsServer.started = false;
+
         if (this.httpsServer) {
-          await new Promise((resolve) => {
+          await new Promise((resolve): void => {
             this.httpsServer.close(resolve);
           });
         } else {
@@ -525,24 +610,27 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
    * 
    */
   private async startDB(): Promise<void> {
-    if (this.logFn && this.deepLog) console.log('\nfn:. startDB');
+    if (this.logFn && this.deepLog) Dynamo_Log.log('\nfn:. startDB');
 
     await new Promise<void>(
-      async (resolve, reject) => {
+      (resolve, reject): void => {
         this.systemControls.mongoose.init = true;
 
         this.mongoose.connection
-          .once('open', () => {
+          .once('open', (): void => {
             this.systemControls.mongoose.started = true;
             Dynamo_Log.success('\nConnected to MongoDB\n');
 
             resolve();
           })
-          .on('error', (error) => {
+          .on('error', (error): void => {
             if (!this.systemControls.mongoose.started) {
               this.constructErrors.push(error);
   
-              if (this.debugLog) Dynamo_Log.error('\nUnable to connect to MongoDB server, ERROR: ', error);
+              if (this.debugLog) Dynamo_Log.error(
+                '\nUnable to connect to MongoDB server, ERROR: ', 
+                error
+              );
 
               const d_error: Dynamo_Error = new Dynamo_Error({
                 ...this._getDefaultErrorSettings(
@@ -568,6 +656,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   
                 errorCode: 'NTS-AS0-SDB2',
                 message: `MongoDB ERROR: ${error}`,
+                level: Dynamo_ErrorLevel.critical,
               });
 
               DynamoNTS_GlobalService.globalErrorHandler?.(d_error);
@@ -578,7 +667,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           this._params.dbUri, 
           {
             useNewUrlParser: true,
-            useUnifiedTopology: true 
+            useUnifiedTopology: true,
           }
         );
       }
@@ -589,7 +678,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
    * 
    */
   private async initExpresses(): Promise<void> {
-    if (this.logFn && this.deepLog) console.log('\nfn:. initExpresses');
+    if (this.logFn && this.deepLog) Dynamo_Log.log('\nfn:. initExpresses');
 
     if (this._security && this._security !== DynamoNTS_RouteSecurity.secure) {
       if (!this._portSettings.httpPort) {
@@ -599,10 +688,11 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           `\nset httpPort in DynamoBEServer - setupRoutingModules() to enable secure routes.`;
         
         errorMsg += '\n\nThe routes setted to use open server:';
-        this._routingModules.forEach((module: DynamoNTS_RoutingModule) => {
+        this._routingModules.forEach((module: DynamoNTS_RoutingModule): void => {
           if (module.security != DynamoNTS_RouteSecurity.secure) {
-            errorMsg += `\n  ${module.route} (security: ${module.security}) \n  subroutes using open sever:`;
-            module.endpoints.forEach((endpoint: DynamoNTS_EndpointParams) => {
+            errorMsg += `\n  ${module.route} (security: ${module.security})`;
+            errorMsg += `\n  subroutes using open sever:`;
+            module.endpoints.forEach((endpoint: DynamoNTS_EndpointParams): void => {
               if (endpoint.security != DynamoNTS_RouteSecurity.secure) {
                 errorMsg += `\n    ${endpoint.endpoint} (security: ${endpoint.security})`;
               }
@@ -610,12 +700,14 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           }
         });
 
-        let error = new Error('Open routes cannot be established!');
-        let 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');
 
         Dynamo_Log.error(errorMsg);
+
         throw error;
       }
 
@@ -637,10 +729,11 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           `\nin DynamoBEServer - getRoutingModules() to enable secure routes.`;        
 
         errorMsg += '\n\nThe routes setted to use secure server:';
-        this._routingModules.forEach((module: DynamoNTS_RoutingModule) => {
+        this._routingModules.forEach((module: DynamoNTS_RoutingModule): void => {
           if (module.security && module.security !== DynamoNTS_RouteSecurity.open) {
-            errorMsg += `\n  ${module.route} (security: ${module.security}) \n  subroutes using secure sever:`;
-            module.endpoints.forEach((endpoint: DynamoNTS_EndpointParams) => {
+            errorMsg += `\n  ${module.route} (security: ${module.security})`;
+            errorMsg += `\n  subroutes using secure sever:`;
+            module.endpoints.forEach((endpoint: DynamoNTS_EndpointParams): void => {
               if (endpoint.security && endpoint.security !== DynamoNTS_RouteSecurity.open) {
                 errorMsg += `\n    ${endpoint.endpoint} (security: ${endpoint.security})`;
               }
@@ -648,12 +741,14 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           }
         });
 
-        let error = new Error('Secure routes cannot be established!');
-        let 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');
 
         Dynamo_Log.error(errorMsg);
+
         throw error;
       }
 
@@ -665,7 +760,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
    * 
    */
   protected async initOpenExpress(): Promise<void> {
-    if (this.logFn) console.log('\nfn:. initOpenExpress');
+    if (this.logFn) Dynamo_Log.log('\nfn:. initOpenExpress');
     this.openExpress = Express();    
     this.openExpress.use(BodyParser.urlencoded(this._portSettings.httpUrlencoded));
     this.openExpress.use(BodyParser.json(this._portSettings.httpJson));
@@ -675,7 +770,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
    * 
    */
   protected async initSecureExpress(): Promise<void> {
-    if (this.logFn) console.log('\nfn:. initSecureExpress');
+    if (this.logFn) Dynamo_Log.log('\nfn:. initSecureExpress');
     this.secureExpress = Express();    
     this.secureExpress.use(BodyParser.urlencoded(this._portSettings.httpsUrlencoded));
     this.secureExpress.use(BodyParser.json(this._portSettings.httpsJson));
@@ -684,6 +779,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
       key: FileSystem.readFileSync(this._cert.keyPath),
       cert: FileSystem.readFileSync(this._cert.certPath),
     };
+
     this.httpsServer = Https.createServer(options, this.secureExpress);
   }
 
@@ -691,19 +787,21 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
    * 
    */
   private async startExpresses(): Promise<void> {
-    if (this.logFn && this.deepLog) console.log('\nfn:. startExpresses');
+    if (this.logFn && this.deepLog) Dynamo_Log.log('\nfn:. startExpresses');
     try {
       if (this._security && this._security !== DynamoNTS_RouteSecurity.open) {
-        await new Promise<void>((resolve, reject) => {
+        await new Promise<void>((resolve, reject): void => {
           this.systemControls.httpsServer.init = true;
           this.httpsServer
-            .listen(this._portSettings.httpsPort, 'localhost', 0, () => {
+            .listen(this._portSettings.httpsPort, 'localhost', 0, (): void => {
               this.systemControls.httpsServer.started = true;
-              Dynamo_Log.success(`\nHTTPS (secure) server is listening on port: ${this._portSettings.httpsPort}`);
+              Dynamo_Log.success(
+                `\nHTTPS (secure) server is listening on port: ${this._portSettings.httpsPort}`
+              );
 
               resolve();
             })
-            .on('error', (error) => {
+            .on('error', (error): void => {
               if (this.debugLog) Dynamo_Log.error(`\nHTTPS (secure) server ERROR`, error);
               
               if (!this.systemControls.httpsServer.started) {
@@ -731,23 +829,28 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
                   errorCode: 'NTS-AS0-SE2',
                   message: `HTTPS (secure) server ERROR`,
+                  level: Dynamo_ErrorLevel.serious,
                 });
 
                 DynamoNTS_GlobalService.globalErrorHandler?.(d_error);
               }
             })
-            .on('uncaughtException', (ex) => {
+            .on('uncaughtException', (exception): void => {
               const d_error: Dynamo_Error = new Dynamo_Error({
                 ...this._getDefaultErrorSettings(
                   'httpsServer.on(uncaughtException)',
-                  ex
+                  exception
                 ),
 
                 errorCode: 'NTS-AS0-SE3',
                 message: `HTTPS (secure) server uncaughtException`,
+                level: Dynamo_ErrorLevel.critical,
               });
 
-              if (this.debugLog) Dynamo_Log.warn(`\nHTTPS (secure) server uncaughtException`, d_error);
+              if (this.debugLog) Dynamo_Log.warn(
+                `\nHTTPS (secure) server uncaughtException`, 
+                d_error
+              );
 
               DynamoNTS_GlobalService.globalErrorHandler?.(d_error);
             });
@@ -756,15 +859,17 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
       if (this._security && this._security !== DynamoNTS_RouteSecurity.secure) {
         this.systemControls.httpServer.init = true;
-        await new Promise<void>((resolve, reject) => {
+        await new Promise<void>((resolve, reject): void => {
           this.httpServer = this.openExpress
-            .listen(this._portSettings.httpPort, () => {
+            .listen(this._portSettings.httpPort, (): void => {
               this.systemControls.httpServer.started = true;
-              Dynamo_Log.success(`\nHTTP (open) server is listening on port: ${this._portSettings.httpPort}`);
+              Dynamo_Log.success(
+                `\nHTTP (open) server is listening on port: ${this._portSettings.httpPort}`
+              );
 
               resolve();
             })
-            .on('error', (error) => {
+            .on('error', (error): void => {
               if (this.debugLog) Dynamo_Log.error(`\nHTTP (open) server ERROR`, error);
 
               if (!this.systemControls.httpServer.started) {
@@ -792,12 +897,13 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
                   errorCode: 'NTS-AS0-SE4',
                   message: `HTTP (open) server ERROR`,
+                  level: Dynamo_ErrorLevel.serious,
                 });
 
                 DynamoNTS_GlobalService.globalErrorHandler?.(d_error);
               }
             })
-            .on('uncaughtException', (ex) => {
+            .on('uncaughtException', (ex): void => {
               const d_error: Dynamo_Error = new Dynamo_Error({
                 ...this._getDefaultErrorSettings(
                   'httpServer.on(uncaughtException)',
@@ -806,6 +912,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
                 errorCode: 'NTS-AS0-SE5',
                 message: `HTTP (open) server uncaughtException`,
+                level: Dynamo_ErrorLevel.critical,
               });
 
               if (this.debugLog) Dynamo_Log.warn(`\nHTTP (open) server uncaughtException`, d_error);
@@ -816,6 +923,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
       }
     } catch (error) {
       Dynamo_Log.error(`startExpresses failed...`, error);
+
       throw error;
     }
   }
@@ -838,6 +946,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
             req,
             res,
           },
+          level: Dynamo_ErrorLevel.error,
         });
 
         await DynamoNTS_GlobalService.globalErrorHandler?.(d_error, req, res);
@@ -862,90 +971,102 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
    * 
    */
   private async mountSecureRoutes (): Promise<void> {
-    if (this.logFn && this.deepLog) console.log('\nfn:. mountSecureRoutes');
+    if (this.logFn && this.deepLog) Dynamo_Log.log('\nfn:. mountSecureRoutes');
     
-    this.openExpress.use(this.expressErrorHandling);
+    this.openExpress.use(
+      (error, req, res, next): Promise<void> => this.expressErrorHandling(error, req, res, next)
+    );
 
-    await Dynamo_Array.asyncForEach(this._routingModules, async (module: DynamoNTS_RoutingModule) => {
-      if (module.security !== DynamoNTS_RouteSecurity.open) {
-        if (this.logSetup) { 
-          console.log(`route mount (secure): ${module.route}`);
-        }
-        
-        const existingRoutes: DynamoNTS_RoutingModule[] = this._routingModules.filter(
-          (mod: DynamoNTS_RoutingModule) => mod.route === module.route
-        );
+    await Dynamo_Array.asyncForEach(
+      this._routingModules, 
+      async (module: DynamoNTS_RoutingModule): Promise<void> => {
+        if (module.security !== DynamoNTS_RouteSecurity.open) {
+          if (this.logSetup) { 
+            Dynamo_Log.log(`route mount (secure): ${module.route}`);
+          }
+          
+          const existingRoutes: DynamoNTS_RoutingModule[] = this._routingModules.filter(
+            (mod: DynamoNTS_RoutingModule): boolean => mod.route === module.route
+          );
 
-        if (1 < existingRoutes.length) {
-          let error: Error = new Error(`ROUTE DUPLICATION: ${module.route}`);
-          let errorStack: string[] = error.stack.split('\n');
-          errorStack.splice(1, 4);
-          error.stack = errorStack.join('\n');
-  
-          Dynamo_Log.error(`ROUTE DUPLICATION: ${module.route}`, error);
-          throw new Dynamo_Error({
-            ...this._getDefaultErrorSettings(
-              'mountSecureRoutes',
-              error
-            ),
-
-            errorCode: 'NTS-AS0-MSR1',
-            message: `ROUTE DUPLICATION: ${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');
+    
+            Dynamo_Log.error(`ROUTE DUPLICATION: ${module.route}`, error);
 
-        this.secureExpress.use(module.route, module.secureRouter);
+            throw new Dynamo_Error({
+              ...this._getDefaultErrorSettings(
+                'mountSecureRoutes',
+                error
+              ),
+
+              errorCode: 'NTS-AS0-MSR1',
+              message: `ROUTE DUPLICATION: ${module.route}`,
+            });
+          }
+
+          this.secureExpress.use(module.route, module.secureRouter);
+        }
       }
-    });
+    );
   }
 
   /**
    * 
    */
   private async mountOpenRoutes(): Promise<void> {
-    if (this.logFn && this.deepLog) console.log('\nfn:. mountOpenRoutes');
+    if (this.logFn && this.deepLog) Dynamo_Log.log('\nfn:. mountOpenRoutes');
 
     this.openExpress.use(this.expressErrorHandling);
 
-    await Dynamo_Array.asyncForEach(this._routingModules, async (module: DynamoNTS_RoutingModule) => {
-      if (module.security !== DynamoNTS_RouteSecurity.secure) {
-        if (this.logSetup) {
-          console.log(`route mount (open): ${module.route}`);
-        }
+    await Dynamo_Array.asyncForEach(
+      this._routingModules, 
+      async (module: DynamoNTS_RoutingModule): Promise<void> => {
+        if (module.security !== DynamoNTS_RouteSecurity.secure) {
+          if (this.logSetup) {
+            Dynamo_Log.log(`route mount (open): ${module.route}`);
+          }
 
-        const existingRoutes: DynamoNTS_RoutingModule[] = this._routingModules.filter(
-          (mod: DynamoNTS_RoutingModule) => mod.route === module.route
-        );
+          const existingRoutes: DynamoNTS_RoutingModule[] = this._routingModules.filter(
+            (mod: DynamoNTS_RoutingModule): boolean => mod.route === module.route
+          );
 
-        if (1 < existingRoutes.length) {
-          let error: Error = new Error(`ROUTE DUPLICATION: ${module.route}`);
-          let errorStack: string[] = error.stack.split('\n');
-          errorStack.splice(1, 4);
-          error.stack = errorStack.join('\n');
-  
-          Dynamo_Log.error(`ROUTE DUPLICATION: ${module.route}`, error);
-          throw new Dynamo_Error({
-            ...this._getDefaultErrorSettings(
-              'mountOpenRoutes',
-              error
-            ),
-
-            errorCode: 'NTS-AS0-MOR1',
-            message: `ROUTE DUPLICATION: ${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');
+    
+            Dynamo_Log.error(`ROUTE DUPLICATION: ${module.route}`, error);
+
+            throw new Dynamo_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);
       }
-    });
+    );
   }
 
   /**
    * 
    */
   private setSecurity(): void {
-    if (this.logFn && this.deepLog) console.log('\nfn:. setSecurity');
-    this._routingModules.forEach((module: DynamoNTS_RoutingModule) => {
+    if (this.logFn && this.deepLog) Dynamo_Log.log('\nfn:. setSecurity');
+    this._routingModules.forEach((module: DynamoNTS_RoutingModule): void => {
       if (!module.security) {
         Dynamo_Log.warn(`RoutingModule security is not set for ${module.route}\n`);
 
@@ -959,10 +1080,12 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
     if (!this._security) {
       let msg = `Could not set security for the server! (${this.security})`;
+
       msg += '\n  RoutingModules:';
-      this._routingModules.forEach((module: DynamoNTS_RoutingModule) => {
+      this._routingModules.forEach((module: DynamoNTS_RoutingModule): void => {
         msg += `\n    ${module.route} (security: ${module.security})`;
       });
+
       if (this._routingModules.length === 0) {
         msg += '\n    - no RoutingModule found -\n';
       }      
@@ -970,7 +1093,9 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
     }
   }
     
-  private _getDefaultErrorSettings(fnName: string, error: Error | Dynamo_Error) {
+  private _getDefaultErrorSettings(
+    fnName: string, error: Error | Dynamo_Error
+  )/* : Dynamo_ErrorSettings */ {
     return {
       status: (error as Dynamo_Error)?.___status ?? 500,
       message: (error as Error)?.message ?? `${fnName} was UNSUCCESFUL (NTS)`,
@@ -978,7 +1103,8 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
       userMessage: this.defaultErrorUserMsg,
       issuerService: `${this?.constructor?.name}-DynamoNTS_App`,
       error: error,
-    }
+      level: Dynamo_ErrorLevel.fatal,
+    };
   }
 
   /**