@futdevpro/nts-dynamo 1.6.19 → 1.6.21

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

@@ -6,7 +6,7 @@ import * as Https from 'https';
 import * as FileSystem from 'fs';
 import * as BodyParser from 'body-parser';
 
-import { delay, Dynamo_Array, Dynamo_Error, Dynamo_Log, second } from '@futdevpro/fsm-dynamo';
+import { delay, Dynamo_Array, Dynamo_Error, Dynamo_Log, second, wait } from '@futdevpro/fsm-dynamo';
 
 import { DynamoNTS_SingletonService } from '../base/singleton.service';
 import { DynamoNTS_RouteSecurity } from '../../_enums/route-security.enum';
@@ -18,6 +18,10 @@ import { DynamoNTS_GlobalServiceSettings } from '../../_models/interfaces/global
 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_SystemControl } from '../../_models/control-models/system-control.control-model';
+import { DynamoNTS_AppSystemControls } from '../../_models/control-models/app-system-controls.control-model';
+
+
 
 /**
  * This will be the MAIN service of our server project,
@@ -177,15 +181,10 @@ import { DynamoNTS_EndpointParams } from '../../_models/control-models/endpoint-
  */
 export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
-  started: boolean = false;
-  private initDone: boolean = false;
-  private haveMongoose: boolean = false;
-  private mongooseStarted: boolean = false;
-  private haveHttpServer: boolean = false;
-  private httpServerStarted: boolean = false;
-  private haveHttpsServer: boolean = false;
-  private httpsServerStarted: boolean = false;
-  private constructErrors: (Error | Dynamo_Error)[] = [];
+  protected systemControls: DynamoNTS_AppSystemControls = new DynamoNTS_AppSystemControls();
+  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; }
 
@@ -218,14 +217,24 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   /**
    * setting this value to true, enables this service debug logs
    */
-  protected debugLog: boolean;
+  protected logSetup: boolean;
+  protected deepLog: boolean;
+  protected logFn: boolean;
 
