@futdevpro/nts-dynamo 1.6.27 → 1.6.29

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

@@ -19,6 +19,7 @@ import { SocketClient_Mock } from './socket-client.mock';
 import { dependency_mock_DataParams, dependent_mock_DataParams } from './data-model.mock';
 import { dynamo_error_default } from '@futdevpro/fsm-dynamo';
 import { EmailServiceCollection_Mock } from './email-service-collection.mock';
+import { getCustomDataRoutingModule } from '../../_modules/custom-data';
 
 /**
  * 
@@ -104,6 +105,7 @@ export class DynamoNTS_AppExtendedFull_Mock extends DynamoNTS_AppExtended {
       }),
 
       getTestRoutingModule(),
+      getCustomDataRoutingModule(),
       getUsageRoutingModule(),
     ];
   }
@@ -173,6 +175,7 @@ export class DynamoNTS_AppWbMock_Mock extends DynamoNTS_AppExtended {
       }),
 
       getTestRoutingModule(),
+      getCustomDataRoutingModule(),
       getUsageRoutingModule(),
     ];
   }

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

@@ -15,6 +15,7 @@ import { DynamoNTS_Controller_Mock } from './controller.mock';
 import { AuthService_Mock } from './auth-service.mock';
 import { dynamoNTS_globalSettings } from '../global-settings.const';
 import { dependency_mock_DataParams, dependent_mock_DataParams } from './data-model.mock';
+import { getCustomDataRoutingModule } from '../../_modules/custom-data';
 
 /**
  * 
@@ -95,6 +96,7 @@ export class DynamoNTS_AppFull_Mock extends DynamoNTS_App {
       }),
 
       getTestRoutingModule(),
+      getCustomDataRoutingModule(),
       getUsageRoutingModule(),
     ];
   }

package/src/_constants/mocks/auth-service.mock.ts

@@ -10,13 +10,11 @@ export class AuthService_Mock extends DynamoNTS_AuthService {
     return AuthService_Mock.getSingletonInstance();
   }
 
-  async authenticateToken(req: Request, res: Response, next: NextFunction): Promise<void> {
-    next();
-  }
+  async authenticateToken(req: Request, res: Response): Promise<void> {}
 
-  async authenticateTokenSelf(req: Request, res: Response, next: NextFunction): Promise<void> {
-    next();
-  }
+  async authenticateTokenSelf(req: Request, res: Response): Promise<void> {}
+  
+  async authTokenPermAccUsageData(req: Request, res: Response): Promise<void> {}
 
   getAccountIdFromRequest(req: Request): string {
     return 'accountId_mock';
@@ -26,9 +24,5 @@ export class AuthService_Mock extends DynamoNTS_AuthService {
     return 'username_mock';
   }
   
-  async authTokenPermAccUsageData(req: Request, res: Response, next: NextFunction): Promise<void> {
-    next();
-  }
-
 }
 

package/src/_models/control-models/endpoint-params.control-model.ts

@@ -2,7 +2,7 @@
 
 import { NextFunction, Request, Response } from 'express';
 
-import { Dynamo_Error, Dynamo_Log } from '@futdevpro/fsm-dynamo';
+import { Dynamo_Array, Dynamo_Error, Dynamo_Log } from '@futdevpro/fsm-dynamo';
 import { DynamoNTS_RouteSecurity } from '../../_enums/route-security.enum';
 import { DynamoNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
 import { dynamoNTS_globalSettings } from '../../_constants/global-settings.const';
@@ -20,14 +20,14 @@ export class DynamoNTS_EndpointParams{
   type: DynamoNTS_HttpCallType;
   endpoint: string;
 
-  pathParams: string[];
+  private pathParams: string[];
 
-  preProcessess: ((req: Request, res: Response, next: NextFunction) => Promise<void>)[]
-  tasks: ((req: Request, res: Response, issuer?: string) => Promise<void>)[];
+  private preProcessess: ((req: Request, res: Response) => Promise<void>)[]
+  private tasks: ((req: Request, res: Response, issuer?: string) => Promise<void>)[];
 
-  logRequest: boolean;
-  logRequestsContent: boolean;
-  logResponseContent: boolean;
+  private logRequest: boolean;
+  private logRequestsContent: boolean;
+  private logResponseContent: boolean;
 
   constructor(
     set: {
@@ -57,7 +57,7 @@ export class DynamoNTS_EndpointParams{
        * preprocesses are the functions you need to run before the actual function,
        * such as authentications
        */
