@futdevpro/nts-dynamo 1.5.40 → 1.5.47

package/package.json

@@ -1,12 +1,19 @@
 {
   "name": "@futdevpro/nts-dynamo",
-  "version": "01.05.40",
+  "version": "01.05.47",
   "description": "Dynamic NodeTS (NodeJS-Typescript), MongoDB Backend System Framework by Future Development Ltd.",
   "scripts": {
-    "build": "npx tsc",
-    "postbuild": "npm publish",
-    "buildtgz": "npx tsc",
-    "postbuildtgz": "npm pack"
+    "build": "npm run inb",
+    "inb": "npm i",
+    "postinb": "npm run pinb",
+    "pinb": "npx tsc",
+    "postpinb": "npm publish",
+    
+    "build-tgz": "npm run inbt",
+    "inbt": "npm i",
+    "postinbt": "npm run pinbt",
+    "pinbt": "npx tsc",
+    "postbpinbt": "npm pack"
   },
   "main": "./lib/index.js",
   "module": "./lib/index.js",
@@ -169,7 +176,7 @@
   },
   "homepage": "https:/futdevpro.hu/projects/dynamo",
   "peerDependencies": {
-    "@futdevpro/fsm-dynamo": "^1.5.24",
+    "@futdevpro/fsm-dynamo": "^1.5.28",
 
     "@types/express": "^4.17.7",
     "@types/geoip-lite": "^1.4.1",
@@ -179,13 +186,16 @@
     "geoip-lite": "^1.4.5",
     "mongoose": "^5.13.14",
     "nodemailer": "^6.7.5",
-    "rxjs": "^7.4.0"
-  },
-  "dependencies": {
+    "rxjs": "^7.4.0",
+
     "@types/node": "~14.0.27",
-    "socket.io": "^4.5.2",
     "ts-node": "~8.10.2",
-    "tslib": "~2.0.1",
-    "typescript": "~3.9.7"
+    "typescript": "~4.8.3"
+  },
+  "peerDevDependencies": {
+    "tslib": "~2.0.1"
+  },
+  "devDependencies": {
+    "socket.io": "^4.5.2"
   }
 }

package/src/_enums/http/socket-event.enum.ts

@@ -2,6 +2,8 @@
 export enum DynamoNTS_SocketEvent {
   connection = 'connection',
   subscribe = 'subscribe',
+  subscriptionSuccessful = 'subscriptionSuccessful',
+  unsubscribe = 'unsubscribe',
   event = 'event',
   disconnect = 'disconnection'
 }

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

@@ -84,7 +84,7 @@ export class DynamoNTS_EndpointParams{
             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 !== {}) {
+              if (i + 1 < this.pathParams.length || req.body && `${req.body}` !== '{}') {
                 inputs += ',';
               }
             }

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

@@ -0,0 +1,39 @@
+
+import { Dynamo_Error } from '@futdevpro/fsm-dynamo';
+import * as SocketIO from 'socket.io';
+
+export class DynamoNTS_SocketDictionary {
+  issuerId: string;
+  sockets: SocketIO.Socket[];
+
+  constructor(
+    set?: {
+      issuerId: string,
+      sockets: SocketIO.Socket[],
+    }
+  ) {
+    this.issuerId = set.issuerId;
+    if (!set.sockets.length) {
+      throw new Dynamo_Error({ 
+        status: 406, 
+        errorCode: 'NTS-SD0-C00',
+        addECToUserMsg: true,
+        message: 'trying to create DynamoNTS_SocketDictionary without a single active socket',
+        userMessage: 'We encountered an unhandled Server Error, please contact the responsible development team.'
+      });
+    }
+    this.sockets = set.sockets;
+  }
+
+  /**
+   * Emits event on all sockets
+   * @param event 
+   * @param content 
+   */
+  emitEvent(event: string, content: any) {
+    this.sockets.forEach((socket: SocketIO.Socket) => {
+      socket.emit(event, content);
+    });
+  }
+}
+

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

