@futdevpro/nts-dynamo 1.6.19 → 1.6.20

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

@@ -0,0 +1,113 @@
+
+
+import { usageSessionModelParams } from '@futdevpro/fsm-dynamo/usage-module';
+import { customDataModelParams } from '@futdevpro/fsm-dynamo/custom-data-module';
+
+import { DynamoNTS_AppParams } from '../../_models/control-models/app-params.control-model';
+import { DynamoNTS_GlobalServiceSettings } from '../../_models/interfaces/global-service-settings.interface';
+import { DynamoNTS_PortSettings } from '../../_models/interfaces/port-settings.interface';
+import { getTestRoutingModule } from '../../_modules/test';
+import { getUsageRoutingModule } from '../../_modules/usage';
+import { DynamoNTS_SingletonService } from '../../_services';
+import { DynamoNTS_RoutingModule } from '../../_services/route/routing-module.service';
+import { DynamoNTS_App } from '../../_services/server/app.server';
+import { DynamoNTS_Controller_Mock } from './controller.mock';
+import { AuthService_Mock } from './auth-service.mock';
+import { DynamoNTS_AppExtended, dynamoNTS_globalSettings, DynamoNTS_SocketServerService } from '../../_modules/app-extended.index';
+import { DynamoNTS_SocketServer_Mock } from './socket-server.mock';
+
+/**
+ * 
+ */
+export class DynamoNTS_AppExtendedBase_Mock extends DynamoNTS_AppExtended {
+  getAppParams(): DynamoNTS_AppParams {
+    return new DynamoNTS_AppParams({
+      name: 'test-extended-base',
+      version: '1.0.1',
+      dbName: 'test-base',
+    });
+  }
+
+  getGlobalServiceCollection(): DynamoNTS_GlobalServiceSettings {
+    return {
+      authService: AuthService_Mock.getInstance(),
+    };
+  }
+
+  getPortSettings(): DynamoNTS_PortSettings {
+    return {};
+  }
+
+  getRoutingModules(): DynamoNTS_RoutingModule[] {
+    return [];
+  }
+
+  getSocketServices(): DynamoNTS_SocketServerService[] {
+    return [];
+  }
+}  
+
+////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////
+
+/**
+ * 
+ */
+export class DynamoNTS_AppExtendedFull_Mock extends DynamoNTS_AppExtended {
+  getAppParams(): DynamoNTS_AppParams {
+    return new DynamoNTS_AppParams({
+      name: 'test-extended-full',
+      version: 'x.0.101',
+      dbName: 'test-full',
+    });
+  }
+  
+  
+  overrideDynamoNTSGlobalSettings(): void {
+    /* dynamoNTS_globalSettings.logSetup = true; */
+    /* dynamoNTS_globalSettings.defaultRouteSecurity = DynamoNTS_RouteSecurity.open;  */
+  }
+
+  getGlobalServiceCollection(): DynamoNTS_GlobalServiceSettings {
+    return {
+      authService: AuthService_Mock.getInstance(),
+      /* emailServiceCollection: EmailServiceCollectionService.getInstance(), */
+      dbModels: [
+
+        usageSessionModelParams,
+        customDataModelParams,
+      ],      
+    };
+  }
+
+  getPortSettings(): DynamoNTS_PortSettings {
+    return {
+      httpPort: 53535,
+    };
+  }
+
+  getRoutingModules(): DynamoNTS_RoutingModule[] {
+    return [
+      new DynamoNTS_RoutingModule({
+        route: '/test-0',
+        controllers: [
+          DynamoNTS_Controller_Mock.getInstance(),
+        ],
+      }),
+
+      getTestRoutingModule(),
+      getUsageRoutingModule()
+    ];
+  }
+
+  getSocketServices(): DynamoNTS_SocketServerService[] {
+    return [
+      DynamoNTS_SocketServer_Mock.getInstance(),
+    ];
+  }
+
+  async getRootServices(): Promise<DynamoNTS_SingletonService[]> {
+    return [];
+  }
+}

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

