@futdevpro/nts-dynamo 1.3.58 → 1.3.60

package/package.json

@@ -1,46 +1,46 @@
 {
   "name": "@futdevpro/nts-dynamo",
-  "version": "01.03.58",
+  "version": "01.03.60",
   "description": "Dynamic NodeTS (NodeJS-Typescript), MongoDB Backend System Framework by Future Development Ltd.",
-  "main": "./lib/index.js",
-  "module": "./lib/index.js",
-  "types": "./lib/index.d.ts",
-  "typings": "./lib/index.d.ts",
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "types": "./src/index.ts",
+  "typings": "./src/index.ts",
   "exports": {
     ".": {
-      "default": "./lib/index.js",
-      "types": "./lib/index.d.ts"
+      "default": "./src/index.ts",
+      "types": "./src/index.ts"
     },
     "./enums": {
-      "default": "./lib/_enums/index.js",
-      "types": "./lib/_enums/index.d.ts"
+      "default": "./src/_enums/index.ts",
+      "types": "./src/_enums/index.ts"
     },
     "./models": {
-      "default": "./lib/_models/index.js",
-      "types": "./lib/_models/index.d.ts"
+      "default": "./src/_models/index.ts",
+      "types": "./src/_models/index.ts"
     },
     "./modules": {
-      "default": "./lib/_modules/index.js",
-      "types": "./lib/_modules/index.d.ts"
+      "default": "./src/_modules/index.ts",
+      "types": "./src/_modules/index.ts"
     },
     "./services": {
-      "default": "./lib/_services/index.js",
-      "types": "./lib/_services/index.d.ts"
+      "default": "./src/_services/index.ts",
+      "types": "./src/_services/index.ts"
     }
   },
   "typesVersions": {
     "*": {
       "enums": [
-        "lib/_enums/index.d.ts"
+        "src/_enums/index.ts"
       ],
       "models": [
-        "lib/_models/index.d.ts"
+        "src/_models/index.ts"
       ],
       "modules": [
-        "lib/_modules/index.d.ts"
+        "src/_modules/index.ts"
       ],
       "services": [
-        "lib/_services/index.d.ts"
+        "src/_services/index.ts"
       ]
     }
   },

package/src/_models/dynamobe-endpoint-control.ts

@@ -63,27 +63,31 @@ export class DynamoBEEndpointParams{
 
   getPreLog(): (req: Request, res: Response, next: NextFunction) => Promise<void> {
     return async (req: Request, res: Response, next: NextFunction) => {
-      if (this.logRequest) {
-        if (this.logRequestsContent) {
-          let inputs = '';
-          for(let i = 0; i < this.pathParams.length; i++) {
-            inputs += ` ${this.pathParams[i]}: ${req.params[this.pathParams[i]]}`;
-            if (i + 1 < this.pathParams.length || req.body && req.body !== {}) {
-              inputs += ',';
+      try {
+        if (this.logRequest) {
+          if (this.logRequestsContent) {
+            let inputs = '';
+            for(let i = 0; i < this.pathParams.length; i++) {
+              inputs += ` ${this.pathParams[i]}: ${req.params[this.pathParams[i]]}`;
+              if (i + 1 < this.pathParams.length || req.body && req.body !== {}) {
+                inputs += ',';
+              }
             }
-          }
 
-          if (req.body && 0 < Object.keys(req.body).length) {
-            console.log(`==> incoming ${this.name} request...${inputs} body:`, req.body);
+            if (req.body && 0 < Object.keys(req.body).length) {
+              console.log(`==> incoming ${this.name} request...${inputs} body:`, req.body);
+            } else {
+              console.log(`==> incoming ${this.name} request...${inputs}`);
+            }
           } else {
-            console.log(`==> incoming ${this.name} request...${inputs}`);
+            console.log(`==> incoming ${this.name} request...`);
           }
-        } else {
-          console.log(`==> incoming ${this.name} request...`);
         }
-      }
 
-      next();
+        next();
+      } catch (error) {
+        this.error(res, error);
+      }
     };
   }
 
@@ -92,9 +96,10 @@ export class DynamoBEEndpointParams{
       try {  
         const issuer: string = DBE_Global_S.getAuthService().getAccountIdFromRequest(req);
   
-        await this.tasks.forEach(async (task: (req: Request, res: Response, issuer?: string) => Promise<void>) => {
-          await task(req, res, issuer);
-        });
+        console.log(`A ${this.name} ${this.tasks.length}`);
+        for (let i = 0; i < this.tasks.length; i++) {
+          await this.tasks[i](req, res, issuer);
+        }
   
         if (this.logRequest) {
           if (this.logResponseContent) {
@@ -105,21 +110,25 @@ export class DynamoBEEndpointParams{
           }
         }
       } catch (error) {
-        DBE_Shared.logError(`${this.name} ERROR`, error, '\n');
-        res.status(error.status ? error.status : 501);
-        res.send(error);
-  
-        if (this.logRequest) {
-          if (this.logResponseContent) {
-            DBE_Shared.logError(`  <<<=====   ${this.name} error sent.`);
-            DBE_Shared.logError('sorry, the logResponseContent is not implemented yet.');
-          } else {
-            DBE_Shared.logError(`  <<<=====   ${this.name} error sent.`);
-          }
-        }
+        this.error(res, error);
       }
     };
   }
+
+  error(res: Response, error): void {
+    DBE_Shared.logError(`${this.name} ERROR`, error, '\n');
+    res.status(error.status ? error.status : 501);
+    res.send(error);
+
+    if (this.logRequest) {
+      if (this.logResponseContent) {
+        DBE_Shared.logError(`  <<<=====   ${this.name} error sent.`);
+        DBE_Shared.logError('sorry, the logResponseContent is not implemented yet.');
+      } else {
+        DBE_Shared.logError(`  <<<=====   ${this.name} error sent.`);
+      }
+    }
+  }
 }
 
 

package/src/_models/fullstack-models/control-models/dynamobe-data-params.ts

@@ -0,0 +1,19 @@
+
+import { DynamoBEDataPropertyParams } from './dynamobe-data-property-params';
+
+export class DynamoBEDataParams {
+  dataName: string;
+  dbName: string;
+  modelParams: DynamoBEDataPropertyParams[];
+
+  constructor(
+    set: {
+      dataName: string,
+      modelParams: DynamoBEDataPropertyParams[],
+    }
+  ) {
+    this.dataName = set.dataName;
+    this.dbName = set.dataName.charAt(0).toUpperCase() + set.dataName.slice(1);
+    this.modelParams = set.modelParams ? set.modelParams : [];
+  }
+}

package/src/_models/fullstack-models/control-models/dynamobe-data-property-params.ts

@@ -10,7 +10,7 @@ export class DynamoBEDataPropertyParams {
   index?: boolean;
 
   isDependencyHook?: boolean;
-  dependencyDBServiceName?: string;
+  dependencyName?: string;
 
   minlength?: number;
   maxlength?: number;
@@ -56,7 +56,7 @@ export class DynamoBEDataPropertyParams {
       if (set.isDependencyHook) {
         if (set.dependencyDBServiceName) {
           this.isDependencyHook = set.isDependencyHook;
-          this.dependencyDBServiceName = set.dependencyDBServiceName;
+          this.dependencyName = set.dependencyDBServiceName;
         } else {
           this.isDependencyHook = set.isDependencyHook;
           console.log('DYNAMO ERROR: \n dependencyDBServiceName missing for dependencyHook', '\n\n', new Error());

package/src/_models/fullstack-models/data-models/custom-data.ts

@@ -1,5 +1,5 @@
 
-import { DynamoBEDataPropertyParams } from '../control-models/dynamobe-data-property-params';
+import { DynamoBEDataParams } from '../control-models/dynamobe-data-params';
 import { Metadata } from './metadata';
 
 export class CustomData extends Metadata {
@@ -32,6 +32,10 @@ export class CustomData extends Metadata {
   }
 }
 
-export const customDataModelParams: DynamoBEDataPropertyParams[] = [
-  { key: 'data', type: 'string', required: true },
-];
+export const customDataModelParams = new DynamoBEDataParams({
+  dataName: 'customData',
+  modelParams: [
+    { key: 'data', type: 'string', required: true },
+  ]
+})
+

package/src/_models/fullstack-models/data-models/usage-session.ts

@@ -1,8 +1,8 @@
 
-import { DynamoBEDataPropertyParams } from '../control-models/dynamobe-data-property-params';
 import { GeoIpLocation } from '../control-models/geo-ip-location';
 import { Metadata } from './metadata';
 import { DynamoUsageData } from '../control-models/usage-data';
+import { DynamoBEDataParams } from '../control-models/dynamobe-data-params';
 
 export class DynamoUsageSession extends Metadata {
   date?: string;
@@ -65,18 +65,21 @@ export class DynamoUsageSession extends Metadata {
   }
 }
 
-export const usageSessionModelParams: DynamoBEDataPropertyParams[] = [
-  { key: 'date', type: 'string',
-    required: true, index: true
-  },
-  { key: 'sessionStart', type: 'Date',
-    required: true, index: true
-  },
-  { key: 'sessionEnd', type: 'Date' },
-  { key: 'address', type: 'string' },
-  { key: 'issuer', type: 'string' },
-  { key: 'locationData', type: 'IpApiLocation' },
-  { key: 'usageData', type: 'UsageData[]' },
-  { key: 'totalSessionTime', type: 'number' },
-  { key: 'loggedInAs', type: 'string' },
-];
+export const usageSessionModelParams = new DynamoBEDataParams({
+  dataName: 'usageSession',
+  modelParams: [
+    { key: 'date', type: 'string',
+      required: true, index: true
+    },
+    { key: 'sessionStart', type: 'Date',
+      required: true, index: true
+    },
+    { key: 'sessionEnd', type: 'Date' },
+    { key: 'address', type: 'string' },
+    { key: 'issuer', type: 'string' },
+    { key: 'locationData', type: 'IpApiLocation' },
+    { key: 'usageData', type: 'UsageData[]' },
+    { key: 'totalSessionTime', type: 'number' },
+    { key: 'loggedInAs', type: 'string' },
+  ]
+})

package/src/_models/index.ts

@@ -13,6 +13,7 @@ export * from './fullstack-models/control-models/dynamobe-error';
 export * from './fullstack-models/control-models/geo-ip-location';
 export * from './fullstack-models/control-models/usage-action';
 export * from './fullstack-models/control-models/usage-data';
+export * from './fullstack-models/control-models/dynamobe-data-params';
   // FULLSTACK - DATA MODELS
 export * from './fullstack-models/data-models/custom-data';
 export * from './fullstack-models/data-models/metadata';

package/src/_modules/test-route/custom-data.service.ts

@@ -3,7 +3,6 @@
 
 import { CustomData, customDataModelParams } from '../../_models/fullstack-models/data-models/custom-data';
 import { DynamoBEDataService } from '../../_services/dynamobe-data.service';
-import { DBE_Global_S } from '../../_services/dynamobe-global.service';
 
 export class CustomDataService extends DynamoBEDataService<CustomData> {
 
@@ -12,7 +11,6 @@ export class CustomDataService extends DynamoBEDataService<CustomData> {
     issuer?: string,
   ) {
     super(
-      DBE_Global_S.getDBServiceCollection().customDataDBService, 
       new CustomData(customData),
       customDataModelParams,
       issuer

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

@@ -6,7 +6,6 @@ import { Request } from 'express';
 import { DynamoUsageData } from '../../_models/fullstack-models/control-models/usage-data';
 import { DailyUsageData } from '../../_models/fullstack-models/control-models/daily-usage-data';
 import { DynamoUsageSession, usageSessionModelParams } from '../../_models/fullstack-models/data-models/usage-session';
-import { DBE_Global_S } from '../../_services/dynamobe-global.service';
 
 export class UsageService extends DynamoBEDataService<DynamoUsageSession> {
   usageData: DynamoUsageData[] = [];
@@ -20,12 +19,10 @@ export class UsageService extends DynamoBEDataService<DynamoUsageSession> {
     }
   ) {
     super(
-      DBE_Global_S.getDBServiceCollection().usageDataDBService,
       new DynamoUsageSession(set?.usageSession),
       usageSessionModelParams,
       set?.issuer
     );
-
     this.usageData = set?.usageData ? set?.usageData : [];
   }
 

package/src/_services/dynamobe-app.ts

@@ -1,16 +1,51 @@
 
 import { DynamoBEAppParams } from '../_models/dynamobe-app-params';
 /* import * as Mongoose from 'mongoose'; */
+/* import * as Express from 'express'; */
 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 { DynamoBERountingModule } from './dynamobe-routing-module.service';
+import { DBE_Global_S } from './dynamobe-global.service';
+import { DynamoBEEndpointParams } from '../_models/dynamobe-endpoint-control';
 
+/**
+ * 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 DynamoBEApp extends DynamoBESingletonService {
 
   protected params: DynamoBEAppParams;
   
   protected mongoose = Mongoose;
 
+  protected security: DynamoBERouteSecurity;
+
+  protected httpPort?: number;
+  protected httpsPort?: number;
+
+  protected cert?: {
+    keyPath: FileSystem.PathLike,
+    certPath: FileSystem.PathLike,
+  };
+
+  private secureExpress: Express.Application;
+  private httpsServer: Https.Server;
+  private openExpress: Express.Application;
+
+  protected routingModules: DynamoBERountingModule[];
+
+  protected log: boolean;
+
   constructor(){
     super();
 
@@ -22,6 +57,22 @@ export abstract class DynamoBEApp extends DynamoBESingletonService {
       this.startDB();
 
       this.setGlobalServiceCollection();
+      this.log = DBE_Global_S.getGlobalSettings().logSetup;
+
+      this.setupRoutingModules();
+      this.setSecurity();
+          
+      this.initExpresses();
+      this.startExpresses();
+
+      if (this.security !== DynamoBERouteSecurity.secure) {
+        this.mountOpenRoutes();
+      }
+      if (this.security !== DynamoBERouteSecurity.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);
     }
@@ -45,6 +96,235 @@ export abstract class DynamoBEApp extends DynamoBESingletonService {
     );
   }
 
+  private initExpresses() {
+    if (this.security !== DynamoBERouteSecurity.secure) {
+      if (!this.httpPort) {
+        let errorMsg: string =
+          `You have open routes, but httpPort is not set!` +
+          `\nsecurity: ${this.security}` +
+          `\nset httpPort in DynamoBEServer - setupRoutingModules() to enable secure routes.`;
+        
+        errorMsg += '\n\nThe routes setted to use open server:';
+        this.routingModules.forEach((module: DynamoBERountingModule) => {
+          if (module.security != DynamoBERouteSecurity.secure) {
+            errorMsg += `\n  ${module.route} (security: ${module.security}) \n  subroutes using open sever:`;
+            module.endpoints.forEach((endpoint: DynamoBEEndpointParams) => {
+              if (endpoint.security != DynamoBERouteSecurity.secure) {
+                errorMsg += `\n    ${endpoint.endpoint} (security: ${endpoint.security})`;
+              }
+            });
+          }
+        });
+        DBE_Shared.logError(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');
+
+        throw error;
+      }
+
+      this.initOpenExpress();
+    }
+
+    if (this.security !== DynamoBERouteSecurity.open) {
+      if (!this.cert || !this.httpsPort) {
+        let errorMsg: string =
+          `You have secure routes, but the certification paths or httpsPort are not set!` +
+          `\nsecurity: ${this.security}` +
+          `\nset...` +
+          `\n  httpsPort and` +
+          `\n  cert: {` +
+          `\n    keyPath: FileSystem.PathLike,` +
+          `\n    certPath: FileSystem.PathLike,` +
+          `\n  }` +
+          `\nin DynamoBEServer - setupRoutingModules() to enable secure routes.`;
+        
+        errorMsg += '\n\nThe routes setted to use secure server:';
+        this.routingModules.forEach((module: DynamoBERountingModule) => {
+          if (module.security != DynamoBERouteSecurity.open) {
+            errorMsg += `\n  ${module.route} (security: ${module.security}) \n  subroutes using secure sever:`;
+            module.endpoints.forEach((endpoint: DynamoBEEndpointParams) => {
+              if (endpoint.security != DynamoBERouteSecurity.open) {
+                errorMsg += `\n    ${endpoint.endpoint} (security: ${endpoint.security})`;
+              }
+            });
+          }
+        });
+        DBE_Shared.logError(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');
+
+        throw error;
+      }
+
+      this.initSecureExpress();
+    }
+  }
+
+  private initOpenExpress(): void {
+    this.openExpress = Express();    
+    this.openExpress.use(BodyParser.urlencoded({ limit: '50mb', extended: true }));
+    this.openExpress.use(BodyParser.json({ limit: '50mb' }));
+  }
+
+  private initSecureExpress(): void {
+    this.secureExpress = Express();    
+    this.secureExpress.use(BodyParser.urlencoded({ limit: '50mb', extended: true }));
+    this.secureExpress.use(BodyParser.json({ limit: '50mb' }));
+
+    const options = {
+      key: FileSystem.readFileSync(this.cert.keyPath),
+      cert: FileSystem.readFileSync(this.cert.certPath),
+    };
+    this.httpsServer = Https.createServer(options, this.secureExpress);
+  }
+
+  private async startExpresses(): Promise<void> {
+    if (this.security !== DynamoBERouteSecurity.open) {
+      this.httpsServer
+        .listen(this.httpsPort, 'localhost', 0, () => {
+          DBE_Shared.logSuccess(`\nHTTPS (secure) server is listening on port ${this.httpsPort}\n`);
+        })
+        .on('error', (error) => {
+          DBE_Shared.logError(`https (secure) server ERROR`, error);
+        })
+        .on('uncaughtException', (ex) => {
+          DBE_Shared.logWarning(`https (secure) server uncaughtException`, ex);
+        });
+    }
+
+    if (this.security !== DynamoBERouteSecurity.secure) {
+      this.openExpress
+        .listen(this.httpPort, () => {
+          DBE_Shared.logSuccess(`\nHTTP  (-open-) server is listening on port ${this.httpPort}\n`);
+        })
+        .on('error', (error) => {
+          DBE_Shared.logError(`http  (-open-) server ERROR`, error);
+        })
+        .on('uncaughtException', (ex) => {
+          DBE_Shared.logWarning(`http  (-open-) server uncaughtException`, ex);
+        });
+    }
+  }
+
+  private mountSecureRoutes (): void {
+    this.routingModules.forEach((module: DynamoBERountingModule) => {
+      if (module.security !== DynamoBERouteSecurity.open) {
+        if (this.log) console.log(`route mount (secure): ${module.route}`);
+        const existingRoutes: DynamoBERountingModule[] = this.routingModules.filter(
+            (mod: DynamoBERountingModule) => mod.route === module.route);
+        if (1 < existingRoutes.length) {
+          let error = new Error(`ROUTE DUPLICATION: ${module.route}`);
+          let errorStack: string[] = error.stack.split('\n');
+          errorStack.splice(1, 4);
+          error.stack = errorStack.join('\n');
+  
+          throw error;
+        }
+        this.secureExpress.use(module.route, module.secureRouter);
+      }
+    });
+  }
+
+  private mountOpenRoutes (): void {
+    this.routingModules.forEach((module: DynamoBERountingModule) => {
+      if (module.security !== DynamoBERouteSecurity.secure) {
+        if (this.log) console.log(`route mount (open): ${module.route}`);
+        const existingRoutes: DynamoBERountingModule[] = this.routingModules.filter(
+            (mod: DynamoBERountingModule) => mod.route === module.route);
+        if (1 < existingRoutes.length) {
+          let error = new Error(`ROUTE DUPLICATION: ${module.route}`);
+          let errorStack: string[] = error.stack.split('\n');
+          errorStack.splice(1, 4);
+          error.stack = errorStack.join('\n');
+  
+          throw error;
+        }
+        this.openExpress.use(module.route, module.openRouter);
+      }
+    });
+  }
+
+  private setSecurity(): void {
+    this.routingModules.forEach((module: DynamoBERountingModule) => {
+      if (!this.security) {
+        this.security = module.security;
+      } else if (this.security !== module.security) {
+        this.security = DynamoBERouteSecurity.both;
+      }
+    });
+  }
+
+  /**
+   * You must setup app params in this function like this:
+   * 
+   * @example
+   * this.params = new DynamoBEAppParams({
+   *  name: 'Sample Server',
+   *  title: 'A BIG nice header that will be logged on start',
+   *  version: version,
+   *  dbName: 'sampleapp',
+   * });
+   */
   abstract setupAppParams(): void;
+
+  /**
+   * You must setup globalServiceCollection and dbServices in this function
+   * 
+   * @example
+   * DBE_Global_S.setServices({
+   *   authService: AuthService.getInstance(),
+   *   emailServiceCollection: EmailServiceCollectionService.getInstance(),
+   *   dbModels: [
+   *     accountModelParams,
+   *     projectModelParams,
+   *     ...
+   *   ]
+   * });
+   *
+   * DBE_Global_S.setGlobalSettings({
+   *   defaultRouteSecurity: DynamoBERouteSecurity.secure,
+   *   logSetup: true,
+   * });
+   * 
+   */
   abstract setGlobalServiceCollection(): void;
+
+  /**
+   * You must setup endpoints and required services in this function
+   * 
+   * @example
+   * this.httpPort = env.httpPort;
+   * this.httpsPort = env.httpsPort;
+
+   * this.cert = {
+   *   keyPath: Path.join(__dirname, './_assets/cert/ucc.key'),
+   *   certPath: Path.join(__dirname, './_assets/cert/ucc.crt'),
+   * };
+
+   * this.routingModules = [
+   *   new DynamoBERountingModule({
+   *     route: '/api/account',
+   *     controllers: [
+   *       AccountController.getInstance(),
+   *       PersonalInformationController.getInstance(),
+   *       ...
+   *     ]
+   *   }),
+   *   new DynamoBERountingModule({
+   *     route: '/api/project',
+   *     controllers: [ 
+   *       ProjectController.getInstance(),
+   *       ProjectExtensionController.getInstance(),
+   *     ]
+   *   }),
+   *   ...
+   * ];
+   */
+  abstract setupRoutingModules(): void;
 }

package/src/_services/dynamobe-auth.service.ts

@@ -3,11 +3,26 @@ import { NextFunction, Request, Response } from 'express';
 import { DynamoBEError } from '../_models/fullstack-models/control-models/dynamobe-error';
 import { DynamoBESingletonService } from './dynamobe-singleton.service';
 
+/**
+ * Extend this class as an Auth Service implementation
+ * 
+ * You should use singleton instance getting function by implementing a
+ * static getInstance() function
+ * @example
+ * export class AuthService extends DynamoBEAuthService {
+ *
+ *   static getInstance(): AuthService {
+ *     return AuthService.getSingletonInstance();
+ *   }
+ *   ...
+ */
 export abstract class DynamoBEAuthService extends DynamoBESingletonService {
 
   /**
+   * this function returns the 'authorization' header from the Request,
+   * or throws error, if its missing
    * 
-   * @param req 
+   * @param req
    * @returns 
    */
   static getTokenFromRequest(req: Request): string {

package/src/_services/dynamobe-controller.service.ts

@@ -1,6 +1,7 @@
 
 
 import { DynamoBEEndpointParams } from '../_models/dynamobe-endpoint-control';
+import { DBE_Shared } from './dynamobe-shared.service';
 import { DynamoBESingletonService } from './dynamobe-singleton.service';
 
 export abstract class DynamoBEController extends DynamoBESingletonService {
@@ -10,7 +11,11 @@ export abstract class DynamoBEController extends DynamoBESingletonService {
   protected constructor(){
     super();
     
-    this.setupEndpoints();
+    try {
+      this.setupEndpoints();
+    } catch (error) {
+      DBE_Shared.logError(`DynamoBEController ERROR setup failed:`, error);
+    }
   }
 
   /**