@futdevpro/nts-dynamo 1.5.30 → 1.5.32

package/src/_services/{dynamobe-api.service.ts → dynamo-nts-api.service.ts}

@@ -1,16 +1,16 @@
 
 import * as Axios from 'axios';
-import { DynamoBEError } from '@futdevpro/fsm-dynamo';
+import { DynamoNTS_Error } from '@futdevpro/fsm-dynamo';
 
 import { HttpCallType } from '../_enums/http/http-call-type.enum';
 import { HttpResponseType } from '../_enums/http/http-response-type.enum';
-import { DynamoBEApiCallParams } from '../_models/dynamobe-api-call-params';
-import { DBE_Shared } from './dynamobe-shared.service';
+import { DynamoNTS_ApiCallParams } from '../_models/dynamo-nts-api-call-params';
+import { DynamoNTS_Shared } from './dynamo-nts-shared.service';
 
 /**
  * 
  */
-export class DynamoBEApiService {
+export class DynamoNTS_ApiService {
 
     /**
      * 
@@ -19,7 +19,7 @@ export class DynamoBEApiService {
      * @returns 
      */
   public static async startApiCall<T>(
-    callParams: DynamoBEApiCallParams,
+    callParams: DynamoNTS_ApiCallParams,
     inputParams?: {
       pathParams?: {
         [param: string]: string
@@ -38,7 +38,7 @@ export class DynamoBEApiService {
                 if (callParams.httpOptions.headers[headerKey]) {
                     privateAxiosInstance.defaults.headers.common[headerKey] = callParams.httpOptions.headers[headerKey];
                 } else {
-                    DBE_Shared.logError('DYNAMOBE ERROR: \n missing header:', headerKey, '\n\n', new Error());
+                    DynamoNTS_Shared.logError('DYNAMOBE ERROR: \n missing header:', headerKey, '\n\n', new Error());
                 }
             }
         }
@@ -55,11 +55,11 @@ export class DynamoBEApiService {
                         url = url.replace(`:${pathParamKey}`, inputParams.pathParams[pathParamKey]);
                         break;
                     default:
-                        DBE_Shared.logError(`DYNAMOBE ERROR: \n wrong path param type: (${pathParamKey}): ${paramType} \n${inputParams.pathParams[pathParamKey]}\nMUST BE string or number\n\n`, new Error());
+                        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());
                         break;
                     }
                 } else {
-                    DBE_Shared.logError('DYNAMOBE ERROR: \n missing pathParam:', pathParamKey, '\n\n', new Error());
+                    DynamoNTS_Shared.logError('DYNAMOBE ERROR: \n missing pathParam:', pathParamKey, '\n\n', new Error());
                 }
             }
         }
@@ -128,7 +128,7 @@ export class DynamoBEApiService {
                 });
             break;
             default:
-                DBE_Shared.logError('DYNAMOBE ERROR: \n wrong api call type', '\n\n', new Error());
+                DynamoNTS_Shared.logError('DYNAMOBE ERROR: \n wrong api call type', '\n\n', new Error());
             break;
         }
 