@@ -13,6 +13,7 @@ import { DynamoNTS_RoutingModule } from '../../_services/route/routing-module.se
 import { DynamoNTS_App } from '../../_services/server/app.server';
 import { DynamoNTS_Controller_Mock } from './controller.mock';
 import { AuthService_Mock } from './auth-service.mock';
+import { dynamoNTS_globalSettings } from '../global-settings.const';
 
 /**
  * 
@@ -21,7 +22,7 @@ export class DynamoNTS_AppBase_Mock extends DynamoNTS_App {
   getAppParams(): DynamoNTS_AppParams {
     return new DynamoNTS_AppParams({
       name: 'test-base',
-      version: '1.0.1',
+      version: 'x1.0.1',
       dbName: 'test-base',
     });
   }
@@ -52,13 +53,14 @@ export class DynamoNTS_AppFull_Mock extends DynamoNTS_App {
   getAppParams(): DynamoNTS_AppParams {
     return new DynamoNTS_AppParams({
       name: 'test-full',
-      version: 'x.0.101',
+      version: 'xx.0.101',
       dbName: 'test-full',
     });
   }
   
   
   overrideDynamoNTSGlobalSettings(): void {
+    /* dynamoNTS_globalSettings.logSetup = true; */
     /* dynamoNTS_globalSettings.defaultRouteSecurity = DynamoNTS_RouteSecurity.open;  */
   }
 
