@futdevpro/nts-dynamo 1.7.16 → 1.7.20

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

@@ -2,10 +2,14 @@
 
 import { Request, Response } from 'express';
 
-import { Dynamo_Metadata, Dynamo_DataParams, Dynamo_Log, Dynamo_Error } from '@futdevpro/fsm-dynamo';
+import { 
+  Dynamo_Metadata, Dynamo_DataParams, Dynamo_Log, Dynamo_Error, Dynamo_Array 
+} from '@futdevpro/fsm-dynamo';
 import { DynamoNTS_AppParams } from '../../_models/control-models/app-params.control-model';
 
-import { DynamoNTS_GlobalServiceSettings } from '../../_models/interfaces/global-service-settings.interface';
+import { 
+  DynamoNTS_GlobalServiceSettings 
+} from '../../_models/interfaces/global-service-settings.interface';
 
 import { DynamoNTS_AuthService } from './auth.service';
 /* import { DynamoNTS_DBServiceCollection } from './db-service-collection.service'; */
@@ -27,17 +31,28 @@ export class DynamoNTS_GlobalService extends DynamoNTS_SingletonService {
   }
 
   private static _params: DynamoNTS_AppParams;
-  static get params(): DynamoNTS_AppParams { return this._params; }
+  static get params(): DynamoNTS_AppParams { 
+    return this._params; 
+  }
 
   private static readonly _upSince: Date = new Date();
-  static get upSince(): Date { return this._upSince; }
-  static get upTime(): number { return +new Date() - +this._upSince; }
+  static get upSince(): Date { 
+    return this._upSince; 
+  }
+  static get upTime(): number { 
+    return +new Date() - +this._upSince; 
+  }
 
   authService: DynamoNTS_AuthService;
-  dbServiceCollection: DynamoNTS_ServiceCollection<DynamoNTS_DBService<any>>; // DynamoNTS_DBServiceCollection;
-  emailServiceCollection: DynamoNTS_ServiceCollection<DynamoNTS_EmailService>; // DynamoNTS_EmailServiceCollection;
-
-  static globalErrorHandler?: (err: any, req?: Request, res?: Response, issuer?: string) => Promise<void>;
+  dbServiceCollection: DynamoNTS_ServiceCollection<DynamoNTS_DBService<any>>;
+  emailServiceCollection: DynamoNTS_ServiceCollection<DynamoNTS_EmailService>; 
+
+  static globalErrorHandler?: (
+    err: any, 
+    req?: Request, 
+    res?: Response, 
+    issuer?: string
+  ) => Promise<void>;
     
   /**
    * You need to setup global Services through this function
@@ -47,34 +62,43 @@ export class DynamoNTS_GlobalService extends DynamoNTS_SingletonService {
 
     try {
       this.instance.dbServiceCollection = {};
-      set.dbModels?.forEach((dbModel: Dynamo_DataParams) => {
+      set.dbModels?.forEach((dbModel: Dynamo_DataParams): void => {
         try {
           this.instance.dbServiceCollection[dbModel.dataName] = new DynamoNTS_DBService(dbModel);
         } catch (error) {
           Dynamo_Log.error(`Failed to create DynamoNTS_DBService (${dbModel.dataName}).`, error);
-          error = new Dynamo_Error({
+          
+          throw new Dynamo_Error({
             message: `Failed to create DynamoNTS_DBService (${dbModel.dataName}).\n` + dbModel, 
             issuerService: 'DynamoNTS_GlobalService',
-            error: error
+            error: error,
           });
-          throw error;
         }
       });
 
       this.instance.authService = set.authService;
-      this.instance.emailServiceCollection = set.emailServiceCollection;
+      this.instance.emailServiceCollection = set.emailServiceCollection ?? {};
+      await Dynamo_Array.asyncForEach(
+        Object.keys(this.instance.emailServiceCollection),
+        async (key: string): Promise<void> => {
+          await (
+            this.instance.emailServiceCollection[key] as DynamoNTS_EmailService
+          ).asyncPostConstruct();
+        }
+      );
       
-      DynamoNTS_GlobalService.globalErrorHandler = set.errorHandler ?? (async (error: any) => {
-        Dynamo_Log.warn(`globalErrorHandler not set!`);
-        Dynamo_Log.error(`ERROR:\n`, error)
-      });
+      DynamoNTS_GlobalService.globalErrorHandler = 
+        set.errorHandler ?? 
+        (async (error: any): Promise<void> => {
+          Dynamo_Log.warn(`globalErrorHandler not set!`);
+          Dynamo_Log.error(`ERROR:\n`, error);
+        });
     } catch (error) {
-      Dynamo_Log.error(`Failed to create DynamoNTS_GlobalService.`, error);
-      /* error = new Dynamo_Error({
-        message: `Failed to create DynamoNTS_GlobalService.`,
-        error: error
+      throw new Dynamo_Error({
+        message: `Failed to setServices on DynamoNTS_GlobalService.`,
+        error: error,
+        errorCode: 'NTS-GS0-SS0',
       });
-      throw error; */
     }
   }
 
