@futdevpro/nts-dynamo 1.6.22 → 1.6.24

package/src/_constants/mocks/app-extended-server.mock.ts

@@ -104,7 +104,7 @@ export class DynamoNTS_AppExtendedFull_Mock extends DynamoNTS_AppExtended {
       }),
 
       getTestRoutingModule(),
-      getUsageRoutingModule()
+      getUsageRoutingModule(),
     ];
   }
 
@@ -173,7 +173,7 @@ export class DynamoNTS_AppWbMock_Mock extends DynamoNTS_AppExtended {
       }),
 
       getTestRoutingModule(),
-      getUsageRoutingModule()
+      getUsageRoutingModule(),
     ];
   }
 
@@ -188,4 +188,5 @@ export class DynamoNTS_AppWbMock_Mock extends DynamoNTS_AppExtended {
       SocketClient_Mock.getInstance(),
     ];
   }
-}
+}
+

package/src/_constants/mocks/app-server.mock.ts

@@ -95,7 +95,7 @@ export class DynamoNTS_AppFull_Mock extends DynamoNTS_App {
       }),
 
       getTestRoutingModule(),
-      getUsageRoutingModule()
+      getUsageRoutingModule(),
     ];
   }
 

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

@@ -136,7 +136,9 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
   constructor(){
     super(true);
 
-    this.asyncConstructExt();
+    this.asyncConstructExt().catch((error: any) => {
+      Dynamo_Log.error(`\nExtended Application: ${this.params?.name} start failed.\n`, error, '\n');
+    });
   }
 
   private async asyncConstructExt(): Promise<void> {
@@ -163,6 +165,24 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
       Dynamo_Log.test(`${this.params.name} started successfully.`);
     } catch (error) {
       Dynamo_Log.error(`\nExtended Application: ${this.params?.name} start failed.\n`, error, '\n');
+      throw new Dynamo_Error({
+        errorCode: 'NTS-AES-001',
+        error: error,
+        additionalContent: {
+          constructErrors: this.constructErrors,
+          systemControls: this.systemControls,
+          systemControlsExt: this.systemControlsExt,
+          systemReadies: {
+            app: this.systemControls.app.getReady(),
+            appExtended: this.systemControlsExt.appExtended.getReady(),
+            mongoose: this.systemControls.mongoose.getReady(),
+            httpServer: this.systemControls.httpServer.getReady(),
+            httpsServer: this.systemControls.httpsServer.getReady(),
+            httpSocketServer: this.systemControlsExt.httpSocketServer.getReady(),
+            httpsSocketServer: this.systemControlsExt.httpsSocketServer.getReady(),
+          },
+        },
+      });
     }
   }
 
@@ -189,9 +209,13 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
           this.systemControlsExt.httpSocketServer.getReady() &&
           this.systemControlsExt.httpsSocketServer.getReady()
         );
+      } else {
+        Dynamo_Log.error(`${this.params.name} APP NOT INITIALIZED while trying to get ready.`);
       }
 
-      await wait(100);
+      if (!ready) {
+        await wait(100);
+      }
     }
 
     if (this.constructErrors.length) {
@@ -325,13 +349,13 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
                 errorMsg += `\n  ${service?.name} (port: ${service.port})`;
               }
             });
-            Dynamo_Log.error(errorMsg);
     
             let error = new Error('Secure routes cannot be established!');
             let errorStack: string[] = error.stack.split('\n');
             errorStack.splice(1, 2);
             error.stack = errorStack.join('\n');
     
+            Dynamo_Log.error(errorMsg);
             throw error;
           }
         }
@@ -352,6 +376,7 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
               errorStack.splice(1, 4);
               error.stack = errorStack.join('\n');
 
+              Dynamo_Log.error(`\n${error.message}`);
               throw error;
             }
 
@@ -397,6 +422,7 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
               errorStack.splice(1, 4);
               error.stack = errorStack.join('\n');
 