@@ -76,14 +78,14 @@ export class DynamoNTS_AppFull_Mock extends DynamoNTS_App {
 
   getPortSettings(): DynamoNTS_PortSettings {
     return {
-      httpPort: 39393
+      httpPort: 10101,
     };
   }
 
   getRoutingModules(): DynamoNTS_RoutingModule[] {
     return [
       new DynamoNTS_RoutingModule({
-        route: '/test-0',
+        route: '/test-extended-0',
         controllers: [
           DynamoNTS_Controller_Mock.getInstance(),
         ],
@@ -94,7 +96,7 @@ export class DynamoNTS_AppFull_Mock extends DynamoNTS_App {
     ];
   }
 
-  getRootServices(): DynamoNTS_SingletonService[] {
+  async getRootServices(): Promise<DynamoNTS_SingletonService[]> {
     return [];
   }
 }

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

@@ -8,10 +8,14 @@ import { DynamoNTS_SocketServerService } from '../../_services/socket/socket-ser
 
 export class DynamoNTS_SocketServer_Mock extends DynamoNTS_SocketServerService<DynamoNTS_SocketPresence> {
   
+  static getInstance(): DynamoNTS_SocketServer_Mock {
+    return DynamoNTS_SocketServer_Mock.getSingletonInstance();
+  }
+  
   getServiceParams(): DynamoNTS_SocketServerServiceParams<any> {
     return new DynamoNTS_SocketServerServiceParams({
       name: 'test',
-      port: 3000,
+      port: 9393,
     });
   }
 

package/src/_models/control-models/app-system-controls.control-model copy.ts

@@ -0,0 +1,9 @@
+
+
+import { DynamoNTS_SystemControl } from './system-control.control-model'
+
+export class DynamoNTS_AppExtSysControls {
+  appExtended: DynamoNTS_SystemControl = new DynamoNTS_SystemControl();
+  httpSocketServer: DynamoNTS_SystemControl = new DynamoNTS_SystemControl();
+  httpsSocketServer: DynamoNTS_SystemControl = new DynamoNTS_SystemControl();  
+}

package/src/_models/control-models/app-system-controls.control-model.ts

@@ -0,0 +1,9 @@
+import { DynamoNTS_SystemControl } from './system-control.control-model'
+
+
+export class DynamoNTS_AppSystemControls {
+  app: DynamoNTS_SystemControl = new DynamoNTS_SystemControl();
+  mongoose: DynamoNTS_SystemControl = new DynamoNTS_SystemControl();
+  httpServer: DynamoNTS_SystemControl = new DynamoNTS_SystemControl();
+  httpsServer: DynamoNTS_SystemControl = new DynamoNTS_SystemControl();  
+}

package/src/_models/control-models/system-control.control-model.ts

@@ -0,0 +1,13 @@
+
+
+
+export class DynamoNTS_SystemControl {
+  init: boolean = false;
+  /* failed: boolean = false; */
+  started: boolean = false;
+
+  getReady(): boolean {
+    return this.init ? this.started : true;
+  }
+}
+

package/src/_services/base/db.service.ts

@@ -17,7 +17,7 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
 
   serviceName: string;
 
-  dataModel = mongoose.model(this.dataParams.dbName, this.getSchema());
+  dataModel; // = mongoose.model(this.dataParams.dbName, this.getSchema());
 
   private depDataName: string;
 
@@ -34,21 +34,31 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
   constructor(
     public dataParams: Dynamo_DataParams
   ){
-    try {
-      this.serviceName = this.constructor?.name;
-      this.lookForDependencyDataSettings();
-    } catch (error) {
-      Dynamo_Log.error(
-        `\nDynamoNTS_DBService ERROR, The dbService construction failed for ${dataParams.dataName}. ${this.serviceName}`, 
-        new Error()
-      );
-      /* error = new Dynamo_Error({
-        message: `\nDynamoNTS_DBService ERROR, The construction failed for ${dataParams.dataName}. ${this.serviceName}`, 
-        error
-      });
+    async () => {
+      try {
+        this.serviceName = this.constructor?.name;
+
+        try {
+          this.dataModel = mongoose.model(this.dataParams.dbName, this.getSchema());
+        } catch {
+          this.dataModel = mongoose.models[this.dataParams.dbName];
+        }
 
-      throw error; */
-    }
+        this.lookForDependencyDataSettings();
+        // Dynamo_Log.testLog(`${this.dataParams.dbName}: ${this.dataModel === mongoose.models[this.dataParams.dbName]}`);
+      } catch (error) {
+        Dynamo_Log.error(
+          `\nDynamoNTS_DBService ERROR, The dbService construction failed for ${dataParams.dataName}. ${this.serviceName}`, 
+          new Error()
+        );
+        /* error = new Dynamo_Error({
+          message: `\nDynamoNTS_DBService ERROR, The construction failed for ${dataParams.dataName}. ${this.serviceName}`, 
+          error
+        });
+
+        throw error; */
+      }
+    };
   }
 
   /**

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

@@ -0,0 +1,45 @@
+import { DynamoNTS_AppExtendedBase_Mock, DynamoNTS_AppExtendedFull_Mock } from '../../_constants/mocks/app-extended-server.mock';
+
+describe('DynamoNTS_AppExtended;', () => {
+  describe('a extended-base instance;', () => {
+    let app: DynamoNTS_AppExtendedBase_Mock;
+
+    beforeEach(async () => {
+      app = new DynamoNTS_AppExtendedBase_Mock();
+      await app.ready();
+    });
+
+    afterEach(async () => {
+      await app.stop();
+    });
+
+    it('should be created', () => {
+      expect(app).toBeDefined();
+    });
+
+    it('should be started', () => {
+      expect(app.started).toBeTrue();
+    });
+  });
+
+  describe('a extended-full instance;', () => {
+    let app: DynamoNTS_AppExtendedFull_Mock;
+
+    beforeEach(async () => {
+      app = new DynamoNTS_AppExtendedFull_Mock();
+      await app.ready();
+    });
+
+    afterEach(async () => {
+      await app.stop();
+    });
+
+    it('should be created', () => {
+      expect(app).toBeDefined();
+    });
+      
+    it('should be started', () => {
+      expect(app.started).toBeTrue();
+    });
+  });
+});

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

@@ -2,12 +2,13 @@
 import * as SocketIO from 'socket.io';
 import * as Http from 'http';
 
-import { Dynamo_Log } from '@futdevpro/fsm-dynamo';
+import { delay, Dynamo_Array, Dynamo_Error, Dynamo_Log, second, wait } from '@futdevpro/fsm-dynamo';
 
 import { DynamoNTS_App } from './app.server';
 import { DynamoNTS_RouteSecurity } from '../../_enums/route-security.enum';
 import { DynamoNTS_SocketServerService } from '../socket/socket-server.service';
 import { DynamoNTS_SocketSecurity } from '../../_enums/socket-security.enum';
+import { DynamoNTS_AppExtSysControls } from '../../_models/control-models/app-system-controls.control-model copy';
 
 /**
  * This will be the MAIN service of our server project,
@@ -110,8 +111,15 @@ import { DynamoNTS_SocketSecurity } from '../../_enums/socket-security.enum';
  * }
  */
 export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
+  
+  private systemControlsExt: DynamoNTS_AppExtSysControls = new DynamoNTS_AppExtSysControls();
+  override get started(): boolean { return this.systemControlsExt.appExtended.started; }
+  private httpsSocketCount: number = 0;
+  private httpSocketCount: number = 0;
 
   private socketSecurity: DynamoNTS_RouteSecurity;
+
+  private httpSocketServer: Http.Server;
   
   /**
    * @example
@@ -123,27 +131,150 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
    * ];
    */
   protected socketServices: DynamoNTS_SocketServerService<any>[];
+  private allSocketServers: SocketIO.Server[] = [];
 
   constructor(){
-    super();
+    super(true);
+
+    this.asyncConstructExt();
+  }
 
+  private async asyncConstructExt(): Promise<void> {
+    if (this.logFn && this.deepLog) console.log('\nfn:. asyncConstruct-extended');
     try {
+      this.systemControlsExt.appExtended.init = true;
+    
       this.socketServices = this.getSocketServices();
 
       if (this.socketServices?.length) {
         this.setSocketSecurity();
 
-        this.setupSocketServerServices();
-
-        if (this.debugLog) console.log(`\nAll sockets setted up.... sockets using security: ${this.socketSecurity}`);
+        await this.setupSocketServerServices();
+        if (this.logSetup) console.log(`\nAll sockets setted up.... sockets using security: ${this.socketSecurity}`);
       } else {
-        Dynamo_Log.warn(
+        Dynamo_Log.testWarn(
           '\nNo socketServices setted up while using Extended Application.',
           '\nYou should use DynamoNTS_App if you don`t need socket services.\n' 
         );
       }
+
+      await this.ready();
+      
+      Dynamo_Log.test(`${this.params.name} started successfully.`);
     } catch (error) {
-      Dynamo_Log.error('\nExtended Application start failed.\n', error, '\n');
+      Dynamo_Log.error(`\nExtended Application: ${this.params?.name} start failed.\n`, error, '\n');
+    }
+  }
+
+  override async ready(timeout: number = 4 * second): Promise<void> {
+    if (this.logFn) console.log('\nfn:. ready-extended');
+    /* return new Promise(async (resolve, reject) => { */
+    /* try { */
+    await super.ready(timeout);
+
+    let ready: boolean = false;
+    const start: number = +new Date();
+
+    if (this.constructErrors.length) {
+      throw new Dynamo_Error({ 
+        message: `${this.params?.name} start failed. ERRORS`,
+        additionalContent: this.constructErrors,
+        error: this.constructErrors?.[0] ?? new Error()
+      });
+    }
+
+    if (this.logFn && this.deepLog) console.log('\nfn:. ready-extended: bef while', this.systemControls, this.systemControlsExt);
+    while (!ready && +new Date() - start < timeout) {
+      if (this.systemControlsExt.appExtended.init) {
+        ready = (
+          this.superStarted &&
+          this.systemControlsExt.httpSocketServer.getReady() &&
+          this.systemControlsExt.httpsSocketServer.getReady()
+        );
+      }
+
+      await wait(100);
+    }
+
+    if (this.constructErrors.length) {
+      throw new Dynamo_Error({ 
+        message: `${this.params?.name} start failed. TIMEOUT`,
+        additionalContent: this.constructErrors,
+        error: this.constructErrors?.[0] ?? new Error()
+      });
+    }
+
+    /* ready = (
+      this.superStarted &&
+      this.systemControlsExt.httpSocketServer.getReady() &&
+      this.systemControlsExt.httpsSocketServer.getReady()
+    ); */
+      /* console.log('T1000', ready, this.started, this.systemControlsExt.httpSocketServer.getReady(), this.systemControlsExt.httpsSocketServer.getReady(),  this.systemControls, this.systemControlsExt); */
+    if (ready) {
+      this.systemControlsExt.appExtended.started = true;
+      
+      if (this.logFn && this.deepLog) console.log('\nfn:. ready-extended: return');
+      return;
+    } else {
+      this.systemControlsExt.appExtended.started = false;
+      
+      let msg: string = `${this.params?.name} start failed. UNKNOWN`;
+      if (this.systemControlsExt.httpSocketServer.init && !this.systemControlsExt.httpSocketServer.started) {
+        msg += '\nhttpSocketServer start failed.';
+      }
+      if (this.systemControlsExt.httpsSocketServer.init && !this.systemControlsExt.httpsSocketServer.started) {
+        msg += '\nhttpsSocketServer start failed.';
+      }      
+
+      throw new Dynamo_Error({ 
+        errorCode: 'NTS-AES-110',
+        message: msg,
+        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(),
+          },
+        },
+        error: this.constructErrors?.[0] ?? new Error()
+      });
+    }
+    /* } catch (error) {
+      reject(error);
+    } */
+    /* }); */
+  }
+
+  override async stop(): Promise<void> {
+    if (this.logFn) console.log('\nfn:. stop-extended');
+    if (this.started) {
+      await super.stop(true);
+
+      this.systemControlsExt.httpSocketServer.started = false;
+      this.systemControlsExt.httpsSocketServer.started = false;
+      await Dynamo_Array.asyncForEach(this.allSocketServers, async (socketServer: SocketIO.Server) => {
+        await new Promise<void>((resolve, reject) => {
+          socketServer.disconnectSockets(true);
+          socketServer.close((err) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve();
+            }
+          });
+        });
+      });
+      this.systemControlsExt.httpSocketServer.init = false;
+      this.systemControlsExt.httpsSocketServer.init = false;
+
+      Dynamo_Log.test(`${this.params.name} stopped successfully.`);
     }
   }
 
