@futdevpro/nts-dynamo 1.6.18 → 1.6.20

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

@@ -1,11 +1,12 @@
 
 import Mongoose = require("mongoose");
 import Express = require("express");
+import * as Http from 'http';
 import * as Https from 'https';
 import * as FileSystem from 'fs';
 import * as BodyParser from 'body-parser';
 
-import { Dynamo_Log } 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';
@@ -17,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,
@@ -176,7 +181,11 @@ import { DynamoNTS_EndpointParams } from '../../_models/control-models/endpoint-
  */
 export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
-  started: boolean = false;
+  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; }
 
   private _params: DynamoNTS_AppParams;
@@ -196,6 +205,9 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   protected openExpress: Express.Application;
   private secureExpress: Express.Application;
   protected httpsServer: Https.Server;
+  protected httpServer: Http.Server;
+
+  private globalService: DynamoNTS_GlobalService;
 
   private _routingModules: DynamoNTS_RoutingModule[] = [];
   /* protected get routingModules(): DynamoNTS_RoutingModule[] { return this._routingModules; } */
@@ -205,23 +217,34 @@ 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(dontLog?: boolean){
     super();
 
+    this.asyncConstruct(dontLog);
+  }
+
+  private async asyncConstruct(dontLog?: 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();        
       } 
       