@@ -8,6 +8,7 @@ import { DynamoNTS_SocketEvent } from '../_enums/http/socket-event.enum';
  * 
  */
 export class DynamoNTS_SocketEventParams<T>{
+  socketName?: string;
   event: DynamoNTS_SocketEvent | string;
   
   preProcessess?: ((content?: T) => Promise<T>)[];
@@ -18,6 +19,7 @@ export class DynamoNTS_SocketEventParams<T>{
 
   constructor(
     set: {
+      socketName?: string,
       event: DynamoNTS_SocketEvent | string,
 
       preProcessess?: ((content?: T) => Promise<T>)[],
@@ -28,6 +30,7 @@ export class DynamoNTS_SocketEventParams<T>{
     }
   ) {
     try {
+      this.socketName = set.socketName;
       this.event = set.event;
 
       this.preProcessess = set.preProcessess ? set.preProcessess : [];
@@ -47,7 +50,7 @@ export class DynamoNTS_SocketEventParams<T>{
       }
     } catch (error) {
       DynamoNTS_Shared.logError(
-        `\nSocket Event params setup failed: ${set.event}`, error);
+        `\nSocket Event params setup failed (${this.socketName}): ${set.event}`, error);
       throw error;
     }
   }
@@ -61,14 +64,14 @@ export class DynamoNTS_SocketEventParams<T>{
       try {
         if (this.logEvent) {
           if (this.logEventContent) {
-            console.log(`==> incoming ${this.event} socket event... content:`, content);
+            console.log(`==> incoming ${this.socketName} socket event: ${this.event} content:`, content);
           } else {
-            console.log(`==> incoming ${this.event} socket event...`);
+            console.log(`==> incoming ${this.socketName} socket event: ${this.event}...`);
           }
         }
         return content;
       } catch (error) {
-        console.error('PreLog failed....', error);
+        console.error(`PreLog failed... (socket:  ${this.socketName})`, error);
       }
     };
   }
@@ -88,7 +91,7 @@ export class DynamoNTS_SocketEventParams<T>{
           await this.tasks[i](content, issuer);
         }
       } catch (error) {
-        console.error(`Socket Event tasks failed to execute.... (${this.event})`, error, 'content:', content);
+        console.error(`Socket Event tasks failed to execute on ${this.socketName}.... (${this.event})`, error, 'content:', content);
       }
     };
   }

package/src/_models/index.ts

@@ -8,4 +8,5 @@ export * from './dynamo-nts-global-settings';
 export * from './dynamo-nts-routing-module-settings';
 export * from './dynamo-nts-socket-event-params';
 export * from './dynamo-nts-socket-service-params';
+export * from './dynamo-nts-socket-dictionary';
 

package/src/_modules/app-extended.index.ts

@@ -11,6 +11,7 @@ export * from '../_models/dynamo-nts-app-params';
 export * from '../_models/dynamo-nts-endpoint-params';
 export * from '../_models/dynamo-nts-global-settings';
 export * from '../_models/dynamo-nts-routing-module-settings';
+export * from '../_models/dynamo-nts-socket-dictionary';
 
 // ENUMS
 export * from '../_enums/dynamo-nts-route-security.enum';

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

@@ -1,17 +1,17 @@
 
 
 
-import { CustomData, customDataModelParams } from '@futdevpro/fsm-dynamo/test-module';
+import { Dynamo_CustomData, customDataModelParams } from '@futdevpro/fsm-dynamo/test-module';
 import { DynamoNTS_DataService } from '../../_services/dynamo-nts-data.service';
 