@@ -151,6 +282,7 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
    * 
    */
   private setSocketSecurity(): void {
+    if (this.logFn) console.log('\nfn:. setSocketSecurity');
     this.socketServices.forEach((service: DynamoNTS_SocketServerService<any>) => {
       if (!this.socketSecurity) {
         this.socketSecurity = DynamoNTS_RouteSecurity[service.security];
@@ -163,20 +295,23 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
   /**
    * 
    */
-  private setupSocketServerServices(): void {
+  private async setupSocketServerServices(): Promise<void> {
     try {
-      let httpSocketServer: Http.Server;
+      if (this.logFn) console.log('\nfn:. setupSocketServerServices');
+      /* let httpServer: Http.Server; */
       if (this.socketSecurity !== DynamoNTS_RouteSecurity.secure) {
         if (!this.openExpress) {
-          this.initOpenExpress();
+          await this.initOpenExpress();
+        }
+        if (!this.httpSocketServer) {
+          this.httpSocketServer = Http.createServer(this.openExpress);
         }
-        httpSocketServer = Http.createServer(this.openExpress);
       }
 
       if (this.socketSecurity !== DynamoNTS_RouteSecurity.open) {
         if (!this.httpsServer) {
           if (this.cert) {
-            this.initSecureExpress();
+            await this.initSecureExpress();
           } else {
             let errorMsg: string =
               `\nYou have secure socket service, but the certification paths are not set!` +
@@ -190,7 +325,7 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
             errorMsg += '\n\nThe socket services setted to use secure server:';
             this.socketServices.forEach((service: DynamoNTS_SocketServerService<any>) => {
               if (service.security != DynamoNTS_SocketSecurity.open) {
-                errorMsg += `\n  ${service.name} (port: ${service.port})`;
+                errorMsg += `\n  ${service?.name} (port: ${service.port})`;
               }
             });
             Dynamo_Log.error(errorMsg);
@@ -205,42 +340,74 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
         }
       }
 
-      this.socketServices.forEach((service: DynamoNTS_SocketServerService<any>) => {
-        try {
-          const existingPorts: DynamoNTS_SocketServerService<any>[] = this.socketServices.filter(
-            (mod: DynamoNTS_SocketServerService<any>) => mod.port === service.port
-          );
+      await Dynamo_Array.asyncForEach(
+        this.socketServices, 
+        async (service: DynamoNTS_SocketServerService<any>) => {
+          try {
+            this.systemControlsExt.httpSocketServer.init = true;
+            const existingPorts: DynamoNTS_SocketServerService<any>[] = this.socketServices.filter(
+              (mod: DynamoNTS_SocketServerService<any>) => mod.port === service.port
+            );
 
-          if (1 < existingPorts.length || this.ports.httpPort === service.port || this.ports.httpsPort === service.port) {
-            let error = new Error(`PORT DUPLICATION: ${service.port}`);
-            let errorStack: string[] = error.stack.split('\n');
-            errorStack.splice(1, 4);
-            error.stack = errorStack.join('\n');
+            if (1 < existingPorts.length || this.ports.httpPort === service.port || this.ports.httpsPort === service.port) {
+              let error = new Error(`PORT DUPLICATION: ${service.port}`);
+              let errorStack: string[] = error.stack.split('\n');
+              errorStack.splice(1, 4);
+              error.stack = errorStack.join('\n');
 
-            throw error;
-          }
+              throw error;
+            }
 
-          if (service.security === DynamoNTS_SocketSecurity.open) {
-            if (this.debugLog) console.log(`\nsocket setup (open): ${service.name}:${service.port}`);
-            service.setupSocketServer(new SocketIO.Server(httpSocketServer));
+            if (service.security === DynamoNTS_SocketSecurity.open) {
+              if (this.logSetup) console.log(`\nsocket setup (open): ${service?.name}:${service.port}`);
+              this.httpSocketCount++;
+              this.systemControlsExt.httpSocketServer.started = false;
 
-          } else if (service.security === DynamoNTS_SocketSecurity.secure) {
-            if (this.debugLog) console.log(`\nsocket setup (secure): ${service.name}:${service.port}`);
-            service.setupSocketServer(new SocketIO.Server(this.httpsServer));
-            
-          } else {
-            let error = new Error(`INVALID Socket Service security: ${service.security} on ${service.name}`);
-            let errorStack: string[] = error.stack.split('\n');
-            errorStack.splice(1, 4);
-            error.stack = errorStack.join('\n');
+              this.allSocketServers.push(
+                await service.setupSocketServer(
+                  new SocketIO.Server(this.httpSocketServer), 
+                  DynamoNTS_SocketSecurity.open, 
+                  () => { 
+                    this.httpSocketCount--;
+                    if (this.httpSocketCount === 0) {
+                      this.systemControlsExt.httpSocketServer.started = true;
+                    }
+                  }
+                )
+              );
+
+            } else if (service.security === DynamoNTS_SocketSecurity.secure) {
+              if (this.logSetup) console.log(`\nsocket setup (secure): ${service?.name}:${service.port}`);
+              this.httpsSocketCount++;
+              this.systemControlsExt.httpsSocketServer.started = false;
 
+              this.allSocketServers.push(
+                await service.setupSocketServer(
+                  new SocketIO.Server(this.httpsServer), 
+                  DynamoNTS_SocketSecurity.secure, 
+                  () => {
+                    this.httpsSocketCount--;
+                    if (this.httpsSocketCount === 0) {
+                      this.systemControlsExt.httpsSocketServer.started = true;
+                    }
+                  }
+                )
+              );
+              
+            } else {
+              let error = new Error(`INVALID Socket Service security: ${service.security} on ${service?.name}`);
+              let errorStack: string[] = error.stack.split('\n');
+              errorStack.splice(1, 4);
+              error.stack = errorStack.join('\n');
+
+              throw error;
+            }
+          } catch (error) {
+            Dynamo_Log.error(`\nSocket Server service setup failed. (${service?.name})\n`, error, '\n');
             throw error;
           }
-        } catch (error) {
-          Dynamo_Log.error(`\nSocket Server service setup failed. (${service.name})\n`, error, '\n');
-          throw error;
         }
-      });
+      );
     } catch (error) {
       Dynamo_Log.error(`\nSocket Server services setup failed. (${this.socketServices?.length} services)\n`, error, '\n');
       throw error;