+      this.globalService = DynamoNTS_GlobalService.getInstance();
       DynamoNTS_GlobalService.setServices(this.getGlobalServiceCollection());
       DynamoNTS_GlobalService.setParams(this.params);
 
       if (this.getPortSettings) {
-        this._ports = this.getPortSettings();     
+        this._ports = this.getPortSettings();
       }
 
       if (this.getCertificationSettings) {
@@ -233,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}... `);
@@ -242,68 +265,222 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
       }
       console.log(`Version: ${this._params.version}\n`);
 
-      this.startDB();
+      await this.startDB();
 
-      this.getGlobalServiceCollection();
-      this.debugLog = dynamoNTS_globalSettings.logSetup;
+      await this.getGlobalServiceCollection();
 
-      this.setSecurity();
+      await 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.started = true;
+      await this.ready();
+
+      if (!dontLog) {
+        Dynamo_Log.test(`${this._params.name} started successfully.`);
+      }
     } catch (error) {
-      Dynamo_Log.error('\nApplication start failed.\n', error);
+      this.constructErrors.push(error);
+      Dynamo_Log.error(`\nApplication: ${this._params.name} start failed.\n`, error);
+    }
+  }
+
+  async ready(timeout: number = 4 * second): Promise<void> {
+    if (this.logFn) console.log('\nfn:. ready');
+    /* return new Promise<void>(async (resolve, reject) => { */
+    let ready: boolean = false;
+    const start: number = +new Date();
+
+    if (this.constructErrors.length) {
+      if (this.logFn && this.deepLog) console.log('\nfn:. ready: throw ERROR-0', 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.logFn && this.deepLog) console.log('\nfn:. ready: bef while', this.systemControls);
+    while (!ready && +new Date() - start < timeout) {
+      // if (this.logFn && this.deepLog) console.log('\nfn:. ready: while', this.systemControls); 
+      /* if (this.logFn && this.deepLog) console.log('\nfn:. ready: while', this.systemControls, 
+      {
+        mongoose: this.systemControls.mongoose.getReady(),
+        httpServer: this.systemControls.httpServer.getReady(),
+        httpsServer: this.systemControls.httpsServer.getReady(),
+      }); */
+      if (this.systemControls.app.init) {
+        ready = (
+          this.systemControls.mongoose.getReady() &&
+          this.systemControls.httpServer.getReady() &&
+          this.systemControls.httpsServer.getReady()
+        );
+      }
+
+      await wait(100);
+    }
+
+    if (timeout < +new Date() - start) {
+      //if (this.logFn && this.deepLog) console.log('\nfn:. ready: throw TIMEOUT', this.constructErrors, this.systemControls);
+      if (this.logFn && this.deepLog) console.log('\nfn:. ready: throw TIMEOUT', this.constructErrors, this.systemControls, 
+      {
+        mongoose: this.systemControls.mongoose.getReady(),
+        httpServer: this.systemControls.httpServer.getReady(),
+        httpsServer: this.systemControls.httpsServer.getReady(),
+      }); 
+      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) {
+      if (this.logFn && this.deepLog) console.log('\nfn:. ready: throw ERROR');
+      throw new Dynamo_Error({ 
+        message: `${this._params.name} start failed. ERROR`,
+        additionalContent: 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.`;
+      }
+
+      if (this.logFn && this.deepLog) console.log('\nfn:. ready: throw UNKNOWN');
+      throw new Dynamo_Error({ 
+        message: msg,
+        additionalContent: this.constructErrors,
+        error: this.constructErrors?.[0] ?? new Error(),
+      });
+    }
+    /* }); */
+  }
+
+  async stop(dontLog?: boolean): Promise<void> {
+    if (this.logFn) console.log('\nfn:. stop');
+    if (this.started) {
+
+      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.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.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.`);
+      }
     }
   }
 
   /**
    * 
    */
-  private startDB(): void {
-    this.mongoose.connection
-      .on('error', (error) => {
-        Dynamo_Log.error('\nUnable to connect to MongoDB server, ERROR: ', error);
-      })
-      .once('open', () => {
-        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(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 =
@@ -332,7 +509,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
         throw error;
       }
 
-      this.initOpenExpress();
+      await this.initOpenExpress();
     }
 
     if (this._security && this._security !== DynamoNTS_RouteSecurity.open) {
@@ -369,14 +546,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' }));
@@ -385,7 +563,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' }));
@@ -401,31 +580,71 @@ 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.httpsServer
-          .listen(this._ports.httpsPort, 'localhost', 0, () => {
-            Dynamo_Log.success(`\nHTTPS (secure) server is listening on port ${this._ports.httpsPort}`);
-          })
-          .on('error', (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({
+                  message: `HTTPS (secure) server ERROR`,
+                  error: error,
+                })
+              );
+            })
+            .on('uncaughtException', (ex) => {
+              Dynamo_Log.warn(`\nHTTPS (secure) server uncaughtException`, ex);
+              reject(
+                new Dynamo_Error({
+                  message: `HTTPS (secure) server uncaughtException`,
+                  error: ex,
+                })
+              );
+            });
+        });
       }
 
       if (this._security && this._security !== DynamoNTS_RouteSecurity.secure) {
-        this.openExpress
-          .listen(this._ports.httpPort, () => {
-            Dynamo_Log.success(`\nHTTP (-open-) server is listening on port ${this._ports.httpPort}`);
-          })
-          .on('error', (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({
+                  message: `HTTP (open) server ERROR`,
+                  error: error,
+                })
+              );
+            })
+            .on('uncaughtException', (ex) => {
+              Dynamo_Log.warn(`\nHTTP (open) server uncaughtException`, ex);
+              reject(
+                new Dynamo_Error({ 
+                  message: `HTTP (open) server uncaughtException`, 
+                  error: ex 
+                })
+              );
+            });
+        });
       }
     } catch (error) {
       Dynamo_Log.error(`startExpresses failed...`, error);
@@ -435,10 +654,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}`);
         }
         
@@ -452,8 +672,12 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           errorStack.splice(1, 4);
           error.stack = errorStack.join('\n');
   
-          throw error;
+          throw new Dynamo_Error({
+            message: `ROUTE DUPLICATION: ${module.route}`,
+            error: error,
+          });
         }
+
         this.secureExpress.use(module.route, module.secureRouter);
       }
     });
@@ -462,10 +686,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}`);
         }
 
@@ -479,8 +704,12 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           errorStack.splice(1, 4);
           error.stack = errorStack.join('\n');
   
-          throw error;
+          throw new Dynamo_Error({
+            message: `ROUTE DUPLICATION: ${module.route}`,
+            error: error,
+          });
         }
+        
         this.openExpress.use(module.route, module.openRouter);
       }
     });
@@ -489,7 +718,8 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   /**
    * 
    */
-  private setSecurity(): void {
+  private async setSecurity(): Promise<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`);
@@ -507,7 +737,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);
     }
@@ -605,7 +835,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   /**
    * MISSING Description (TODO)
    */
-  getRootServices?(): DynamoNTS_SingletonService[];
+  getRootServices?(): Promise<DynamoNTS_SingletonService[]>;
   
   /**
    * MISSING Description (TODO)
@@ -615,10 +845,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();
   });
 });