@@ -138,29 +138,29 @@ export class DynamoBEApiService {
             return a as T;
         }
     } catch (error) {
-        DBE_Shared.logError(`\nAPI ERRROR: ${callParams?.name} failed...` +
+        DynamoNTS_Shared.logError(`\nAPI ERRROR: ${callParams?.name} failed...` +
         `\n${callParams?.baseUrl}${callParams?.endPoint}`);
         if (callParams?.httpOptions?.responseType === HttpResponseType.text) {
             error.error = JSON.parse(error.error);
         }
         if (error?.response?.data?.flag === 'DYNAMO-BE ERROR OBJECT') {
-            DBE_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
-            throw new DynamoBEError(error.response.data);
+            DynamoNTS_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
+            throw new DynamoNTS_Error(error.response.data);
         } else if (error.code === 'ENOTFOUND') {
-            DBE_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
-            throw new DynamoBEError({ 
+            DynamoNTS_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
+            throw new DynamoNTS_Error({ 
                 status: 404, message: 'DNS error; address cannot be resolved!', 
                 userMessage: `We encountered a BackEnd API Error, please contact the responsible development team. errorcode: 965-453-300`, 
                 error: error 
             });
         } else if (error.config && error.message) {
-            throw new DynamoBEError({ 
+            throw new DynamoNTS_Error({ 
                 status: +error.message.substring(error.message.length - 4, 3), 
                 userMessage: `We encountered a BackEnd API Error, please contact the responsible development team. errorcode: 965-453-303`, 
                 error: error 
             });
         } else {
-            DBE_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL`, error, '\n\n', new Error());
+            DynamoNTS_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL`, error, '\n\n', new Error());
             throw error;
         }
     }

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

@@ -0,0 +1,124 @@
+
+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';
+
+export class DynamoBESocketModule { // NEW
+  security:DynamoNTS_RouteSecurity; 
+  port:number 
+}
+
+/**
+ * This will be the main service of our server project,
+ * follow the types and type instructions while setting up your project
+ * 
+ * In this service, there are abstract functions that you will need to implement,
+ * where you need to set up the main params for your application.
+ */
+export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
+  
+  private openSocketServer: SocketIO.Server;
+  /* private secureSocketServer: SocketIO.Server; */
+  
+  protected socketModules: DynamoBESocketModule[];
+
+  constructor(){
+    super();
+
+    try {
+
+      if (0 < this.socketModules.length) { // NEW
+        if (this.security !== DynamoNTS_RouteSecurity.secure) {
+          this.initOpenSocketPorts();
+        }
+      }
+    } catch (error) {
+      DynamoNTS_Shared.logError('\nExtended Application start failed.\n', error);
+    }
+  }
+
+  /**
+   * 
+   */
+  private initOpenSocketPorts(): void {  // NEW NEED SECURE AS WELL
+    const httpSocketServer: Http.Server = Http.createServer(this.openExpress);
+    this.openSocketServer = new SocketIO.Server(httpSocketServer);
+
+    this.socketModules.forEach((module: DynamoBESocketModule) => {
+      if (module.security !== DynamoNTS_RouteSecurity.secure) {
+        if (this.log) console.log(`socket mount (open): ${module.port}`);
+
+
+
+
+        const existingPorts: DynamoBESocketModule[] = this.socketModules.filter(
+            (mod: DynamoBESocketModule) => mod.port === module.port);
+
+        if (1 < existingPorts.length || this.httpPort === module.port || this.httpsPort === module.port) {
+          let error = new Error(`PORT DUPLICATION: ${module.port}`);
+          let errorStack: string[] = error.stack.split('\n');
+          errorStack.splice(1, 4);
+          error.stack = errorStack.join('\n');
+  
+          throw error;
+        }
+
+        
+    const highlight = '\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!' +
+    '\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!' +
+    '\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!' +
+    '\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!';
+        
+    this.openSocketServer.on('disconnect', (socket) => {
+      console.log(highlight, `\nnew DISCONNECT ALFA: \n\n`, socket);
+    })
+    
+    this.openSocketServer.on('new message', (msg) => {
+      console.log(highlight, `\nnew MESSAGE ALFA: \n\n`, msg);
+    })
+
+    this.openSocketServer.on('connection', (socket) => {
+      console.log(highlight, `\nnew CONNECTION: \n\n`, socket);
+
+      socket.on('disconnect', (socket) => {
+        console.log(highlight, `\nnew DISCONNECT BETA: \n\n`, socket);
+      });
+      
+      socket.on('new message', (msg) => {
+        console.log(highlight, `\nnew MESSAGE BETA: \n\n`, msg);
+      });
+    })
+
+
+
+        this.openSocketServer.listen(module.port);
+
+
+
+        this.openSocketServer.on('disconnect', (socket) => {
+          console.log(highlight, `\nnew DISCONNECT ALFA: \n\n`, socket);
+        })
+        
+        this.openSocketServer.on('new message', (msg) => {
+          console.log(highlight, `\nnew MESSAGE ALFA: \n\n`, msg);
+        })
+    
+        this.openSocketServer.on('connection', (socket) => {
+          console.log(highlight, `\nnew CONNECTION: \n\n`, socket);
+    
+          socket.on('disconnect', (socket) => {
+            console.log(highlight, `\nnew DISCONNECT BETA: \n\n`, socket);
+          });
+          
+          socket.on('new message', (msg) => {
+            console.log(highlight, `\nnew MESSAGE BETA: \n\n`, msg);
+          });
+        })
+
+      }
+    });
+  }
+}

package/src/_services/{dynamobe-app.ts → dynamo-nts-app.ts}

@@ -1,17 +1,17 @@
 
-import { DynamoBEAppParams } from '../_models/dynamobe-app-params';
+import { DynamoNTS_AppParams } from '../_models/dynamo-nts-app-params';
 import Mongoose = require("mongoose");
 import Express = require("express");
 import * as Https from 'https';
 import * as FileSystem from 'fs';
 import * as BodyParser from 'body-parser';
 
-import { DBE_Shared } from './dynamobe-shared.service';
-import { DynamoBESingletonService } from './dynamobe-singleton.service';
-import { DynamoBERouteSecurity } from '../_enums/dynamobe-route-security.enum';
-import { DynamoBERoutingModule } from './dynamobe-routing-module.service';
-import { DynamoBEEndpointParams } from '../_models/dynamobe-endpoint-params';
-import { dynamoBEGlobalSettings } from '../_constants';
+import { DynamoNTS_Shared } from './dynamo-nts-shared.service';
+import { DynamoNTS_SingletonService } from './dynamo-nts-singleton.service';
+import { DynamoNTS_RouteSecurity } from '../_enums/dynamo-nts-route-security.enum';
+import { DynamoNTS_RoutingModule } from './dynamo-nts-routing-module.service';
+import { DynamoNTS_EndpointParams } from '../_models/dynamo-nts-endpoint-params';
+import { dynamoNTS_GlobalSettings } from '../_constants';
 
 /**
  * This will be the main service of our server project,
@@ -20,13 +20,13 @@ import { dynamoBEGlobalSettings } from '../_constants';
  * In this service, there are abstract functions that you will need to implement,
  * where you need to set up the main params for your application.
  */
-export abstract class DynamoBEApp extends DynamoBESingletonService {
+export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
-  protected params: DynamoBEAppParams;
+  protected params: DynamoNTS_AppParams;
   
   protected mongoose = Mongoose;
 
-  protected security: DynamoBERouteSecurity;
+  protected security: DynamoNTS_RouteSecurity;
 
   protected httpPort?: number;
   protected httpsPort?: number;
@@ -38,9 +38,9 @@ export abstract class DynamoBEApp extends DynamoBESingletonService {
 
   private secureExpress: Express.Application;
   private httpsServer: Https.Server;
-  private openExpress: Express.Application;
+  protected openExpress: Express.Application;
 
-  protected routingModules: DynamoBERoutingModule[];
+  protected routingModules: DynamoNTS_RoutingModule[];
 
   protected log: boolean;
 
@@ -55,7 +55,7 @@ export abstract class DynamoBEApp extends DynamoBESingletonService {
       this.startDB();
 
       this.setGlobalServiceCollection();
-      this.log = dynamoBEGlobalSettings.logSetup;
+      this.log = dynamoNTS_GlobalSettings.logSetup;
 
       this.setupRoutingModules();
       this.setSecurity();
@@ -64,17 +64,17 @@ export abstract class DynamoBEApp extends DynamoBESingletonService {
         this.initExpresses();
         this.startExpresses();
 
-        if (this.security !== DynamoBERouteSecurity.secure) {
+        if (this.security !== DynamoNTS_RouteSecurity.secure) {
           this.mountOpenRoutes();
         }
-        if (this.security !== DynamoBERouteSecurity.open && this.cert) {
+        if (this.security !== DynamoNTS_RouteSecurity.open && this.cert) {
           this.mountSecureRoutes();
         }
 
         if (this.log) console.log(`\nRoutes mounted.... server using security: ${this.security}`);
       }
     } catch (error) {
-      DBE_Shared.logError('\nApplication start failed.\n', error);
+      DynamoNTS_Shared.logError('\nApplication start failed.\n', error);
     }
   }
 
@@ -84,10 +84,10 @@ export abstract class DynamoBEApp extends DynamoBESingletonService {
   private startDB(): void {
     this.mongoose.connection
       .on('error', (error) => {
-        DBE_Shared.logError('\nUnable to connect to MongoDB server, ERROR: ', error);
+        DynamoNTS_Shared.logError('\nUnable to connect to MongoDB server, ERROR: ', error);
       })
       .once('open', () => {
-        DBE_Shared.logSuccess('\nConnected to MongoDB\n');
+        DynamoNTS_Shared.logSuccess('\nConnected to MongoDB\n');
       });
 
     this.mongoose.connect(
@@ -103,7 +103,7 @@ export abstract class DynamoBEApp extends DynamoBESingletonService {
    * 
    */
   private initExpresses() {
-    if (this.security !== DynamoBERouteSecurity.secure) {
+    if (this.security !== DynamoNTS_RouteSecurity.secure) {
       if (!this.httpPort) {
         let errorMsg: string =
           `\nYou have open routes, but httpPort is not set!` +
@@ -111,17 +111,17 @@ export abstract class DynamoBEApp extends DynamoBESingletonService {
           `\nset httpPort in DynamoBEServer - setupRoutingModules() to enable secure routes.`;
         
         errorMsg += '\n\nThe routes setted to use open server:';
-        this.routingModules.forEach((module: DynamoBERoutingModule) => {
-          if (module.security != DynamoBERouteSecurity.secure) {
+        this.routingModules.forEach((module: DynamoNTS_RoutingModule) => {
+          if (module.security != DynamoNTS_RouteSecurity.secure) {
             errorMsg += `\n  ${module.route} (security: ${module.security}) \n  subroutes using open sever:`;
-            module.endpoints.forEach((endpoint: DynamoBEEndpointParams) => {
-              if (endpoint.security != DynamoBERouteSecurity.secure) {
+            module.endpoints.forEach((endpoint: DynamoNTS_EndpointParams) => {
+              if (endpoint.security != DynamoNTS_RouteSecurity.secure) {
                 errorMsg += `\n    ${endpoint.endpoint} (security: ${endpoint.security})`;
               }
             });
           }
         });
-        DBE_Shared.logError(errorMsg);
+        DynamoNTS_Shared.logError(errorMsg);
 
         let error = new Error('Open routes cannot be established!');
         let errorStack: string[] = error.stack.split('\n');
@@ -134,7 +134,7 @@ export abstract class DynamoBEApp extends DynamoBESingletonService {
       this.initOpenExpress();
     }
 
-    if (this.security !== DynamoBERouteSecurity.open) {
+    if (this.security !== DynamoNTS_RouteSecurity.open) {
       if (!this.cert || !this.httpsPort) {
         let errorMsg: string =
           `\nYou have secure routes, but the certification paths or httpsPort are not set!` +
@@ -148,17 +148,17 @@ export abstract class DynamoBEApp extends DynamoBESingletonService {
           `\nin DynamoBEServer - setupRoutingModules() to enable secure routes.`;
         
         errorMsg += '\n\nThe routes setted to use secure server:';
-        this.routingModules.forEach((module: DynamoBERoutingModule) => {
-          if (module.security != DynamoBERouteSecurity.open) {
+        this.routingModules.forEach((module: DynamoNTS_RoutingModule) => {
+          if (module.security != DynamoNTS_RouteSecurity.open) {
             errorMsg += `\n  ${module.route} (security: ${module.security}) \n  subroutes using secure sever:`;
-            module.endpoints.forEach((endpoint: DynamoBEEndpointParams) => {
-              if (endpoint.security != DynamoBERouteSecurity.open) {
+            module.endpoints.forEach((endpoint: DynamoNTS_EndpointParams) => {
+              if (endpoint.security != DynamoNTS_RouteSecurity.open) {
                 errorMsg += `\n    ${endpoint.endpoint} (security: ${endpoint.security})`;
               }
             });
           }
         });
-        DBE_Shared.logError(errorMsg);
+        DynamoNTS_Shared.logError(errorMsg);
 
         let error = new Error('Secure routes cannot be established!');
         let errorStack: string[] = error.stack.split('\n');
@@ -201,33 +201,33 @@ export abstract class DynamoBEApp extends DynamoBESingletonService {
    */
   private async startExpresses(): Promise<void> {
     try {
-      if (this.security !== DynamoBERouteSecurity.open) {
+      if (this.security !== DynamoNTS_RouteSecurity.open) {
         this.httpsServer
           .listen(this.httpsPort, 'localhost', 0, () => {
-            DBE_Shared.logSuccess(`\nHTTPS (secure) server is listening on port ${this.httpsPort}\n`);
+            DynamoNTS_Shared.logSuccess(`\nHTTPS (secure) server is listening on port ${this.httpsPort}\n`);
           })
           .on('error', (error) => {
-            DBE_Shared.logError(`\nHTTPS (secure) server ERROR`, error);
+            DynamoNTS_Shared.logError(`\nHTTPS (secure) server ERROR`, error);
           })
           .on('uncaughtException', (ex) => {
-            DBE_Shared.logWarning(`\nHTTPS (secure) server uncaughtException`, ex);
+            DynamoNTS_Shared.logWarning(`\nHTTPS (secure) server uncaughtException`, ex);
           });
       }
 
-      if (this.security !== DynamoBERouteSecurity.secure) {
+      if (this.security !== DynamoNTS_RouteSecurity.secure) {
         this.openExpress
           .listen(this.httpPort, () => {
-            DBE_Shared.logSuccess(`\nHTTP  (-open-) server is listening on port ${this.httpPort}\n`);
+            DynamoNTS_Shared.logSuccess(`\nHTTP  (-open-) server is listening on port ${this.httpPort}\n`);
           })
           .on('error', (error) => {
-            DBE_Shared.logError(`\nHTTP  (-open-) server ERROR`, error);
+            DynamoNTS_Shared.logError(`\nHTTP  (-open-) server ERROR`, error);
           })
           .on('uncaughtException', (ex) => {
-            DBE_Shared.logWarning(`\nHTTP  (-open-) server uncaughtException`, ex);
+            DynamoNTS_Shared.logWarning(`\nHTTP  (-open-) server uncaughtException`, ex);
           });
       }
     } catch (error) {
-      DBE_Shared.logError(`startExpresses failed...`, error);
+      DynamoNTS_Shared.logError(`startExpresses failed...`, error);
     }
   }
 
@@ -235,11 +235,11 @@ export abstract class DynamoBEApp extends DynamoBESingletonService {
    * 
    */
   private mountSecureRoutes (): void {
-    this.routingModules.forEach((module: DynamoBERoutingModule) => {
-      if (module.security !== DynamoBERouteSecurity.open) {
+    this.routingModules.forEach((module: DynamoNTS_RoutingModule) => {
+      if (module.security !== DynamoNTS_RouteSecurity.open) {
         if (this.log) console.log(`route mount (secure): ${module.route}`);
-        const existingRoutes: DynamoBERoutingModule[] = this.routingModules.filter(
-            (mod: DynamoBERoutingModule) => mod.route === module.route);
+        const existingRoutes: DynamoNTS_RoutingModule[] = this.routingModules.filter(
+            (mod: DynamoNTS_RoutingModule) => mod.route === module.route);
         if (1 < existingRoutes.length) {
           let error = new Error(`ROUTE DUPLICATION: ${module.route}`);
           let errorStack: string[] = error.stack.split('\n');
@@ -257,11 +257,11 @@ export abstract class DynamoBEApp extends DynamoBESingletonService {
    * 
    */
   private mountOpenRoutes (): void {
-    this.routingModules.forEach((module: DynamoBERoutingModule) => {
-      if (module.security !== DynamoBERouteSecurity.secure) {
+    this.routingModules.forEach((module: DynamoNTS_RoutingModule) => {
+      if (module.security !== DynamoNTS_RouteSecurity.secure) {
         if (this.log) console.log(`route mount (open): ${module.route}`);
-        const existingRoutes: DynamoBERoutingModule[] = this.routingModules.filter(
-            (mod: DynamoBERoutingModule) => mod.route === module.route);
+        const existingRoutes: DynamoNTS_RoutingModule[] = this.routingModules.filter(
+            (mod: DynamoNTS_RoutingModule) => mod.route === module.route);
         if (1 < existingRoutes.length) {
           let error = new Error(`ROUTE DUPLICATION: ${module.route}`);
           let errorStack: string[] = error.stack.split('\n');
@@ -279,11 +279,11 @@ export abstract class DynamoBEApp extends DynamoBESingletonService {
    * 
    */
   private setSecurity(): void {
-    this.routingModules.forEach((module: DynamoBERoutingModule) => {
+    this.routingModules.forEach((module: DynamoNTS_RoutingModule) => {
       if (!this.security) {
         this.security = module.security;
       } else if (this.security !== module.security) {
-        this.security = DynamoBERouteSecurity.both;
+        this.security = DynamoNTS_RouteSecurity.both;
       }
     });
   }

package/src/_services/{dynamobe-auth.service.ts → dynamo-nts-auth.service.ts}

@@ -1,8 +1,8 @@
 
 import { NextFunction, Request, Response } from 'express';
-import { DynamoBEError } from '@futdevpro/fsm-dynamo';
+import { DynamoNTS_Error } from '@futdevpro/fsm-dynamo';
 
-import { DynamoBESingletonService } from './dynamobe-singleton.service';
+import { DynamoNTS_SingletonService } from './dynamo-nts-singleton.service';
 
 /**
  * Extend this class as an Auth Service implementation
@@ -17,7 +17,7 @@ import { DynamoBESingletonService } from './dynamobe-singleton.service';
  *   }
  *   ...
  */
-export abstract class DynamoBEAuthService extends DynamoBESingletonService {
+export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
 
   /**
    * this function returns the 'authorization' header from the Request,
@@ -29,14 +29,14 @@ export abstract class DynamoBEAuthService extends DynamoBESingletonService {
   static getTokenFromRequest(req: Request): string {
     const authHeader = req.headers['authorization'];
     if (!authHeader) {
-      throw new DynamoBEError({ 
+      throw new DynamoNTS_Error({ 
         message: 'AuthHeader missing!',
         userMessage: `We encountered a BackEnd Auth Error, please contact the responsible development team. errorcode: 007-636-500`, 
       });
     }
     const token = authHeader.split(' ')[1];
     if (!token) {
-      throw new DynamoBEError({ 
+      throw new DynamoNTS_Error({ 
         message: 'Token missing!', 
         userMessage: `We encountered a BackEnd Auth Error, please contact the responsible development team. errorcode: 007-636-501`, 
       });

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

@@ -0,0 +1,28 @@
+
+
+import { DynamoNTS_EndpointParams } from '../_models/dynamo-nts-endpoint-params';
+import { DynamoNTS_Shared } from './dynamo-nts-shared.service';
+import { DynamoNTS_SingletonService } from './dynamo-nts-singleton.service';
+
+/**
+ * 
+ */
+export abstract class DynamoNTS_Controller extends DynamoNTS_SingletonService {
+
+  endpoints: DynamoNTS_EndpointParams[];
+
+  protected constructor(){
+    super();
+    
+    try {
+      this.setupEndpoints();
+    } catch (error) {
+      DynamoNTS_Shared.logError(`DynamoBEController ERROR setup failed:`, error);
+    }
+  }
+
+  /**
+   * You must setup endpoints and required services in this function
+   */
+  abstract setupEndpoints(): void
+}