-      preProcessess?: ((req: Request, res: Response, next: NextFunction) => Promise<void>)[],
+      preProcessess?: ((req: Request, res: Response) => Promise<void>)[],
       /**
        * the actual tasks to run, 
        * the last one should contain the res.send(); execution to send response on API requests
@@ -107,9 +107,9 @@ export class DynamoNTS_EndpointParams{
       this.logRequestsContent = set.logRequestsContent ?? dynamoNTS_globalSettings.logRequestsContent;
       this.logResponseContent = set.logResponseContent ?? dynamoNTS_globalSettings.logResponseContent;
 
-      if (this.logRequest) {
+      /* if (this.logRequest) {
         this.preProcessess.unshift(this.getPreLog());
-      }
+      } */
     } catch (error) {
       Dynamo_Log.error(
         `\nEndpoint params setup failed: name: '${set.name}' (security: ${set.security}) endpoint: ${set.endpoint}\nERROR:\n`, error);
@@ -121,71 +121,57 @@ export class DynamoNTS_EndpointParams{
    * 
    * @returns 
    */
-  getPreLog(): (req: Request, res: Response, next: NextFunction) => Promise<void> {
-    return async (req: Request, res: Response, next: NextFunction) => {
-      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);
-            } else {
-              console.log(`==> incoming ${this.name} request...${inputs}`);
+  private async preLog(req: Request, res: Response): Promise<void> {
+    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 += ',';
             }
-          } else {
-            console.log(`==> incoming ${this.name} request...`);
           }
-        }
 
-        next();
-      } catch (error) {
-        this.error(res, error);
-      }
-    };
-  }
-  
-  getPreProcessExecution(): ((req: Request, res: Response, next: NextFunction) => Promise<void>)[] {
-    return this.preProcessess.map(
-      (
-        preProcess: (req: Request, res: Response, next: NextFunction) => Promise<void>
-      ) => async (req: Request, res: Response, next: NextFunction) => {
-        try {  
-          await preProcess(req, res, next)
-    
-          if (this.logRequest) {
-            if (this.logResponseContent) {
-              Dynamo_Log.success(`  <<<=====   ${this.name} result sent.`);
-              Dynamo_Log.warn('sorry, the logResponseContent is not implemented yet.');
-            } else {
-              Dynamo_Log.success(`  <<<=====   ${this.name} result sent.`);
-            }
+          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}`);
           }
-        } catch (error) {
-          this.error(res, error);
+        } else {
+          console.log(`==> incoming ${this.name} request...`);
         }
       }
-    );
+
+    } catch (error) {
+      this.error(res, error);
+    }
   }
 
   /**
    * 
    * @returns 
    */
-  getTasksExecution(): (req: Request, res: Response) => Promise<void> {
+  getFullExecution(): (req: Request, res: Response) => Promise<void> {
     return async (req: Request, res: Response) => {
-      try {  
+      try {
+        if (this.logRequest) {
+          await this.preLog(req, res);
+        }
+
+        await Dynamo_Array.asyncForEach(this.preProcessess, 
+          async (preProcess: (req: Request, res: Response) => Promise<void>) => {
+            await preProcess(req, res);
+          }
+        );
+        
         const issuer: string = DynamoNTS_GlobalService?.getAuthService()?.getAccountIdFromRequest(req);
   
-        for (let i = 0; i < this.tasks.length; i++) {
-          await this.tasks[i](req, res, issuer);
-        }
+        await Dynamo_Array.asyncForEach(this.tasks,
+          async (task: (req: Request, res: Response, issuer?: string) => Promise<void>) => {
+            await task(req, res, issuer);
+          }
+        );
   
         if (this.logRequest) {
           if (this.logResponseContent) {
@@ -206,7 +192,7 @@ export class DynamoNTS_EndpointParams{
    * @param res 
    * @param error 
    */
-  error(res: Response, error: Error | Dynamo_Error): void {
+  private error(res: Response, error: Error | Dynamo_Error): void {
     try {
 
       Dynamo_Log.error(

package/src/_services/core/auth.service.ts

@@ -90,7 +90,7 @@ export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
    *   }
    * }
    * */
-  abstract authenticateToken(req: Request, res: Response, next: NextFunction): Promise<void>;
+  abstract authenticateToken(req: Request, res: Response): Promise<void>;
 
   /**
    * You need to implement a token validation logic, 
@@ -126,7 +126,7 @@ export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
    * }
    * 
    */
-  abstract authenticateTokenSelf(req: Request, res: Response, next: NextFunction): Promise<void>;
+  abstract authenticateTokenSelf(req: Request, res: Response): Promise<void>;
   
   /**
    * Authenticate Token for Permission to Access UsageData
@@ -142,7 +142,7 @@ export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
    *   AuthService.authTokenAndPerm(req, res, next, Permission.accessUsageData);
    * }
    */
-  abstract authTokenPermAccUsageData(req: Request, res: Response, next: NextFunction): Promise<void>;
+  abstract authTokenPermAccUsageData(req: Request, res: Response): Promise<void>;
 
   /**
    * The DynamoBE System is using this to get issuer, that will be set on DBServices

package/src/_services/route/routing-module.service.ts

@@ -160,33 +160,23 @@ export class DynamoNTS_RoutingModule {
     switch(endpointParams.type) {
 
       case DynamoNTS_HttpCallType.get:
-        this.openRouter.get(endpointParams.endpoint, 
-          endpointParams.preProcessess, endpointParams.getTasksExecution()
-        );
+        this.openRouter.get(endpointParams.endpoint, endpointParams.getFullExecution());
         break;
 
       case DynamoNTS_HttpCallType.post:
-          this.openRouter.post(endpointParams.endpoint, 
-            endpointParams.preProcessess, endpointParams.getTasksExecution()
-          );
+          this.openRouter.post(endpointParams.endpoint, endpointParams.getFullExecution());
         break;
 
       case DynamoNTS_HttpCallType.put:
-        this.openRouter.put(endpointParams.endpoint, 
-          endpointParams.preProcessess, endpointParams.getTasksExecution()
-        );
+        this.openRouter.put(endpointParams.endpoint, endpointParams.getFullExecution());
         break;
 
       case DynamoNTS_HttpCallType.patch:
-        this.openRouter.patch(endpointParams.endpoint, 
-          endpointParams.preProcessess, endpointParams.getTasksExecution()
-        );
+        this.openRouter.patch(endpointParams.endpoint, endpointParams.getFullExecution());
         break;
 
       case DynamoNTS_HttpCallType.delete:
-        this.openRouter.delete(endpointParams.endpoint, 
-          endpointParams.preProcessess, endpointParams.getTasksExecution()
-        );
+        this.openRouter.delete(endpointParams.endpoint, endpointParams.getFullExecution());
         break;
 
       default:
@@ -209,28 +199,23 @@ export class DynamoNTS_RoutingModule {
   private mountSecureRoute(endpointParams: DynamoNTS_EndpointParams): void {
     switch(endpointParams.type) {
       case DynamoNTS_HttpCallType.get:
-        this.secureRouter.get(endpointParams.endpoint, 
-          endpointParams.preProcessess, endpointParams.getTasksExecution());
+        this.secureRouter.get(endpointParams.endpoint, endpointParams.getFullExecution());
         break;
 
       case DynamoNTS_HttpCallType.post:
-        this.secureRouter.post(endpointParams.endpoint, 
-          endpointParams.preProcessess, endpointParams.getTasksExecution());
+        this.secureRouter.post(endpointParams.endpoint, endpointParams.getFullExecution());
         break;
 
       case DynamoNTS_HttpCallType.put:
-        this.secureRouter.put(endpointParams.endpoint, 
-          endpointParams.preProcessess, endpointParams.getTasksExecution());
+        this.secureRouter.put(endpointParams.endpoint, endpointParams.getFullExecution());
         break;
 
       case DynamoNTS_HttpCallType.patch:
-        this.secureRouter.patch(endpointParams.endpoint, 
-          endpointParams.preProcessess, endpointParams.getTasksExecution());
+        this.secureRouter.patch(endpointParams.endpoint, endpointParams.getFullExecution());
         break;
 
       case DynamoNTS_HttpCallType.delete:
-        this.secureRouter.delete(endpointParams.endpoint, 
-          endpointParams.preProcessess, endpointParams.getTasksExecution());
+        this.secureRouter.delete(endpointParams.endpoint, endpointParams.getFullExecution());
         break;
 
       default:

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

@@ -6,7 +6,7 @@ import * as Https from 'https';
 import * as FileSystem from 'fs';
 import * as BodyParser from 'body-parser';
 
-import { delay, Dynamo_Array, Dynamo_Error, Dynamo_Log, second, wait } from '@futdevpro/fsm-dynamo';
+import { Dynamo_Array, Dynamo_Error, Dynamo_Log, second, wait } from '@futdevpro/fsm-dynamo';
 
 import { DynamoNTS_SingletonService } from '../base/singleton.service';
 import { DynamoNTS_RouteSecurity } from '../../_enums/route-security.enum';
@@ -18,7 +18,6 @@ import { DynamoNTS_GlobalServiceSettings } from '../../_models/interfaces/global
 import { dynamoNTS_globalSettings } from '../../_constants/global-settings.const';
 import { DynamoNTS_AppParams } from '../../_models/control-models/app-params.control-model';
 import { DynamoNTS_EndpointParams } from '../../_models/control-models/endpoint-params.control-model';
-import { DynamoNTS_SystemControl } from '../../_models/control-models/system-control.control-model';
 import { DynamoNTS_AppSystemControls } from '../../_models/control-models/app-system-controls.control-model';
 
 
@@ -607,7 +606,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           this.httpsServer
             .listen(this._ports.httpsPort, 'localhost', 0, () => {
               this.systemControls.httpsServer.started = true;
-              Dynamo_Log.success(`\nHTTPS (secure) server is listening on port ${this._ports.httpsPort}`);
+              Dynamo_Log.success(`\nHTTPS (secure) server is listening on port: ${this._ports.httpsPort}`);
               resolve();
             })
             .on('error', (error) => {
@@ -641,7 +640,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           this.httpServer = this.openExpress
             .listen(this._ports.httpPort, () => {
               this.systemControls.httpServer.started = true;
-              Dynamo_Log.success(`\nHTTP (open) server is listening on port ${this._ports.httpPort}`);
+              Dynamo_Log.success(`\nHTTP (open) server is listening on port: ${this._ports.httpPort}`);
               resolve();
             })
             .on('error', (error) => {