+              Dynamo_Log.error(`\n${error.message}`);
               throw error;
             }
           } catch (error) {

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

@@ -208,11 +208,9 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   protected httpServer: Http.Server;
 
   private globalService: DynamoNTS_GlobalService;
+  private _rootServices: DynamoNTS_SingletonService[] = [];
 
   private _routingModules: DynamoNTS_RoutingModule[] = [];
-  /* protected get routingModules(): DynamoNTS_RoutingModule[] { return this._routingModules; } */
-
-  private _rootServices: DynamoNTS_SingletonService[] = [];
 
   /**
    * setting this value to true, enables this service debug logs
@@ -224,7 +222,9 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   constructor(extended?: boolean){
     super();
 
-    this.asyncConstruct(extended);
+    this.asyncConstruct(extended).catch((error: any) => {
+      Dynamo_Log.error(`\nApplication: ${this._params.name} start failed.\n`, error);
+    });
   }
 
   private async asyncConstruct(extended?: boolean): Promise<void> {
@@ -301,7 +301,21 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
       }
     } catch (error) {
       this.constructErrors.push(error);
-      Dynamo_Log.error(`\nApplication: ${this._params.name} start failed.\n`, error);
+      Dynamo_Log.error(`${this._params.name} start failed. ERRORS`, this.constructErrors);
+      throw new Dynamo_Error({
+        errorCode: 'NTS-AS0-001',
+        error: error,
+        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(),
+          },
+        },
+      });
     }
   }
 
@@ -325,14 +339,18 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           this.systemControls.httpServer.getReady() &&
           this.systemControls.httpsServer.getReady()
         );
+      } else {
+        Dynamo_Log.error(`${this.params.name} APP NOT INITIALIZED while trying to get ready.`);
       }
 
-      await wait(100);
+      if (!ready) {
+        await wait(100);
+      }
     }
 
     if (timeout < +new Date() - start) {
       Dynamo_Log.error(`${this._params.name} start failed. TIMEOUT`, this.constructErrors);
-      throw new Dynamo_Error({ 
+      throw new Dynamo_Error({
         message: `${this._params.name} start failed. TIMEOUT`,
         additionalContent: {
           constructErrors: this.constructErrors,
@@ -348,7 +366,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
     if (this.constructErrors.length) {
       Dynamo_Log.error(`${this._params.name} start failed. ERROR`, this.constructErrors);
-      throw new Dynamo_Error({ 
+      throw new Dynamo_Error({
         message: `${this._params.name} start failed. ERROR`,
         additionalContent: this.constructErrors,
       });
@@ -500,13 +518,13 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
             });
           }
         });
-        Dynamo_Log.error(errorMsg);
 
         let error = new Error('Open routes cannot be established!');
         let errorStack: string[] = error.stack.split('\n');
         errorStack.splice(1, 2);
         error.stack = errorStack.join('\n');
 
+        Dynamo_Log.error(errorMsg);
         throw error;
       }
 
@@ -537,13 +555,13 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
             });
           }
         });
-        Dynamo_Log.error(errorMsg);
 
         let error = new Error('Secure routes cannot be established!');
         let errorStack: string[] = error.stack.split('\n');
         errorStack.splice(1, 2);
         error.stack = errorStack.join('\n');
 
+        Dynamo_Log.error(errorMsg);
         throw error;
       }
 
@@ -653,6 +671,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
       }
     } catch (error) {
       Dynamo_Log.error(`startExpresses failed...`, error);
+      throw error;
     }
   }
 

package/src/_services/socket/socket-client.service.ts

@@ -4,8 +4,8 @@
 import * as SocketIO from 'socket.io-client';
 
 import { DynamoNTS_SingletonService } from '../base/singleton.service';
-import { Dynamo_Log } from '@futdevpro/fsm-dynamo';
-import { delay } from '@futdevpro/fsm-dynamo/utils';
+import { Dynamo_Error, Dynamo_Log } from '@futdevpro/fsm-dynamo';
+import { delay, Dynamo_Array } from '@futdevpro/fsm-dynamo/utils';
 import { DynamoNTS_SocketClientServiceParams } from '../../_models/control-models/socket-client-service-params.control-model';
 import { dynamoNTS_globalSettings } from '../../_constants/global-settings.const';
 import { DynamoNTS_SocketEvent } from '../../_models/control-models/socket-event.control-model';
@@ -17,8 +17,6 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
   protected get params(): DynamoNTS_SocketClientServiceParams { return this._params; }
   get name(): string { return this.params.name; }
 
-  protected log: boolean = dynamoNTS_globalSettings.logSetup;
-
   protected socket: SocketIO.Socket
   
   protected incomingEvents: DynamoNTS_SocketEvent<any>[];
@@ -26,6 +24,9 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
   protected _connected: boolean = false;
   get connected(): boolean { return this._connected; }
 
+  protected log: boolean = dynamoNTS_globalSettings.logSetup;
+  protected logFn: boolean;
+
   private defaultEvents: DynamoNTS_SocketEvent<any>[] = [
     new DynamoNTS_SocketEvent<any>({
       eventType: DynamoNTS_SocketEventType.connect,
@@ -60,29 +61,39 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
     }),
   ];
 
-
   protected constructor() {
     super();
 
+    this.asyncConstructor().catch((error: any) => {
+      Dynamo_Log.error(`${this.params?.name} Socket Client Service setup failed!`, error);
+    });
+  }
+
+  private async asyncConstructor(): Promise<void> {
     try {
       this._params = this.getParams();
       this.incomingEvents = this.getIncomingEvents() ?? [];
       this.socket = SocketIO.io(`${this.params.address}:${this.params.port}`/* , this._params.socketOptions */);
       
-      this.setupDefaultEvents();
+      await this.setupDefaultEvents();
 
-      this.setupSocketEvents();
+      await this.setupSocketEvents();
 
       console.log(`\n${this.params?.name} Socket Client Service setup finished`);
       
-      this.connectSocket();
+      await this.connectSocket();
     } catch (error) {
       Dynamo_Log.error(`${this.params?.name} Socket Client Service setup failed!`, error);
+      throw new Dynamo_Error({
+        errorCode: 'NTS-SCS-001',
+        error: error,        
+      });
     }
   }
 