-export class CustomDataService extends DynamoNTS_DataService<CustomData> {
+export class Dynamo_CustomDataService extends DynamoNTS_DataService<Dynamo_CustomData> {
 
   constructor(
-    customData?: CustomData,
+    customData?: Dynamo_CustomData,
     issuer?: string,
   ) {
     super(
-      new CustomData(customData),
+      new Dynamo_CustomData(customData),
       customDataModelParams,
       issuer
     );

package/src/_modules/test/test-controller.ts

@@ -4,7 +4,7 @@ import { testModuleSettings } from '@futdevpro/fsm-dynamo/test-module';
 import { HttpCallType } from '../../_enums/http/http-call-type.enum';
 import { DynamoNTS_EndpointParams } from '../../_models/dynamo-nts-endpoint-params';
 import { DynamoNTS_Controller } from '../../_services/dynamo-nts-controller.service';
-import { CustomDataService } from './custom-data.service';
+import { Dynamo_CustomDataService } from './custom-data.service';
 
 export class TestController extends DynamoNTS_Controller {
 
@@ -92,12 +92,12 @@ export class TestController extends DynamoNTS_Controller {
             
             // CUSTOM DATA
             new DynamoNTS_EndpointParams({
-                name: 'getCustomData',
+                name: 'getDynamo_CustomData',
                 type: HttpCallType.get,
-                endpoint: testModuleSettings.endPoints.getCustomData,
+                endpoint: testModuleSettings.endPoints.getDynamo_CustomData,
                 tasks: [ 
                     async (req: Request, res: Response) => {
-                        const customDataService = new CustomDataService({ _id: req.params.customId });
+                        const customDataService = new Dynamo_CustomDataService({ _id: req.params.customId });
             
                         await customDataService.getDataById();
             
@@ -112,12 +112,12 @@ export class TestController extends DynamoNTS_Controller {
             }),
             
             new DynamoNTS_EndpointParams({
-                name: 'modifyCustomData',
+                name: 'modifyDynamo_CustomData',
                 type: HttpCallType.post,
-                endpoint: testModuleSettings.endPoints.modifyCustomData,
+                endpoint: testModuleSettings.endPoints.modifyDynamo_CustomData,
                 tasks: [ 
                     async (req: Request, res: Response, issuer: string) => {
-                        const customDataService = new CustomDataService(req.body, issuer);
+                        const customDataService = new Dynamo_CustomDataService(req.body, issuer);
             
                         await customDataService.saveData();
             

package/src/_modules/usage/usage-controller.ts

@@ -1,6 +1,6 @@
 
 import { Request, Response } from 'express';
-import { usageModuleSettings, DynamoUsageSession } from '@futdevpro/fsm-dynamo/usage-module';
+import { usageModuleSettings, Dynamo_UsageSession } from '@futdevpro/fsm-dynamo/usage-module';
 import { HttpCallType } from '../../_enums/http/http-call-type.enum';
 import { DynamoNTS_EndpointParams } from '../../_models/dynamo-nts-endpoint-params';
 import { DynamoNTS_AuthService } from '../../_services/dynamo-nts-auth.service';
@@ -30,7 +30,7 @@ export class UsageController extends DynamoNTS_Controller {
                         const authService = DynamoNTS_GlobalService.getAuthService();
                         const username = authService.getUsernameFromRequest(req);
                         const usageService = new UsageService({
-                            usageSession: new DynamoUsageSession({ 
+                            usageSession: new Dynamo_UsageSession({ 
                                 sessionStart: new Date(),
                                 issuer: username,
                             }),

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

@@ -1,25 +1,25 @@
 
 import { Request } from 'express';
-import { DynamoNTS_Error } from '@futdevpro/fsm-dynamo';
-import { DynamoUsageSession, usageSessionModelParams, DynamoUsageData, 
-  DailyUsageData } from '@futdevpro/fsm-dynamo/usage-module';
+import { Dynamo_Error } from '@futdevpro/fsm-dynamo';
+import { Dynamo_UsageSession, usageSessionModelParams, Dynamo_UsageData, 
+  Dynamo_DailyUsageData } from '@futdevpro/fsm-dynamo/usage-module';
 
 import { DynamoNTS_DataService } from '../../_services/dynamo-nts-data.service';
 import { DynamoNTS_Shared } from '../../_services/dynamo-nts-shared.service';
 
-export class UsageService extends DynamoNTS_DataService<DynamoUsageSession> {
-  usageData: DynamoUsageData[] = [];
-  simplifiedDailyUsage: DailyUsageData[] = [];
+export class UsageService extends DynamoNTS_DataService<Dynamo_UsageSession> {
+  usageData: Dynamo_UsageData[] = [];
+  simplifiedDailyUsage: Dynamo_DailyUsageData[] = [];
 
   constructor(
     set?: {
-      usageSession?: DynamoUsageSession,
-      usageData?: DynamoUsageData[],
+      usageSession?: Dynamo_UsageSession,
+      usageData?: Dynamo_UsageData[],
       issuer?: string,
     }
   ) {
     super(
-      new DynamoUsageSession(set?.usageSession),
+      new Dynamo_UsageSession(set?.usageSession),
       usageSessionModelParams,
       set?.issuer
     );
@@ -33,8 +33,10 @@ export class UsageService extends DynamoNTS_DataService<DynamoUsageSession> {
 
       /* console.log(`...getLocationDataFromRequest... ip: ${this.data.address}`, this.data.locationData); */
     } catch (error) {
-      throw new DynamoNTS_Error({ 
-        status: 417, message: 'getLocationDataFromRequest was unsuccessful', 
+      throw new Dynamo_Error({ 
+        status: 417, 
+        errorCode: 'NTS-US0-GLD',
+        message: 'getLocationDataFromRequest was unsuccessful', 
         userMessage: `We were unable to deep analyze your request.`,
         error 
       });
@@ -45,18 +47,18 @@ export class UsageService extends DynamoNTS_DataService<DynamoUsageSession> {
     try {
       await this.dataDBService.find({
         sessionStart: { $gte: DynamoNTS_Shared.oneWeekAgo() }
-      }).then((res: DynamoUsageSession[]) => {
+      }).then((res: Dynamo_UsageSession[]) => {
         this.dataList = res;
       });
       this.simplifiedDailyUsage = [];
-      this.dataList.forEach((session: DynamoUsageSession) => {
+      this.dataList.forEach((session: Dynamo_UsageSession) => {
         let dateIndex = this.simplifiedDailyUsage.findIndex(
-          (dailyData: DailyUsageData) => dailyData.date === session.date
+          (dailyData: Dynamo_DailyUsageData) => dailyData.date === session.date
         );
         if (-1 < dateIndex) {
           this.simplifiedDailyUsage[dateIndex].visitations.push(session);
         } else {
-          const newUsageSimple = new DailyUsageData({ date: session.date, visitations: [ session ] });
+          const newUsageSimple = new Dynamo_DailyUsageData({ date: session.date, visitations: [ session ] });
           this.simplifiedDailyUsage.push(newUsageSimple);
           dateIndex = this.simplifiedDailyUsage.length - 1;
         }
@@ -76,17 +78,19 @@ export class UsageService extends DynamoNTS_DataService<DynamoUsageSession> {
       });
 
       this.simplifiedDailyUsage.sort(
-        (a: DailyUsageData, b: DailyUsageData) => +new Date(b.date) - +new Date(a.date)
+        (a: Dynamo_DailyUsageData, b: Dynamo_DailyUsageData) => +new Date(b.date) - +new Date(a.date)
       );
-      this.simplifiedDailyUsage.forEach((daily: DailyUsageData) => {
+      this.simplifiedDailyUsage.forEach((daily: Dynamo_DailyUsageData) => {
         daily.visitations.sort(
-          (a: DynamoUsageSession, b: DynamoUsageSession) => +a.sessionStart - +b.sessionStart
+          (a: Dynamo_UsageSession, b: Dynamo_UsageSession) => +a.sessionStart - +b.sessionStart
         );
       });
 
     } catch (error) {
-      throw new DynamoNTS_Error({ 
-        status: 417, message: 'getDailyUsage was unsuccessful', 
+      throw new Dynamo_Error({ 
+        status: 417, 
+        errorCode: 'NTS-US0-GLW',
+        message: 'getDailyUsage was unsuccessful', 
         userMessage: `We've failed to collect last week's usage data.`,
         error 
       });
@@ -98,7 +102,7 @@ export class UsageService extends DynamoNTS_DataService<DynamoUsageSession> {
       await this.getDataById();
       this.data.usageData = this.usageData;
       let totalTime = 0;
-      this.data.usageData.forEach((data: DynamoUsageData) => {
+      this.data.usageData.forEach((data: Dynamo_UsageData) => {
         totalTime += data.timeSpentOnPage;
       });
       if (!this.data.locationData) {
@@ -107,8 +111,10 @@ export class UsageService extends DynamoNTS_DataService<DynamoUsageSession> {
       this.data.totalSessionTime = totalTime;
       await this.saveData();
     } catch (error) {
-      throw new DynamoNTS_Error({ 
-        status: 417, message: 'updateSessionData was unsuccessful', 
+      throw new Dynamo_Error({ 
+        status: 417, 
+        errorCode: 'NTS-US0-UU0',
+        message: 'updateSessionData was unsuccessful', 
         userMessage: `The attempt to update Usage Data was unsuccessful.`,
         error 
       });
@@ -124,12 +130,14 @@ export class UsageService extends DynamoNTS_DataService<DynamoUsageSession> {
       if (!this.data.locationData) {
         this.getLocationDataFromRequest(req);
       }
-      this.data.usageData.sort((a: DynamoUsageData, b: DynamoUsageData) => +a.opened - +b.opened);
+      this.data.usageData.sort((a: Dynamo_UsageData, b: Dynamo_UsageData) => +a.opened - +b.opened);
       this.data.totalSessionTime = newTotalSessionTime;
       await this.saveData();
     } catch (error) {
-      throw new DynamoNTS_Error({ 
-        status: 417, message: 'closeSession was unsuccessful', 
+      throw new Dynamo_Error({ 
+        status: 417, 
+        errorCode: 'NTS-US0-CS0',
+        message: 'closeSession was unsuccessful', 
         userMessage: `The attempt to close Usage Session was unsuccessful.`,
         error 
       });

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

@@ -1,6 +1,6 @@
 
 import * as Axios from 'axios';
-import { DynamoNTS_Error } from '@futdevpro/fsm-dynamo';
+import { Dynamo_Error } from '@futdevpro/fsm-dynamo';
 
 import { HttpCallType } from '../_enums/http/http-call-type.enum';
 import { HttpResponseType } from '../_enums/http/http-response-type.enum';
@@ -138,29 +138,46 @@ export class DynamoNTS_ApiService {
             return a as T;
         }
     } catch (error) {
-        DynamoNTS_Shared.logError(`\nAPI ERRROR: ${callParams?.name} failed...` +
+        DynamoNTS_Shared.logError(`\nAPI ERROR: ${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') {
+        
+        if (error?.response?.data?.flag === 'DYNAMO ERROR OBJECT') {
             DynamoNTS_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
-            throw new DynamoNTS_Error(error.response.data);
+
+            throw new Dynamo_Error({
+                errorCode: 'NTS-API-002',
+                addECToUserMsg: true,
+                message: 'API call failed on the other end! error response found...', 
+                userMessage: `We encountered a BackEnd API Error, please contact the responsible development team.`, 
+                error: error.response.data
+            });
         } else if (error.code === 'ENOTFOUND') {
             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`, 
+
+            throw new Dynamo_Error({ 
+                status: 404, 
+                errorCode: 'NTS-API-000',
+                addECToUserMsg: true,
+                message: 'DNS error; address cannot be resolved!', 
+                userMessage: `We encountered a BackEnd API Error, please contact the responsible development team.`, 
                 error: error 
             });
         } else if (error.config && error.message) {
-            throw new DynamoNTS_Error({ 
+
+            throw new Dynamo_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`, 
+                errorCode: 'NTS-API-003',
+                addECToUserMsg: true,
+                userMessage: `We encountered a BackEnd API Error, please contact the responsible development team.`, 
                 error: error 
             });
         } else {
             DynamoNTS_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL`, error, '\n\n', new Error());
+
             throw error;
         }
     }

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

@@ -32,7 +32,7 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
 
   private socketSecurity: DynamoNTS_RouteSecurity;
   
-  protected socketServices: DynamoNTS_SocketService[] = [];
+  protected socketServices: DynamoNTS_SocketService<any>[];
 
   constructor(){
     super();
@@ -47,11 +47,11 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
       } else {
         DynamoNTS_Shared.logWarning(
           '\nNo socketServices setted up while using Extended Application.',
-          '\nYou should use DynamoNTS_App if you don`t need socket services.' 
+          '\nYou should use DynamoNTS_App if you don`t need socket services.\n' 
         );
       }
     } catch (error) {
-      DynamoNTS_Shared.logError('\nExtended Application start failed.\n', error);
+      DynamoNTS_Shared.logError('\nExtended Application start failed.\n', error, '\n');
     }
   }
 
@@ -59,8 +59,7 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
    * 
    */
   private setSocketSecurity(): void {
-    console.log('setSecurityExtended');
-    this.socketServices.forEach((service: DynamoNTS_SocketService) => {
+    this.socketServices.forEach((service: DynamoNTS_SocketService<any>) => {
       if (!this.socketSecurity) {
         this.socketSecurity = DynamoNTS_RouteSecurity[service.security];
       } else if (this.socketSecurity !== DynamoNTS_RouteSecurity.both && this.socketSecurity !== DynamoNTS_RouteSecurity[service.security]) {
@@ -95,7 +94,7 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
             `\nin DynamoBEServer - setupRoutingModules() to enable secure routes.`;
             
           errorMsg += '\n\nThe socket services setted to use secure server:';
-          this.socketServices.forEach((service: DynamoNTS_SocketService) => {
+          this.socketServices.forEach((service: DynamoNTS_SocketService<any>) => {
             if (service.security != DynamoNTS_SocketSecurity.open) {
               errorMsg += `\n  ${service.name} (port: ${service.port})`;
             }
@@ -112,9 +111,10 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
       }
     }
 
-    this.socketServices.forEach((service: DynamoNTS_SocketService) => {
-      const existingPorts: DynamoNTS_SocketService[] = this.socketServices.filter(
-          (mod: DynamoNTS_SocketService) => mod.port === service.port);
+    this.socketServices.forEach((service: DynamoNTS_SocketService<any>) => {
+      const existingPorts: DynamoNTS_SocketService<any>[] = this.socketServices.filter(
+        (mod: DynamoNTS_SocketService<any>) => mod.port === service.port
+      );
 
       if (1 < existingPorts.length || this.httpPort === service.port || this.httpsPort === service.port) {
         let error = new Error(`PORT DUPLICATION: ${service.port}`);

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

@@ -92,10 +92,10 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
     this.mongoose.connect(
         this.params.dbUri, 
-        /* {
+        {
           useNewUrlParser: true,
           useUnifiedTopology: true 
-        } */
+        }
     );
   }
 

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

@@ -1,6 +1,6 @@
 
 import { NextFunction, Request, Response } from 'express';
-import { DynamoNTS_Error } from '@futdevpro/fsm-dynamo';
+import { Dynamo_Error } from '@futdevpro/fsm-dynamo';
 
 import { DynamoNTS_SingletonService } from './dynamo-nts-singleton.service';
 
@@ -29,18 +29,26 @@ export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
   static getTokenFromRequest(req: Request): string {
     const authHeader = req.headers['authorization'];
     if (!authHeader) {
-      throw new DynamoNTS_Error({ 
+      throw new Dynamo_Error({ 
+        status: 401,
+        errorCode: 'NTS-AS0-GT0',
+        addECToUserMsg: true,
         message: 'AuthHeader missing!',
-        userMessage: `We encountered a BackEnd Auth Error, please contact the responsible development team. errorcode: 007-636-500`, 
+        userMessage: `We encountered an unhandled BackEnd Auth Error, please contact the responsible development team.`, 
       });
     }
+
     const token = authHeader.split(' ')[1];
     if (!token) {
-      throw new DynamoNTS_Error({ 
+      throw new Dynamo_Error({ 
+        status: 401,
+        errorCode: 'NTS-AS0-GT1',
+        addECToUserMsg: true,
         message: 'Token missing!', 
-        userMessage: `We encountered a BackEnd Auth Error, please contact the responsible development team. errorcode: 007-636-501`, 
+        userMessage: `We encountered an unhandled BackEnd Auth Error, please contact the responsible development team.`, 
       });
     }
+
     return token;
   }
   

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

@@ -5,7 +5,44 @@ import { DynamoNTS_Shared } from './dynamo-nts-shared.service';
 import { DynamoNTS_SingletonService } from './dynamo-nts-singleton.service';
 
 /**
+ * Basic controller for endpoint handlings
  * 
+ * @example
+ * export class UserMatchStatisticsController extends DynamoNTS_Controller {
+ *
+ * static getInstance(): UserMatchStatisticsController {
+ *   return UserMatchStatisticsController.getSingletonInstance();
+ * }
+ *
+ *   // SERVICES
+ *   private authService: AuthService;
+ *
+ *   setupEndpoints(): void {
+ *     this.authService = AuthService.getInstance();
+ *
+ *     this.endpoints = [
+ *       new DynamoNTS_EndpointParams({
+ *         name: 'getUserMatchStatistics',
+ *         type: HttpCallType.get,
+ *         endpoint: '/get/user-match-statistics/:userId',
+ *         preProcessess: [ this.authService.authenticateTokenSelf ],
+ *         tasks: [ 
+ *           async (req: Request, res: Response) => {
+ *             const userMatchStatistics = new UserMatchStatisticsService({ 
+ *               data: { userId: req.params.userId }
+ *             });
+ * 
+ *             await userMatchStatistics.getDataByDependencyId();
+ *             
+ *             res.send(
+ *               userMatchStatistics.data
+ *             );
+ *           }
+ *         ]
+ *       }),
+ *     ];
+ *   }
+ * }
  */
 export abstract class DynamoNTS_Controller extends DynamoNTS_SingletonService {