@futdevpro/nts-dynamo 1.5.55 → 1.5.60

package/src/_models/dynamo-nts-api-call-params.ts

@@ -2,22 +2,74 @@
 import { HttpCallType } from "../_enums/http/http-call-type.enum";
 import { HttpResponseType } from "../_enums/http/http-response-type.enum";
 
+/**
+ * API call params,
+ * such as
+ * type (HttpCallType),
+ * endpoint,
+ * and other options as httpOptions
+ */
 export class DynamoNTS_ApiCallParams {
+  /**
+   * name the call to be able to identify it when debugging
+   */
   name: string;
+  /**
+   * type of the call as; HttpCallType .get, .post, ...ect
+   */
   type: HttpCallType;
+  /**
+   * the endpoint of the API, without the baseUrl:
+   * '/user/get/:userId',
+   * where the parts starting with ':', will be used as pathParam
+   */
   baseUrl: string;
+  /**
+   * baseUrl of the API;
+   * 'https://futdevpro.hu/api'
+   */
   endPoint: string;
 
+  /**
+   * if this value is true, the call will return the full HTTP call response in raw
+   */
   getFullResponse: boolean;
+  /**
+   * this setting will be passed to the axios http call
+   */
   httpOptions: any;
 
   constructor(
+    /**
+     * set of options necessary for setting up an API call
+     */
     set: {
+      /**
+       * name the call to be able to identify it when debugging
+       */
       name: string,
+      /**
+       * set type as; HttpCallType .get, .post, ...ect
+       */
       type: HttpCallType,
+      /**
+       * the endpoint of the API, without the baseUrl:
+       * '/user/get/:userId',
+       * where the parts starting with ':', will be used as pathParam
+       */
       endPoint: string,
+      /**
+       * baseUrl of the API;
+       * 'https://futdevpro.hu/api'
+       */
       baseUrl: string,
+      /**
+       * setting this value to true, will return the full HTTP call response in raw
+       */
       getFullResponse?: boolean,
+      /**
+       * this setting will pass any kind of http setting used by the axios http messaging package
+       */
       httpOptions?: HttpOptions,
     }
   ) {
@@ -34,6 +86,12 @@ export class DynamoNTS_ApiCallParams {
   }
 }
 
+/**
+ * basic axios HttpsOptions,
+ * 
+ * learn more on axios package....
+ * TOD: link package documentations
+ */
 export class HttpOptions {
   responseType?: HttpResponseType;
   headers?: {
@@ -43,19 +101,21 @@ export class HttpOptions {
   reportProgress?: boolean;
   withCredentials?: boolean;
 
-  constructor(options: {
-    responseType?: HttpResponseType,
-    headers?: {
-      [header: string]: string | string[];
-    },
-    observe?: 'body',
-    reportProgress?: boolean,
-    withCredentials?: boolean
-  }) {
-    this.responseType = options.responseType;
-    this.headers = options.headers;
-    this.observe = options.observe;
-    this.reportProgress = options.reportProgress;
-    this.withCredentials = options.withCredentials;
+  constructor(
+    set: {
+      responseType?: HttpResponseType,
+      headers?: {
+        [header: string]: string | string[];
+      },
+      observe?: 'body',
+      reportProgress?: boolean,
+      withCredentials?: boolean
+    }
+  ) {
+    this.responseType = set.responseType;
+    this.headers = set.headers;
+    this.observe = set.observe;
+    this.reportProgress = set.reportProgress;
+    this.withCredentials = set.withCredentials;
   }
 }

package/src/_models/dynamo-nts-app-params.ts

@@ -1,20 +1,52 @@
 
 /**
- * 
+ * This will hold and set the basic settings of an application
  */
 export class DynamoNTS_AppParams {
+  /**
+   * name of the application
+   */
   name: string;
+  /**
+   * title will be shown on the start of the application
+   */
   title: string;
+  /**
+   * version of the application
+   */
   version: string;
+  /**
+   * name of your MongoDB table
+   */
   dbUri: string;
+  /**
+   * mongoDB uri, by default, its: `mongodb://localhost:27017/${this.dbName}`
+   */
   dbName: string;
 
   constructor(
     set: {
+      /**
+       * name the application
+       */
       name: string,
+      /**
+       * you can set a big f*in title to show on the start of the application
+       */
       title?: string,
+      /**
+       * you should set the version,
+       * probably, you should set from the package.json as follows:
+       * import { version } from '../package.json';
+       */
       version: string,
+      /**
+       * You need to name your MongoDB table
+       */
       dbName: string,
+      /**
+       * you can change the mongoDB uri here. by default, its: `mongodb://localhost:27017/${this.dbName}`
+       */
       dbUri?: string,
     }
   ) {

package/src/_models/dynamo-nts-endpoint-params.ts

@@ -4,13 +4,14 @@ import { NextFunction, Request, Response } from 'express';
 
 import { HttpCallType } from '../_enums/http/http-call-type.enum';
 import { DynamoNTS_RouteSecurity } from '../_enums/dynamo-nts-route-security.enum';
-import { DynamoNTS_Shared } from '../_services/dynamo-nts-shared.service';
 import { DynamoNTS_GlobalService } from '../_services/dynamo-nts-global.service';
 import { dynamoNTS_GlobalSettings } from '../_constants';
-import { Dynamo_Error } from '@futdevpro/fsm-dynamo';
+import { Dynamo_Error, Dynamo_Log } from '@futdevpro/fsm-dynamo';
 
 /**
- * 
+ * High level endpoint for API
+ * used for specific events such as saving or getting data,
+ * triggering events, logging in or out, and much more
  */
 export class DynamoNTS_EndpointParams{
   name: string;
@@ -30,23 +31,56 @@ export class DynamoNTS_EndpointParams{
 
   constructor(
     set: {
+      /**
+       * naming the endpoint will help to follow events on service
+       */
       name: string,
+      /**
+       * security settings for API, different security paths will need different handlers 
+       * 
+       * open; http, secure; https or both
+       */
       security?: DynamoNTS_RouteSecurity,
 
+      /**
+       * define basic Http Call Type such as; get, post, put, patch, delete
+       */
       type: HttpCallType,
+      /**
+       * set endpoint here, without baseUrl and route module path
+       * 
+       * like: '/get-user/:userId'
+       */
       endpoint: string,
       
+      /**
+       * preprocesses are the functions you need to run before the actual function,
+       * such as authentications
+       */
       preProcessess?: ((req: Request, res: Response, next: NextFunction) => Promise<void>)[],
+      /**
+       * the actual tasks to run, 
+       * the last one should contain the res.send(); execution to send response on API requests
+       */
       tasks: ((req: Request, res: Response, issuer?: string) => Promise<void>)[],
 
+      /**
+       * this flag will enable the debug logs on this endpoint
+       */
       logRequest?: boolean,
+      /**
+       * this flag will enable the debug logs on this endpoint's requests
+       */
       logRequestsContent?: boolean,
+      /**
+       * this flag will enable detailed debug logs on this endpoint's requests
+       */
       logResponseContent?: boolean,
     }
   ) {
     try {
-      this.name = set.name ? set.name : set.endpoint;
-      this.security = set.security ? set.security : dynamoNTS_GlobalSettings.defaultRouteSecurity;
+      this.name = set.name ?? set.endpoint;
+      this.security = set.security ?? dynamoNTS_GlobalSettings.defaultRouteSecurity;
 
       this.type = set.type;
       this.endpoint = set.endpoint;
@@ -60,12 +94,13 @@ export class DynamoNTS_EndpointParams{
           userMessage: 'We encountered an unhandled Server Error, please contact the responsible development team.'
         });
       }
+
       let pathParts: string[] = this.endpoint.split('/');
       pathParts = pathParts.filter((part: string) => part[0] === ':');
       pathParts = pathParts.map((part: string) => part = part.replace(':', ''));
       this.pathParams = pathParts;
 
-      this.preProcessess = set.preProcessess ? set.preProcessess : [];
+      this.preProcessess = set.preProcessess ?? [];
       this.tasks = set.tasks;
 
       this.logRequest = set.logRequest !== undefined ? set.logRequest : dynamoNTS_GlobalSettings.logRequest;
@@ -76,7 +111,7 @@ export class DynamoNTS_EndpointParams{
         this.preProcessess.unshift(this.getPreLog());
       }
     } catch (error) {
-      DynamoNTS_Shared.logError(
+      Dynamo_Log.logError(
         `\nEndpoint params setup failed: name: '${set.name}' (security: ${set.security}) endpoint: ${set.endpoint}\nERROR:\n`, error);
       throw error;
     }
@@ -131,10 +166,10 @@ export class DynamoNTS_EndpointParams{
   
         if (this.logRequest) {
           if (this.logResponseContent) {
-            DynamoNTS_Shared.logSuccess(`  <<<=====   ${this.name} result sent.`);
-            DynamoNTS_Shared.logSuccess('sorry, the logResponseContent is not implemented yet.');
+            Dynamo_Log.logSuccess(`  <<<=====   ${this.name} result sent.`);
+            Dynamo_Log.logSuccess('sorry, the logResponseContent is not implemented yet.');
           } else {
-            DynamoNTS_Shared.logSuccess(`  <<<=====   ${this.name} result sent.`);
+            Dynamo_Log.logSuccess(`  <<<=====   ${this.name} result sent.`);
           }
         }
       } catch (error) {
@@ -149,16 +184,16 @@ export class DynamoNTS_EndpointParams{
    * @param error 
    */
   error(res: Response, error): void {
-    DynamoNTS_Shared.logError(`Endpoint catched an error. ${this.name} (${this.endpoint})\nERROR:`, error, '\n');
+    Dynamo_Log.logError(`Endpoint catched an error. ${this.name} (${this.endpoint})\nERROR:`, error, '\n');
     res.status(error.status ? error.status : 501);
     res.send(error);
 
     if (this.logRequest) {
       if (this.logResponseContent) {
-        DynamoNTS_Shared.logError(`  <<<=====   ${this.name} error sent.`);
-        DynamoNTS_Shared.logError('sorry, the logResponseContent is not implemented yet.');
+        Dynamo_Log.logError(`  <<<=====   ${this.name} error sent.`);
+        Dynamo_Log.logError('sorry, the logResponseContent is not implemented yet.');
       } else {
-        DynamoNTS_Shared.logError(`  <<<=====   ${this.name} error sent.`);
+        Dynamo_Log.logError(`  <<<=====   ${this.name} error sent.`);
       }
     }
   }

package/src/_models/dynamo-nts-global-settings.ts

@@ -10,17 +10,48 @@ import { DynamoNTS_SocketSecurity } from '../_enums/dynamo-nts-socket-security.e
  * 
  */
 export interface DynamoNTS_GlobalSettings {
+  /**
+   * this will be used as the main baseUrl for the application,
+   * this is not required, but we suggest to use at least a '/api' as base route
+   */
   baseUrl: string;
+  /**
+   * this sets the default security for routes
+   */
   defaultRouteSecurity: DynamoNTS_RouteSecurity;
+  /**
+   * this sets the default security for sockets
+   */
   defaultSocketSecurity: DynamoNTS_SocketSecurity;
 
+  /**
+   * this setting will enable debug logs for setting up the application
+   */
   logSetup?: boolean;
 
+  /**
+   * this is an application wide default setting for route debug logs
+   */
   logRequest?: boolean;
+  /**
+   * this is an application wide default setting for route debug logs
+   */
   logRequestsContent?: boolean;
+  /**
+   * this is an application wide default setting for route debug logs
+   */
   logResponseContent?: boolean;
 
+  /**
+   * this is an application wide default setting for socket debug logs
+   */
   logMainSocketEvent?: boolean;
+  /**
+   * this is an application wide default setting for socket debug logs
+   */
   logAllSocketEvent?: boolean;
+  /**
+   * this is an application wide default setting for socket debug logs
+   */
   logEventContent?: boolean;
 }

package/src/_models/dynamo-nts-routing-module-settings.ts

@@ -2,10 +2,19 @@ import { DynamoNTS_RouteSecurity } from '../_enums';
 import { DynamoNTS_Controller } from '../_services';
 
 /**
- * 
+ * This is a main route point handler, which collects a list of controllers for the API
  */
 export interface DynamoNTS_RoutingModuleSettings {
+  /**
+   * main route of the module
+   */
   route: string;
+  /**
+   * the collection of controllers (sub-routes, with differentlogical parts, to different db elements)
+   */
   controllers: DynamoNTS_Controller[];
+  /**
+   * securityOverride will be used to create different security for a single module without changing the default security (http/https/both)
+   */
   securityOverride?: DynamoNTS_RouteSecurity;
 }

package/src/_models/dynamo-nts-socket-dictionary.ts

@@ -2,6 +2,9 @@
 import { Dynamo_Error } from '@futdevpro/fsm-dynamo';
 import * as SocketIO from 'socket.io';
 
+/**
+ * socket handling and clarification is under development
+ */
 export class DynamoNTS_SocketDictionary {
   issuerId: string;
   sockets: SocketIO.Socket[];

package/src/_models/dynamo-nts-socket-event-params.ts

@@ -1,11 +1,11 @@
 
 
-import { DynamoNTS_Shared } from '../_services/dynamo-nts-shared.service';
 import { dynamoNTS_GlobalSettings } from '../_constants';
 import { DynamoNTS_SocketEvent } from '../_enums/http/socket-event.enum';
+import { Dynamo_Log } from '@futdevpro/fsm-dynamo';
 
 /**
- * 
+ * socket handling and clarification is under development
  */
 export class DynamoNTS_SocketEventParams<T>{
   socketName?: string;
@@ -49,7 +49,7 @@ export class DynamoNTS_SocketEventParams<T>{
         this.preProcessess.unshift(this.getPreLog());
       }
     } catch (error) {
-      DynamoNTS_Shared.logError(
+      Dynamo_Log.logError(
         `\nSocket Event params setup failed (${this.socketName}): ${set.event}`, error);
       throw error;
     }

package/src/_models/dynamo-nts-socket-service-params.ts

@@ -1,10 +1,10 @@
 
+import { Dynamo_Log } from '@futdevpro/fsm-dynamo';
 import { dynamoNTS_GlobalSettings } from '../_constants';
 import { DynamoNTS_SocketSecurity } from '../_enums/dynamo-nts-socket-security.enum';
-import { DynamoNTS_Shared } from '../_services';
 
 /**
- * 
+ * socket handling and clarification is under development
  */
 export class DynamoNTS_SocketServiceParams {
   name: string;
@@ -31,7 +31,7 @@ export class DynamoNTS_SocketServiceParams {
     if (set.getIdFromSubscrioption) {
       this.getIdFromSubscrioption = set.getIdFromSubscrioption;
       if (set.groupActiveSocketsBy) {
-        DynamoNTS_Shared.logError(
+        Dynamo_Log.logError(
           `setting groupActiveSocketsBy on DynamoNTS_SocketService (${this.name}) won't take effect, ` +
           `since getIdFromSubscrioption is also setted, so it will be used instead`)
       }

package/src/_modules/usage/usage.service.ts

@@ -1,6 +1,6 @@
 
 import { Request } from 'express';
-import { Dynamo_Error } from '@futdevpro/fsm-dynamo';
+import { Dynamo_Error, Dynamo_Time } from '@futdevpro/fsm-dynamo';
 import { Dynamo_UsageSession, usageSessionModelParams, Dynamo_UsageData, 
   Dynamo_DailyUsageData } from '@futdevpro/fsm-dynamo/usage-module';
 
@@ -46,7 +46,7 @@ export class UsageService extends DynamoNTS_DataService<Dynamo_UsageSession> {
   async getLastWeekUsage(): Promise<void> {
     try {
       await this.dataDBService.find({
-        sessionStart: { $gte: DynamoNTS_Shared.oneWeekAgo() }
+        sessionStart: { $gte: Dynamo_Time.oneWeekAgo() }
       }).then((res: Dynamo_UsageSession[]) => {
         this.dataList = res;
       });

package/src/_services/dynamo-nts-api.service.ts

@@ -1,18 +1,19 @@
 
 import * as Axios from 'axios';
-import { Dynamo_Error } from '@futdevpro/fsm-dynamo';
+import { Dynamo_Error, Dynamo_Log } from '@futdevpro/fsm-dynamo';
 
 import { HttpCallType } from '../_enums/http/http-call-type.enum';
 import { HttpResponseType } from '../_enums/http/http-response-type.enum';
 import { DynamoNTS_ApiCallParams } from '../_models/dynamo-nts-api-call-params';
-import { DynamoNTS_Shared } from './dynamo-nts-shared.service';
 
 /**
- * 
+ * This predefined Api service contains the basic API call function which can be used in various ways
  */
 export class DynamoNTS_ApiService {
 
-    static defaultErrorUserMsg = 'We encountered a BackEnd API Error, please contact the responsible development team.';
+    static defaultErrorUserMsg = 
+        `We encountered a BackEnd API Error, ` +
+        `\nplease contact the responsible development team.`;
 
     /**
      * 
@@ -21,12 +22,24 @@ export class DynamoNTS_ApiService {
      * @returns 
      */
   public static async startApiCall<T>(
+    /**
+     * you must setup the basic api call params with this.
+     * follow the instructions in the constructor: new DynamoNTS_ApiCallParams({ ... })
+     */
     callParams: DynamoNTS_ApiCallParams,
+    /**
+     * you can pass data and other inputs in this section
+     */
     inputParams?: {
       pathParams?: {
+        /**
+         * path params setted in endpoint
+         */
         [param: string]: string
       },
-      /* queryParams?: object, */
+      /**
+       * api call's body
+       */
       body?: any
     }
   ): Promise<any> {
@@ -40,7 +53,7 @@ export class DynamoNTS_ApiService {
                 if (callParams.httpOptions.headers[headerKey]) {
                     privateAxiosInstance.defaults.headers.common[headerKey] = callParams.httpOptions.headers[headerKey];
                 } else {
-                    DynamoNTS_Shared.logError('DYNAMOBE ERROR: \n missing header:', headerKey, '\n\n', new Error());
+                    Dynamo_Log.logError('DYNAMOBE ERROR: \n missing header:', headerKey, '\n\n', new Error());
                 }
             }
         }
@@ -57,11 +70,11 @@ export class DynamoNTS_ApiService {
                         url = url.replace(`:${pathParamKey}`, inputParams.pathParams[pathParamKey]);
                         break;
                     default:
-                        DynamoNTS_Shared.logError(`DYNAMOBE ERROR: \n wrong path param type: (${pathParamKey}): ${paramType} \n${inputParams.pathParams[pathParamKey]}\nMUST BE string or number\n\n`, new Error());
+                        Dynamo_Log.logError(`DYNAMOBE ERROR: \n wrong path param type: (${pathParamKey}): ${paramType} \n${inputParams.pathParams[pathParamKey]}\nMUST BE string or number\n\n`, new Error());
                         break;
                     }
                 } else {
-                    DynamoNTS_Shared.logError('DYNAMOBE ERROR: \n missing pathParam:', pathParamKey, '\n\n', new Error());
+                    Dynamo_Log.logError('DYNAMOBE ERROR: \n missing pathParam:', pathParamKey, '\n\n', new Error());
                 }
             }
         }
@@ -130,7 +143,7 @@ export class DynamoNTS_ApiService {
                 });
             break;
             default:
-                DynamoNTS_Shared.logError('DYNAMOBE ERROR: \n wrong api call type', '\n\n', new Error());
+                Dynamo_Log.logError('DYNAMOBE ERROR: \n wrong api call type', '\n\n', new Error());
             break;
         }
 
@@ -140,7 +153,7 @@ export class DynamoNTS_ApiService {
             return a as T;
         }
     } catch (error) {
-        DynamoNTS_Shared.logError(`\nAPI ERROR: ${callParams?.name} failed...` +
+        Dynamo_Log.logError(`\nAPI ERROR: ${callParams?.name} failed...` +
         `\n${callParams?.baseUrl}${callParams?.endPoint}`);
 
         if (callParams?.httpOptions?.responseType === HttpResponseType.text) {
@@ -148,7 +161,7 @@ export class DynamoNTS_ApiService {
         }
         
         if (error?.response?.data?.flag === 'DYNAMO ERROR OBJECT') {
-            DynamoNTS_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
+            Dynamo_Log.logError(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
 
             throw new Dynamo_Error({
                 errorCode: 'NTS-API-002',
@@ -158,7 +171,7 @@ export class DynamoNTS_ApiService {
                 error: error.response.data
             });
         } else if (error.code === 'ENOTFOUND') {
-            DynamoNTS_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
+            Dynamo_Log.logError(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
 
             throw new Dynamo_Error({ 
                 status: 404, 
@@ -178,7 +191,7 @@ export class DynamoNTS_ApiService {
                 error 
             });
         } else {
-            DynamoNTS_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL`, error, '\n\n', new Error());
+            Dynamo_Log.logError(`\n${callParams.name} was UNSUCCESSFUL`, error, '\n\n', new Error());
 
             throw error;
         }

package/src/_services/dynamo-nts-app-extended.ts

@@ -2,11 +2,11 @@
 import * as SocketIO from 'socket.io';
 import * as Http from 'http';
 
-import { DynamoNTS_Shared } from './dynamo-nts-shared.service';
 import { DynamoNTS_RouteSecurity } from '../_enums/dynamo-nts-route-security.enum';
 import { DynamoNTS_App } from './dynamo-nts-app';
 import { DynamoNTS_SocketService } from './dynamo-nts-socket.service';
 import { DynamoNTS_SocketSecurity } from '../_enums/dynamo-nts-socket-security.enum';
+import { Dynamo_Log } from '@futdevpro/fsm-dynamo';
 
 /**
  * This will be the MAIN service of our server project,
@@ -27,7 +27,7 @@ import { DynamoNTS_SocketSecurity } from '../_enums/dynamo-nts-socket-security.e
  * // Setting up App params, and preparing project global settings
  *   setupAppParams(): void {
  *     this.params = new DynamoNTS_AppParams({
- *       name: 'Warbots Distribution Server',
+ *       name: 'Warbots Server',
  *       title: warbotsTitleLog,
  *       version: version,
  *       dbName: 'warbots',
@@ -112,6 +112,15 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
 
   private socketSecurity: DynamoNTS_RouteSecurity;
   
+  /**
+   * @example
+   * // Setting up Sockets
+   * this.socketServices = [
+   *   NotificationService.getInstance(),
+   *   ChatService.getInstance(),
+   *   ...
+   * ];
+   */
   protected socketServices: DynamoNTS_SocketService<any>[];
 
   constructor(){
@@ -123,15 +132,15 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
 
         this.setupSocketServices();
 
-        if (this.log) console.log(`\nAll sockets setted up.... sockets using security: ${this.socketSecurity}`);
+        if (this.debugLog) console.log(`\nAll sockets setted up.... sockets using security: ${this.socketSecurity}`);
       } else {
-        DynamoNTS_Shared.logWarning(
+        Dynamo_Log.logWarning(
           '\nNo socketServices setted up while using Extended Application.',
           '\nYou should use DynamoNTS_App if you don`t need socket services.\n' 
         );
       }
     } catch (error) {
-      DynamoNTS_Shared.logError('\nExtended Application start failed.\n', error, '\n');
+      Dynamo_Log.logError('\nExtended Application start failed.\n', error, '\n');
     }
   }
 
@@ -179,7 +188,7 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
               errorMsg += `\n  ${service.name} (port: ${service.port})`;
             }
           });
-          DynamoNTS_Shared.logError(errorMsg);
+          Dynamo_Log.logError(errorMsg);
   
           let error = new Error('Secure routes cannot be established!');
           let errorStack: string[] = error.stack.split('\n');
@@ -206,10 +215,10 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
       }
 
       if (service.security === DynamoNTS_SocketSecurity.open) {
-        if (this.log) console.log(`\nsocket setup (open): ${service.name}:${service.port}`);
+        if (this.debugLog) console.log(`\nsocket setup (open): ${service.name}:${service.port}`);
         service.setupSocketServer(new SocketIO.Server(httpSocketServer));
       } else if (service.security === DynamoNTS_SocketSecurity.secure) {
-        if (this.log) console.log(`\nsocket setup (secure): ${service.name}:${service.port}`);
+        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}`);