-  private setupDefaultEvents(): void {
+  private async setupDefaultEvents(): Promise<void> {
     try {
+      if (this.logFn) console.log('\nFn:. setupDefaultEvents')
       this.defaultEvents.forEach((defaultEvent: DynamoNTS_SocketEvent<any>) => {
         const eventDeclared = this.incomingEvents.find((event: DynamoNTS_SocketEvent<any>) => event.eventType === defaultEvent.eventType);
         if (!eventDeclared) {
@@ -93,14 +104,15 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
       });
     } catch (error) {
       Dynamo_Log.error(`Socket Client Service Setup Default Events failed: ${this.params?.name} (${this.params?.port})`, error);
+      throw error;
     }
   }
 
-  private setupSocketEvents(): void {
+  private async setupSocketEvents(): Promise<void> {
     try {
       if (this.log) console.log(`Setup Socket Events... (${this.params.name})`);
 
-      this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
+      await Dynamo_Array.asyncForEach(this.incomingEvents, async (event: DynamoNTS_SocketEvent<any>) => {
         if (!event.socketName) {
           event.socketName = this.name;
         }
@@ -109,38 +121,42 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
             await event.executeEventTasks(content, this.params.service);
           } catch (error) {
             Dynamo_Log.error(`Socket Event failed: ${this.params.name} (${this.params.port})`, error);
-            this.emitEvent(DynamoNTS_SocketEventType.error, error);
+            await this.emitEvent(DynamoNTS_SocketEventType.error, error);
           }
         });
       });
     } catch (error) {
       Dynamo_Log.error(`Socket Client Service Setup Socket Events failed: ${this.params?.name} (${this.params?.port})`, error);
+      throw error;
     }
   }
   
-  private connectSocket(): void {
+  private async connectSocket(): Promise<void> {
     try {
       console.log(`${this.params.name} Socket Client connecting to ${this.params.address}:${this.params.port} ...`);
 
       this.socket.connect();
 
       if (this.params.reconnect) {
-        this.tryReconnectIfNeeded();
+        await this.tryReconnectIfNeeded();
       }
     } catch (error) {
       Dynamo_Log.error(`Socket Client Service Connect Socket failed: ${this.params?.name} (${this.params?.port})`, error);
+      throw error;
     }
   }
 
   private async tryReconnectIfNeeded(): Promise<void> {
     try {
+      if (this.logFn) console.log(`\nFn:. tryReconnectIfNeeded`);
       await delay(this._params.reconnectDelay);
       
       if (!this._connected) {
-        this.connectSocket();
+        await this.connectSocket();
       }
     } catch (error) {
       Dynamo_Log.error(`Socket Client Service Try Reconnect failed: ${this.params?.name} (${this.params?.port})`, error);
+      throw error;
     }
   }
 
@@ -149,7 +165,7 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
    * @param eventType event name
    * @param content event content
    */
-  protected emitEvent(eventType: string, content: any): void {
+  protected async emitEvent(eventType: string, content: any): Promise<void> {
     try {
       console.log(`\n<== outgoing ${this.name} socket event: ${eventType}`);
       this.socket.emit(eventType, content);

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

@@ -60,23 +60,33 @@ export abstract class DynamoNTS_SocketServerService<
   constructor(){
     super();
 
+    this.asyncConstructor().catch((error: any) => {
+      Dynamo_Log.error(`Socket Server Service setup failed: ${this.params?.name} (${this.params?.port})`, error);
+    });
+  }
+
+  private async asyncConstructor(): Promise<void> {
     try {
       this.logSetup = dynamoNTS_globalSettings.logSetup;
       this.params = this.getServiceParams();
       this.incomingEvents = this.getIncomingEvents() ?? [];
-      
-      this.prepareEvents();
+
+      await this.prepareEvents();
 
       if (this.logSetup) console.log(`Socket Server Service setup done: ${this.params.name} (${this.params.port}) serurity: ${this.params.security}\n`);
     } catch (error) {
       Dynamo_Log.error(`Socket Server Service setup failed: ${this.params?.name} (${this.params?.port})`, error);
+      throw new Dynamo_Error({
+        errorCode: 'NTS-SSS-001',
+        error: error,        
+      });
     }
   }
 
   /**
    * You must setup events and required services for this function
    */
-  private prepareEvents(): void {
+  private async prepareEvents(): Promise<void> {
     try {
       const connectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventType === DynamoNTS_SocketEventType.connection);
       if (0 <= connectEventIndex) {
@@ -142,6 +152,7 @@ export abstract class DynamoNTS_SocketServerService<
       });
     } catch (error) {
       Dynamo_Log.error(`Socket Server Service - Event Preparation setup failed: ${this.params?.name} (${this.params?.port})`, error);
+      throw error;
     }
   }
 
@@ -266,6 +277,7 @@ export abstract class DynamoNTS_SocketServerService<
       }
     } catch (error) {
       Dynamo_Log.error(`Socket Subscription Removal failed: ${this.params?.name} (${this.params?.port})`, error);
+      throw error;
     }
   }