-  constructor(){
+  constructor(extended?: boolean){
     super();
 
+    this.asyncConstruct(extended);
+  }
+
+  private async asyncConstruct(extended?: boolean): Promise<void> {
+    if (this.logFn && this.deepLog) console.log('\nfn:. asyncConstruct');
     try {
+      this.systemControls.app.init = true;
+      this.logSetup = dynamoNTS_globalSettings.logSetup;
       this._params = this.getAppParams();
       
+      
       if (this.overrideDynamoNTSGlobalSettings) {
         this.overrideDynamoNTSGlobalSettings();        
       } 
@@ -235,7 +244,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
       DynamoNTS_GlobalService.setParams(this.params);
 
       if (this.getPortSettings) {
-        this._ports = this.getPortSettings();     
+        this._ports = this.getPortSettings();
       }
 
       if (this.getCertificationSettings) {
@@ -247,7 +256,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
       }
 
       if (this.createEntries) {
-        this.createEntries();
+        await this.createEntries();
       }
 
       console.log(`\n\n\nStarting ${this._params.name}... `);
@@ -256,166 +265,223 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
       }
       console.log(`Version: ${this._params.version}\n`);
 
-      this.startDB();
-
-      this.getGlobalServiceCollection();
-      this.debugLog = dynamoNTS_globalSettings.logSetup;
+      await this.startDB();
 
       this.setSecurity();
           
       if (this._routingModules?.length) {
-        this.initExpresses();
-        this.startExpresses();
+        await this.initExpresses();
+        await this.startExpresses();
 
         if (this._security !== DynamoNTS_RouteSecurity.secure) {
-          this.mountOpenRoutes();
+          await this.mountOpenRoutes();
         }
         if (this._security !== DynamoNTS_RouteSecurity.open && this._cert) {
-          this.mountSecureRoutes();
+          await this.mountSecureRoutes();
         }
 
-        if (this.debugLog) {
+        if (this.logSetup) {
           console.log(`\nRoutes mounted.... server using security: ${this._security}`);
         }
       }
 
       if (this.getRootServices) {
-        this._rootServices = this.getRootServices();
+        this._rootServices = await this.getRootServices();
       }
       
       if (this.postProcess) { 
-        this.postProcess();
+        await this.postProcess();
       }
 
-      this.initDone = true;
-      this.ready();
+
+      if (!extended) {
+        await this.ready();
+
+        Dynamo_Log.test(`${this._params.name} started successfully.`);
+      }
     } catch (error) {
       this.constructErrors.push(error);
-      Dynamo_Log.error('\nApplication start failed.\n', error);
+      Dynamo_Log.error(`\nApplication: ${this._params.name} start failed.\n`, error);
     }
   }
 
   async ready(timeout: number = 4 * second): Promise<void> {
-    return new Promise(async (resolve, reject) => {
-      let ready: boolean = false;
-      const start: number = +new Date();
-
-      if (this.constructErrors.length) {
-        reject({ 
-          message: 'Application start failed. TIMEOUT',
-          errors: this.constructErrors
-        });
-      }
-
-      while (!ready && +new Date() - start < timeout) {
-        await delay(100);
+    if (this.logFn) console.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({ 
+        message: `${this._params.name} start failed. ERRORS`,
+        additionalContent: this.constructErrors.length === 1 ? this.constructErrors[0] : { errors: this.constructErrors },
+      });
+    }
 
-        if (this.initDone) {
-          ready = (
-            this.haveMongoose ? this.mongooseStarted : true &&
-            this.haveHttpServer ? this.httpServerStarted : true &&
-            this.haveHttpsServer ? this.httpsServerStarted : true
-          );
-        }
+    while (!ready && +new Date() - start < timeout) {
+      if (this.systemControls.app.init) {
+        ready = (
+          this.systemControls.mongoose.getReady() &&
+          this.systemControls.httpServer.getReady() &&
+          this.systemControls.httpsServer.getReady()
+        );
       }
 
-      if (this.constructErrors.length) {
-        reject({ 
-          message: 'Application start failed. TIMEOUT',
-          errors: this.constructErrors
-        });
-      }
+      await wait(100);
+    }
 
-      if (ready) {
-        this.started = true;
-        
-        resolve();
-      } else {
-        this.started = false;
-        
-        let msg: string = 'Application start failed. TIMEOUT';
-        if (this.haveMongoose && !this.mongooseStarted) {
-          msg += '\nMongoose start failed.';
-        }
-        if (this.haveHttpServer && !this.httpServerStarted) {
-          msg += '\nHTTP Server start failed.';
-        }
-        if (this.haveHttpsServer && !this.httpsServerStarted) {
-          msg += '\nHTTPS Server start failed.';
-        }
+    if (timeout < +new Date() - start) {
+      Dynamo_Log.error(`${this._params.name} start failed. TIMEOUT`, this.constructErrors);
+      throw new Dynamo_Error({ 
+        message: `${this._params.name} start failed. TIMEOUT`,
+        additionalContent: {
+          constructErrors: this.constructErrors,
+          systemControls: this.systemControls,
+          systemReadies: {
+            mongoose: this.systemControls.mongoose.getReady(),
+            httpServer: this.systemControls.httpServer.getReady(),
+            httpsServer: this.systemControls.httpsServer.getReady(),
+          },
+        },
+      });
+    }
 
-        
+    if (this.constructErrors.length) {
+      Dynamo_Log.error(`${this._params.name} start failed. ERROR`, this.constructErrors);
+      throw new Dynamo_Error({ 
+        message: `${this._params.name} start failed. ERROR`,
+        additionalContent: this.constructErrors,
+      });
+    }
 
-        reject({ 
-          message: 'Application start failed. TIMEOUT',
-          errors: this.constructErrors
-        });
+    if (ready) {
+      this.systemControls.app.started = true;
+      
+      if (this.logFn && this.deepLog) console.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({ 
+        errorCode: 'NTS-AS0-110',
+        message: msg,
+        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(),
+      });
+    }
   }
 
-  async stop(): Promise<void> {
+  async stop(dontLog?: boolean): Promise<void> {
+    if (this.logFn) console.log('\nfn:. stop');
     if (this.started) {
 
-      if (this.haveHttpServer) {
-        await new Promise((resolve) => {
-          this.httpServer.close(resolve);
-        });
+      if (this.systemControls.mongoose.init) {
+        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 this.mongoose.disconnect();
+        } else {
+          Dynamo_Log.error(`\nMongoose not found.`);
+        }
+        this.systemControls.mongoose.init = false;
       }
-      if (this.haveHttpsServer) {
-        await new Promise((resolve) => {
-          this.httpsServer.close(resolve);
-        });
+
+      if (this.systemControls.httpServer.init) {
+        this.systemControls.httpServer.started = false;
+        if (this.httpServer) {
+          await new Promise((resolve) => {
+            this.httpServer.close(resolve);
+          });
+        } else {
+          Dynamo_Log.error(`\nHTTP Server not found.`);
+        }
+        this.systemControls.httpServer.init = false;
       }
-      if (this.haveMongoose) {
-        await Dynamo_Array.asyncForEach(Object.keys(this.mongoose.models), async (modelName) => {
-          await this.mongoose.deleteModel(modelName);
-        });
-        await this.mongoose.disconnect();
+
+      if (this.systemControls.httpsServer.init) {
+        this.systemControls.httpsServer.started = false;
+        if (this.httpsServer) {
+          await new Promise((resolve) => {
+            this.httpsServer.close(resolve);
+          });
+        } else {
+          Dynamo_Log.error(`\nHTTPS Server not found.`);
+        }
+        this.systemControls.httpsServer.init = false;
+      }
+
+      if (!dontLog) {
+        Dynamo_Log.test(`${this._params.name} stopped successfully.`);
       }
-      
-      this.initDone = false;
-      this.haveHttpServer = false;
-      this.haveHttpsServer = false;
-      this.haveMongoose = false;
-      this.mongooseStarted = false;
-      this.httpServerStarted = false;
-      this.httpsServerStarted = false;
-      this.started = false;
-
-      Dynamo_Log.success('\nServer stopped.\n');
     }
   }
 
   /**
    * 
    */
-  private startDB(): void {
-    this.haveMongoose = true;
-    this.mongoose.connection
-      .on('error', (error) => {
-        this.mongooseStarted = false;
-        this.constructErrors.push(error);
-        Dynamo_Log.error('\nUnable to connect to MongoDB server, ERROR: ', error);
-      })
-      .once('open', () => {
-        this.mongooseStarted = true;
-        Dynamo_Log.success('\nConnected to MongoDB\n');
-      });
+  private async startDB(): Promise<void> {
+    if (this.logFn && this.deepLog) console.log('\nfn:. startDB');
+    await new Promise<void>(
+      async (resolve, reject) => {
+        this.systemControls.mongoose.init = true;
+        this.mongoose.connection
+          .on('error', (error) => {
+            this.systemControls.mongoose.started = false;
+            this.constructErrors.push(error);
+            Dynamo_Log.error('\nUnable to connect to MongoDB server, ERROR: ', error);
+            reject(
+              new Dynamo_Error({
+                errorCode: 'NTS-AS0-100',
+                message: `Unable to connect to MongoDB server, ERROR: ${error}`,
+                error: error, 
+              })
+            );
+          })
+          .once('open', () => {
+            this.systemControls.mongoose.started = true;
+            Dynamo_Log.success('\nConnected to MongoDB\n');
+            resolve();
+          });
 
-    this.mongoose.connect(
-        this._params.dbUri, 
-        {
-          useNewUrlParser: true,
-          useUnifiedTopology: true 
-        }
+        this.mongoose.connect(
+            this._params.dbUri, 
+            {
+              useNewUrlParser: true,
+              useUnifiedTopology: true 
+            }
+        );
+      }
     );
   }
 
   /**
    * 
    */
-  private initExpresses() {
+  private async initExpresses(): Promise<void> {
+    if (this.logFn && this.deepLog) console.log('\nfn:. initExpresses');
     if (this._security && this._security !== DynamoNTS_RouteSecurity.secure) {
       if (!this._ports.httpPort) {
         let errorMsg: string =
@@ -444,7 +510,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
         throw error;
       }
 
-      this.initOpenExpress();
+      await this.initOpenExpress();
     }
 
     if (this._security && this._security !== DynamoNTS_RouteSecurity.open) {
@@ -481,14 +547,15 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
         throw error;
       }
 
-      this.initSecureExpress();
+      await this.initSecureExpress();
     }
   }
 
   /**
    * 
    */
-  protected initOpenExpress(): void {
+  protected async initOpenExpress(): Promise<void> {
+    if (this.logFn) console.log('\nfn:. initOpenExpress');
     this.openExpress = Express();    
     this.openExpress.use(BodyParser.urlencoded({ limit: '50mb', extended: true }));
     this.openExpress.use(BodyParser.json({ limit: '50mb' }));
@@ -497,7 +564,8 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   /**
    * 
    */
-   protected initSecureExpress(): void {
+   protected async initSecureExpress(): Promise<void> {
+    if (this.logFn) console.log('\nfn:. initSecureExpress');
     this.secureExpress = Express();    
     this.secureExpress.use(BodyParser.urlencoded({ limit: '50mb', extended: true }));
     this.secureExpress.use(BodyParser.json({ limit: '50mb' }));
@@ -513,39 +581,75 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
    * 
    */
   private async startExpresses(): Promise<void> {
+    if (this.logFn && this.deepLog) console.log('\nfn:. startExpresses');
     try {
       if (this._security && this._security !== DynamoNTS_RouteSecurity.open) {
-        this.haveHttpsServer = true;
-        this.httpsServer
-          .listen(this._ports.httpsPort, 'localhost', 0, () => {
-            this.httpsServerStarted = true;
-            Dynamo_Log.success(`\nHTTPS (secure) server is listening on port ${this._ports.httpsPort}`);
-          })
-          .on('error', (error) => {
-            this.httpsServerStarted = false;
-            this.constructErrors.push(error);
-            Dynamo_Log.error(`\nHTTPS (secure) server ERROR`, error);
-          })
-          .on('uncaughtException', (ex) => {
-            Dynamo_Log.warn(`\nHTTPS (secure) server uncaughtException`, ex);
-          });
+        await new Promise<void>((resolve, reject) => {
+          this.systemControls.httpsServer.init = true;
+          this.httpsServer
+            .listen(this._ports.httpsPort, 'localhost', 0, () => {
+              this.systemControls.httpsServer.started = true;
+              Dynamo_Log.success(`\nHTTPS (secure) server is listening on port ${this._ports.httpsPort}`);
+              resolve();
+            })
+            .on('error', (error) => {
+              this.systemControls.httpsServer.started = false;
+              this.constructErrors.push(error);
+              Dynamo_Log.error(`\nHTTPS (secure) server ERROR`, error);
+              reject(
+                new Dynamo_Error({
+                  errorCode: 'NTS-AS0-001',
+                  message: `HTTPS (secure) server ERROR`,
+                  error: error,
+                })
+              );
+            })
+            .on('uncaughtException', (ex) => {
+              Dynamo_Log.warn(
+                `\nHTTPS (secure) server uncaughtException`,
+                new Dynamo_Error({
+                  errorCode: 'NTS-AS0-002',
+                  message: `HTTPS (secure) server uncaughtException`,
+                  error: ex,
+                })
+              );
+            });
+        });
       }
 
       if (this._security && this._security !== DynamoNTS_RouteSecurity.secure) {
-        this.haveHttpServer = true;
-        this.httpServer = this.openExpress
-          .listen(this._ports.httpPort, () => {
-            this.httpServerStarted = true;
-            Dynamo_Log.success(`\nHTTP (-open-) server is listening on port ${this._ports.httpPort}`);
-          })
-          .on('error', (error) => {
-            this.httpServerStarted = false;
-            this.constructErrors.push(error);
-            Dynamo_Log.error(`\nHTTP (-open-) server ERROR`, error);
-          })
-          .on('uncaughtException', (ex) => {
-            Dynamo_Log.warn(`\nHTTP (-open-) server uncaughtException`, ex);
-          });
+        this.systemControls.httpServer.init = true;
+        await new Promise<void>((resolve, reject) => {
+          this.httpServer = this.openExpress
+            .listen(this._ports.httpPort, () => {
+              this.systemControls.httpServer.started = true;
+              Dynamo_Log.success(`\nHTTP (open) server is listening on port ${this._ports.httpPort}`);
+              resolve();
+            })
+            .on('error', (error) => {
+              this.systemControls.httpServer.started = false;
+              this.constructErrors.push(error);
+
+              Dynamo_Log.error(`\nHTTP (open) server ERROR`, error);
+              reject(
+                new Dynamo_Error({
+                  errorCode: 'NTS-AS0-003',
+                  message: `HTTP (open) server ERROR`,
+                  error: error,
+                })
+              );
+            })
+            .on('uncaughtException', (ex) => {
+              Dynamo_Log.warn(
+                `\nHTTP (open) server uncaughtException`,
+                new Dynamo_Error({ 
+                  errorCode: 'NTS-AS0-004',
+                  message: `HTTP (open) server uncaughtException`, 
+                  error: ex 
+                })
+              );
+            });
+        });
       }
     } catch (error) {
       Dynamo_Log.error(`startExpresses failed...`, error);
@@ -555,10 +659,11 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   /**
    * 
    */
-  private mountSecureRoutes (): void {
-    this._routingModules.forEach((module: DynamoNTS_RoutingModule) => {
+  private async mountSecureRoutes (): Promise<void> {
+    if (this.logFn && this.deepLog) console.log('\nfn:. mountSecureRoutes');
+    await Dynamo_Array.asyncForEach(this._routingModules, async (module: DynamoNTS_RoutingModule) => {
       if (module.security !== DynamoNTS_RouteSecurity.open) {
-        if (this.debugLog) { 
+        if (this.logSetup) { 
           console.log(`route mount (secure): ${module.route}`);
         }
         
@@ -572,8 +677,14 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           errorStack.splice(1, 4);
           error.stack = errorStack.join('\n');
   
-          throw error;
+          Dynamo_Log.error(`ROUTE DUPLICATION: ${module.route}`, error);
+          throw new Dynamo_Error({
+            errorCode: 'NTS-AS0-005',
+            message: `ROUTE DUPLICATION: ${module.route}`,
+            error: error,
+          });
         }
+
         this.secureExpress.use(module.route, module.secureRouter);
       }
     });
@@ -582,10 +693,11 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   /**
    * 
    */
-  private mountOpenRoutes (): void {
-    this._routingModules.forEach((module: DynamoNTS_RoutingModule) => {
+  private async mountOpenRoutes(): Promise<void> {
+    if (this.logFn && this.deepLog) console.log('\nfn:. mountOpenRoutes');
+    await Dynamo_Array.asyncForEach(this._routingModules, async (module: DynamoNTS_RoutingModule) => {
       if (module.security !== DynamoNTS_RouteSecurity.secure) {
-        if (this.debugLog) {
+        if (this.logSetup) {
           console.log(`route mount (open): ${module.route}`);
         }
 
@@ -599,8 +711,14 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           errorStack.splice(1, 4);
           error.stack = errorStack.join('\n');
   
-          throw error;
+          Dynamo_Log.error(`ROUTE DUPLICATION: ${module.route}`, error);
+          throw new Dynamo_Error({
+            errorCode: 'NTS-AS0-006',
+            message: `ROUTE DUPLICATION: ${module.route}`,
+            error: error,
+          });
         }
+        
         this.openExpress.use(module.route, module.openRouter);
       }
     });
@@ -610,6 +728,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
    * 
    */
   private setSecurity(): void {
+    if (this.logFn && this.deepLog) console.log('\nfn:. setSecurity');
     this._routingModules.forEach((module: DynamoNTS_RoutingModule) => {
       if (!module.security) {
         Dynamo_Log.error(`RoutingModule security is not set for ${module.route}\n`);
@@ -627,7 +746,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
         msg += `\n    ${module.route} (security: ${module.security})`;
       });
       if (this._routingModules.length === 0) {
-        msg += '\n    No RoutingModules found!';
+        msg += '\n    - no RoutingModule found -\n';
       }      
       Dynamo_Log.warn(msg);
     }
@@ -725,7 +844,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   /**
    * MISSING Description (TODO)
    */
-  getRootServices?(): DynamoNTS_SingletonService[];
+  getRootServices?(): Promise<DynamoNTS_SingletonService[]>;
   
   /**
    * MISSING Description (TODO)
@@ -735,10 +854,10 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   /**
    * MISSING Description (TODO)
    */
-  createEntries?(): void;
+  createEntries?(): Promise<void>;
 
   /**
    * MISSING Description (TODO)
    */
-  postProcess?(): void;
+  postProcess?(): Promise<void>;
 }

package/src/_services/shared.service.spec.ts

@@ -1,10 +1,19 @@
 import { DynamoNTS_Shared } from './shared.static-service';
 
 describe('DynamoNTS_Shared', () => {
-  it('fns should be accessible', () => {
+  it('getIpFromRequest should be accessible', () => {
     expect(DynamoNTS_Shared.getIpFromRequest).toBeTruthy();
+  });
+
+  it('getIpFromRequest should be accessible', () => {
     expect(DynamoNTS_Shared.getLocationDataByRequest).toBeTruthy();
+  });
+
+  it('getIpFromRequest should be accessible', () => {
     expect(DynamoNTS_Shared.getLocationByIp).toBeTruthy();
+  });
+
+  it('getIpFromRequest should be accessible', () => {
     expect(DynamoNTS_Shared.prompt).toBeTruthy();
   });
 });