@@ -106,7 +130,8 @@ export class DynamoNTS_GlobalService extends DynamoNTS_SingletonService {
     if (!this.instance?.dbServiceCollection) {
       throw new Error(
         `\n  Unique DataBase Service Collection missing!` + 
-        `\n    Please create a Unique DataBase Service Collection extending DynamoNTS_DBServiceCollection, ` + 
+        `\n    Please create a Unique DataBase Service Collection extending ` +
+          `DynamoNTS_DBServiceCollection, ` + 
         `\n      and Setup with DynamoNTS_GlobalServiceC.setServices(...)\n`
       );
     }
@@ -119,7 +144,9 @@ export class DynamoNTS_GlobalService extends DynamoNTS_SingletonService {
    * @param dataParams 
    * @returns 
    */
-  static getDBService<T extends Dynamo_Metadata>(dataParams: Dynamo_DataParams): DynamoNTS_DBService<T> {
+  static getDBService<T extends Dynamo_Metadata>(
+    dataParams: Dynamo_DataParams
+  ): DynamoNTS_DBService<T> {
     return this.getDBServiceByKey<T>(dataParams.dataName);
   }
 
@@ -130,10 +157,12 @@ export class DynamoNTS_GlobalService extends DynamoNTS_SingletonService {
    */
   static getDBServiceByKey<T extends Dynamo_Metadata>(key: string): DynamoNTS_DBService<T> {
     const collection = this.getDBServiceCollection();
+
     if (collection[key]) {
       return collection[key] as DynamoNTS_DBService<T>;
     } else {
       let keys: string = `${Object.keys(collection)}`;
+
       keys = keys.replace(/,/g, '\n                ');
 
       throw new Error(
@@ -153,7 +182,8 @@ export class DynamoNTS_GlobalService extends DynamoNTS_SingletonService {
     if (!this.instance?.emailServiceCollection) {
       throw new Error(
         `\n  Unique Email Service Collection missing!` + 
-        `\n    Please create a Unique Email Service Collection extending DynamoBEEmailServiceCollection, ` + 
+        `\n    Please create a Unique Email Service Collection extending ` +
+          `DynamoBEEmailServiceCollection, ` + 
         `\n      and Setup with DynamoNTS_GlobalServiceC.setServices(...)\n`
       );
     }

package/src/_services/route/controller.service.ts

@@ -1,7 +1,9 @@
 
 
 import { Dynamo_Log } from '@futdevpro/fsm-dynamo';
-import { DynamoNTS_EndpointParams } from '../../_models/control-models/endpoint-params.control-model';
+import { 
+  DynamoNTS_EndpointParams 
+} from '../../_models/control-models/endpoint-params.control-model';
 
 import { DynamoNTS_SingletonService } from '../base/singleton.service';
 

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

@@ -7,8 +7,12 @@ import { dynamoNTS_globalSettings } from '../../_constants/global-settings.const
 import { DynamoNTS_RouteSecurity } from '../../_enums/route-security.enum';
 import { DynamoNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
 import { DynamoNTS_Controller } from './controller.service';
-import { DynamoNTS_RoutingModuleSettings } from '../../_models/interfaces/routing-module-settings.interface';
-import { DynamoNTS_EndpointParams } from '../../_models/control-models/endpoint-params.control-model';
+import { 
+  DynamoNTS_RoutingModuleSettings 
+} from '../../_models/interfaces/routing-module-settings.interface';
+import { 
+  DynamoNTS_EndpointParams 
+} from '../../_models/control-models/endpoint-params.control-model';
 
 /**
  * Routing Module
@@ -81,7 +85,9 @@ export class DynamoNTS_RoutingModule {
       this.setupRoutes();
       this.mountRoutes(set.securityOverride);
 
-      if (this.log) console.log(`routing module setup done: ${this.route} serurity: ${this.security}\n`);
+      if (this.log) console.log(
+        `routing module setup done: ${this.route} serurity: ${this.security}\n`
+      );
     } catch (error) {
       Dynamo_Log.error(`\nRouting module setup failed (${this.route})`, error);
     }
@@ -91,7 +97,7 @@ export class DynamoNTS_RoutingModule {
    * You must setup endpoints and required services for this function
    */
   private setupRoutes(): void {
-    this.controllers.forEach((controller: DynamoNTS_Controller) => {
+    this.controllers.forEach((controller: DynamoNTS_Controller): void => {
       this.endpoints.push(...controller.endpoints);
     });
   }
@@ -105,7 +111,7 @@ export class DynamoNTS_RoutingModule {
       this.security = securityOverride;
     }
 
-    this.endpoints.forEach((endpoint: DynamoNTS_EndpointParams) => {
+    this.endpoints.forEach((endpoint: DynamoNTS_EndpointParams): void => {
       if (securityOverride) {
         endpoint.security = securityOverride;
       } else {
@@ -118,13 +124,16 @@ export class DynamoNTS_RoutingModule {
         }
       }
 
-      if (this.log) console.log(`endpoint mount (${endpoint.security}): ${this.route}${endpoint.endpoint}`);
+      if (this.log) console.log(
+        `endpoint mount (${endpoint.security}): ${this.route}${endpoint.endpoint}`
+      );
       const existingEndPoints: DynamoNTS_EndpointParams[] = this.endpoints
-        .filter((ep: DynamoNTS_EndpointParams) => ep.endpoint === endpoint.endpoint);
+        .filter((ep: DynamoNTS_EndpointParams): boolean => ep.endpoint === endpoint.endpoint);
         
       if (1 < existingEndPoints.length) {
-        let error = new Error(`ENDPOINT DUPLICATION: ${endpoint.endpoint}`);
-        let errorStack: string[] = error.stack.split('\n');
+        const error = new Error(`ENDPOINT DUPLICATION: ${endpoint.endpoint}`);
+        const errorStack: string[] = error.stack.split('\n');
+
         errorStack.splice(1, 4);
         error.stack = errorStack.join('\n');
 
@@ -135,11 +144,13 @@ export class DynamoNTS_RoutingModule {
         if (endpoint.security !== DynamoNTS_RouteSecurity.secure) {
           this.mountOpenRoute(endpoint);
         }
+
         if (endpoint.security !== DynamoNTS_RouteSecurity.open) {
           this.mountSecureRoute(endpoint);
         }
       } catch (error) {
         Dynamo_Log.error(`\nRouting module setup failed (${this.route})`, error);
+
         throw new Dynamo_Error({ 
           errorCode: 'NTS-RM9-100',
           addECToUserMsg: true,
@@ -147,7 +158,7 @@ export class DynamoNTS_RoutingModule {
           userMessage: this.defaultErrorUserMsg, 
           issuerService: this.serviceName + ' - ' + this.route,
           error 
-        })
+        });
       }
     });
   }
@@ -164,7 +175,7 @@ export class DynamoNTS_RoutingModule {
         break;
 
       case DynamoNTS_HttpCallType.post:
-          this.openRouter.post(endpointParams.endpoint, endpointParams.getFullExecution());
+        this.openRouter.post(endpointParams.endpoint, endpointParams.getFullExecution());
         break;
 
       case DynamoNTS_HttpCallType.put:
@@ -181,14 +192,16 @@ export class DynamoNTS_RoutingModule {
 
       default:
         Dynamo_Log.error(`INVALID route type: ${endpointParams.type} - ${endpointParams.name}`);
+
         throw new Dynamo_Error({ 
           errorCode: 'NTS-RM9-200',
           addECToUserMsg: true,
-          message: `DYNAMO-NTS ERROR: INVALID route type: ${endpointParams.type} - ${endpointParams.name}` ,
+          message:
+            `DYNAMO-NTS ERROR: INVALID route type: ${endpointParams.type} - ${endpointParams.name}`,
           userMessage: this.defaultErrorUserMsg, 
           issuerService: this.serviceName + ' - ' + this.route,
           error: new Error()
-        })
+        });
     }
   }
 
@@ -219,15 +232,19 @@ export class DynamoNTS_RoutingModule {
         break;
 
       default:
-        Dynamo_Log.error(`DYNAMO-NTS ERROR: INVALID route type: ${endpointParams.type} - ${endpointParams.name}`);
+        Dynamo_Log.error(
+          `DYNAMO-NTS ERROR: INVALID route type: ${endpointParams.type} - ${endpointParams.name}`
+        );
+
         throw new Dynamo_Error({ 
           errorCode: 'NTS-RM9-300',
           addECToUserMsg: true,
-          message: `DYNAMO-NTS ERROR: INVALID route type: ${endpointParams.type} - ${endpointParams.name}`,
+          message: 
+            `DYNAMO-NTS ERROR: INVALID route type: ${endpointParams.type} - ${endpointParams.name}`,
           userMessage: this.defaultErrorUserMsg, 
           issuerService: this.serviceName + ' - ' + this.route,
           error: new Error()
-        })
+        });
     }
   }
 }

package/src/_services/server/app-extended.server.spec.ts

@@ -1,70 +1,75 @@
 import { delay } from '@futdevpro/fsm-dynamo';
-import { DynamoNTS_AppExtendedBase_Mock, DynamoNTS_AppExtendedFull_Mock, DynamoNTS_AppWbMock_Mock } from '../../_constants/mocks/app-extended-server.mock';
+import { 
+  DynamoNTS_AppExtendedBase_Mock, DynamoNTS_AppExtendedFull_Mock, DynamoNTS_AppWbMock_Mock 
+} from '../../_constants/mocks/app-extended-server.mock';
 
-describe('DynamoNTS_AppExtended;', () => {
-  describe('a extended-base instance;', () => {
+describe('DynamoNTS_AppExtended;', (): void => {
+  describe('a extended-base instance;', (): void => {
     let app: DynamoNTS_AppExtendedBase_Mock;
 
-    beforeEach(async () => {
+    beforeEach(async (): Promise<void> => {
       app = new DynamoNTS_AppExtendedBase_Mock();
+
+      await delay(100);
+      
       await app.ready();
     });
 
-    afterEach(async () => {
+    afterEach(async (): Promise<void> => {
       await app.stop();
 
       await delay(100);
     });
 
-    it('should be created', () => {
+    it('should be created', (): void => {
       expect(app).toBeDefined();
     });
 
-    it('should be started', () => {
+    it('should be started', (): void => {
       expect(app.started).toBeTrue();
     });
   });
 
-  describe('a extended-full instance;', () => {
+  describe('a extended-full instance;', (): void => {
     let app: DynamoNTS_AppExtendedFull_Mock;
 
-    beforeEach(async () => {
+    beforeEach(async (): Promise<void> => {
       app = new DynamoNTS_AppExtendedFull_Mock();
       await app.ready();
     });
 
-    afterEach(async () => {
+    afterEach(async (): Promise<void> => {
       await app.stop();
     });
 
-    it('should be created', () => {
+    it('should be created', (): void => {
       expect(app).toBeDefined();
     });
       
-    it('should be started', () => {
+    it('should be started', (): void => {
       expect(app.started).toBeTrue();
     });
   });
 
-  describe('a wb-mock instance;', () => {
+  describe('a wb-mock instance;', (): void => {
     let app: DynamoNTS_AppWbMock_Mock;
 
-    beforeEach(async () => {
+    beforeEach(async (): Promise<void> => {
       app = new DynamoNTS_AppWbMock_Mock();
       await app.ready();
     });
 
-    afterEach(async () => {
+    afterEach(async (): Promise<void> => {
       await app.stop();
 
       await delay(100);
     });
 
-    it('should be created', () => {
+    it('should be created', (): void => {
       expect(app).toBeDefined();
     });
       
-    it('should be started', () => {
+    it('should be started', (): void => {
       expect(app.started).toBeTrue();
     });
   });