@futdevpro/nts-dynamo 1.9.45 → 1.10.1

package/src/_services/core/email.service.spec.ts

@@ -0,0 +1,93 @@
+
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyNTS_EmailService, DyNTS_EmailService_Settings, DyNTS_EmailTemplateComponent, DyNTS_SendEmail_Settings } from './email.service';
+
+describe('DyNTS_EmailService', () => {
+  let emailService: DyNTS_EmailService;
+  const settings: DyNTS_EmailService_Settings = {
+    host: 'smtp.example.com',
+    port: 587,
+    email: 'test@example.com',
+    pass: 'password',
+    senderName: 'Test Sender',
+    rootPath: '/path/to/templates',
+    templateComponents: [
+      new DyNTS_EmailTemplateComponent({
+        name: 'testComponent',
+        selector: 'test-selector',
+        template: '<div>{{property}}</div>',
+        properties: [ 'property' ],
+      }),
+    ],
+  };
+
+  beforeEach(() => {
+    emailService = new DyNTS_EmailService(settings);
+  });
+
+  it('should initialize with correct settings', () => {
+    expect(emailService.serviceName).toBe('DyNTS_EmailService');
+    expect(emailService['senderName']).toBe(settings.senderName);
+    expect(emailService['senderNEmail']).toBe(`${settings.senderName} <${settings.email}>`);
+  });
+
+  it('should load email template components', async () => {
+    await emailService.asyncPostConstruct();
+    expect(emailService['componentsByName']['testComponent']).toBeDefined();
+    expect(emailService['componentsBySelector']['test-selector']).toBeDefined();
+  });
+
+  xit('should send email with direct content', async () => {
+    const sendEmailSettings: DyNTS_SendEmail_Settings = {
+      to: 'recipient@example.com',
+      subject: 'Test Subject',
+      content: '<p>Test Content</p>',
+    };
+
+    await emailService.sendEmail(sendEmailSettings, 'testIssuer');
+    // No error should be thrown
+  });
+
+  it('should throw error if no template component name is provided', async () => {
+    const sendEmailSettings: DyNTS_SendEmail_Settings = {
+      to: 'recipient@example.com',
+      subject: 'Test Subject',
+    };
+
+    await expectAsync(emailService.sendEmail(sendEmailSettings, 'testIssuer'))
+      .toBeRejectedWith(jasmine.any(DyFM_Error));
+  });
+
+  it('should throw error if template component is not found', async () => {
+    const sendEmailSettings: DyNTS_SendEmail_Settings = {
+      to: 'recipient@example.com',
+      subject: 'Test Subject',
+      templateComponentName: 'nonExistentComponent',
+    };
+
+    await expectAsync(emailService.sendEmail(sendEmailSettings, 'testIssuer'))
+      .toBeRejectedWith(jasmine.any(DyFM_Error));
+  });
+
+  xit('should compile template component correctly', async () => {
+    const compiledTemplate = await emailService['compileTemplateComponent'](
+      'testComponent',
+      { property: 'value' },
+      'testIssuer'
+    );
+
+    expect(compiledTemplate).toContain('<div>value</div>');
+  });
+
+  it('should throw error if template property is missing', async () => {
+    const component = new DyNTS_EmailTemplateComponent({
+      name: 'testComponent',
+      selector: 'test-selector',
+      template: '<div>{{missingProperty}}</div>',
+      properties: [ 'missingProperty' ],
+    });
+
+    await expectAsync(emailService['compileComponentProperties'](component, {}, '', 'testIssuer'))
+      .toBeRejectedWith(jasmine.any(DyFM_Error));
+  });
+});

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

@@ -1,14 +1,12 @@
 
 import * as FileSystem from 'fs';
-import * as Path from 'path';
 import * as NodeMailer from 'nodemailer';
 
-import { Options as MailOptions, Attachment } from 'nodemailer/lib/mailer';
+import { Attachment, Options as MailOptions } from 'nodemailer/lib/mailer';
 
-import { 
-  DyFM_AnyError, DyFM_Array, DyFM_Error, DyFM_Error_Settings, DyFM_Log 
+import {
+  DyFM_AnyError, DyFM_Array, DyFM_Error, DyFM_Error_Settings, DyFM_Log
 } from '@futdevpro/fsm-dynamo';
-import { DyNTS_SingletonService } from '../base/singleton.service';
 import { DyNTS_global_settings } from '../../_collections/global-settings.const';
 
 export interface DyNTS_EmailService_Settings {
@@ -63,15 +61,15 @@ export interface DyNTS_SendEmail_Settings<T = { [propertyKey: string]: string; }
 export class DyNTS_EmailService /* extends DyNTS_SingletonService */ {
   serviceName: string;
 
-  private nmTransporter: NodeMailer.Transporter;
-  private senderName: string;
-  private senderNEmail: string;
+  private readonly nmTransporter: NodeMailer.Transporter;
+  private readonly senderName: string;
+  private readonly senderNEmail: string;
   
-  private components: DyNTS_EmailTemplateComponent[] = [];
-  private componentsBySelector: {
+  private readonly components: DyNTS_EmailTemplateComponent[] = [];
+  private readonly componentsBySelector: {
     [selector: string]: DyNTS_EmailTemplateComponent
   } = {};
-  private componentsByName: {
+  private readonly componentsByName: {
     [componentName: string]: DyNTS_EmailTemplateComponent
   } = {};
 

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

@@ -1,18 +1,20 @@
 
 
-import { Request, Response } from 'express';
 
-import { 
-  DyFM_Metadata, DyFM_DataModel_Params, DyFM_Log, DyFM_Error, DyFM_Array, 
-  DyFM_errorFlag,
+import {
   DyFM_AnyError,
-  DyFM_Error_Settings
+  DyFM_Array,
+  DyFM_DataModel_Params,
+  DyFM_Error,
+  DyFM_Error_Settings,
+  DyFM_Log,
+  DyFM_Metadata
 } from '@futdevpro/fsm-dynamo';
 import { DyNTS_App_Params } from '../../_models/control-models/app-params.control-model';
 
-import { 
+import {
   DyNTS_GlobalErrorHandlerFn,
-  DyNTS_GlobalService_Settings 
+  DyNTS_GlobalService_Settings
 } from '../../_models/interfaces/global-service-settings.interface';
 
 import { DyNTS_AuthService } from './auth.service';
@@ -21,8 +23,8 @@ import { DyNTS_DBService } from '../base/db.service';
 import { DyNTS_EmailService } from './email.service';
 import { DyNTS_Service_Collection } from './service-collection.service';
 /* import { DyNTS_EmailServiceCollection } from './email-service-collection.service'; */
-import { DyNTS_SingletonService } from '../base/singleton.service';
 import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { DyNTS_SingletonService } from '../base/singleton.service';
 /* import { DyNTS_archiveFlag } from '../../_collections/archive-flag.const'; */
 import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
 
@@ -84,11 +86,11 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
     }
   }
 
-  private static async setDBServices(dbModels?: DyFM_DataModel_Params[]): Promise<void> {    
+  private static async setDBServices(dbModels?: DyFM_DataModel_Params<any>[]): Promise<void> {    
     try {
       this.instance.dbServiceCollection = {};
 
-      dbModels?.forEach((dbModel: DyFM_DataModel_Params): void => {
+      dbModels?.forEach((dbModel: DyFM_DataModel_Params<any>): void => {
         if (!dbModel) {
           throw new DyFM_Error({
             ...this.getDefaultErrorSettings(
@@ -100,13 +102,13 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
             errorCode: 'NTS-GS0-SDBS2',
             additionalContent: {
               dbModels: dbModels,
-              dbModelNames: dbModels.map((dbModel: DyFM_DataModel_Params) => dbModel.dataName),
+              dbModelNames: dbModels.map((dbModel: DyFM_DataModel_Params<any>) => dbModel.dataName),
             },
           });
         }
 
         if (dbModel.addArchive) {
-          const archiveModel: DyFM_DataModel_Params = new DyFM_DataModel_Params({
+          const archiveModel: DyFM_DataModel_Params<any> = new DyFM_DataModel_Params<any>({
             ...dbModel,
             dataName: DyNTS_getArchivedDBName(dbModel.dataName),
           });
@@ -115,7 +117,7 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
         }
       });
 
-      dbModels?.forEach((dbModel: DyFM_DataModel_Params): void => {
+      dbModels?.forEach((dbModel: DyFM_DataModel_Params<any>): void => {
         if (!dbModel.constructed) {
           throw new DyFM_Error({
             ...this.getDefaultErrorSettings(
@@ -223,8 +225,9 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
           }
         } catch (error) {
           DyFM_Log.error(
-            `NTS GLOBAL MULTILEVEL ERROR: \nFailed to handle error on globalErrorHandler.`,
-            error
+            `NTS GLOBAL MULTILEVEL ERROR: ` +
+            `\nFailed to handle error on globalErrorHandler.`,
+            (error as DyFM_Error)?.getErrorSimplified?.() ?? error
           );
         }
       });
@@ -280,7 +283,7 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
    * @returns 
    */
   static getDBService<T extends DyFM_Metadata>(
-    dataParams: DyFM_DataModel_Params
+    dataParams: DyFM_DataModel_Params<T>
   ): DyNTS_DBService<T> {
     return this.getDBServiceByKey<T>(dataParams.dataName);
   }

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

@@ -0,0 +1,52 @@
+
+import { DyNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
+import { DyNTS_Endpoint_Params } from '../../_models/control-models/endpoint-params.control-model';
+import { DyNTS_Controller } from './controller.service';
+
+class TestController extends DyNTS_Controller {
+  setupEndpoints(): void {
+    this.endpoints = [
+      new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyNTS_HttpCallType.get,
+        endpoint: '/test-endpoint',
+        preProcesses: [],
+        tasks: [
+          async (req: any, res: any) => {
+            res.send({ message: 'Test successful' });
+          },
+        ],
+      }),
+    ];
+  }
+
+  static getInstance(): TestController {
+    return new TestController();
+  }
+}
+
+describe('DyNTS_Controller', () => {
+  let controller: TestController;
+
+  beforeEach(() => {
+    controller = TestController.getInstance();
+    controller.setupEndpoints();
+  });
+
+  it('should initialize endpoints correctly', () => {
+    expect(controller.endpoints.length).toBe(1);
+    expect(controller.endpoints[0].name).toBe('testEndpoint');
+    expect(controller.endpoints[0].endpoint).toBe('/test-endpoint');
+  });
+
+  /* it('should execute task and send response', async () => {
+    const req = {};
+    const res = {
+      send: jasmine.createSpy('send'),
+    };
+
+    await controller.endpoints[0].tasks[0](req, res);
+
+    expect(res.send).toHaveBeenCalledWith({ message: 'Test successful' });
+  }); */
+});

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

@@ -1,8 +1,7 @@
 
 
-import { DyFM_Error, DyFM_ErrorLevel, DyFM_Log } from '@futdevpro/fsm-dynamo';
-import { 
-  DyNTS_Endpoint_Params 
+import {
+  DyNTS_Endpoint_Params
 } from '../../_models/control-models/endpoint-params.control-model';
 
 import { DyNTS_SingletonService } from '../base/singleton.service';
@@ -24,7 +23,7 @@ import { DyNTS_SingletonService } from '../base/singleton.service';
  *     this.authService = AuthService.getInstance();
  *
  *     this.endpoints = [
- *       new DyNTS_EndpointParams({
+ *       new DyNTS_Endpoint_Params({
  *         name: 'getUserMatchStatistics',
  *         type: DyNX_HttpCallType.get,
  *         endpoint: '/get/user-match-statistics/:userId',
@@ -55,7 +54,7 @@ export abstract class DyNTS_Controller extends DyNTS_SingletonService {
    * @example
    * 
    * this.endpoints = [
-   *   new DyNTS_EndpointParams({
+   *   new DyNTS_Endpoint_Params({
    *     name: 'getUserMatchStatistics',
    *     type: DyNX_HttpCallType.get,
    *     endpoint: '/get/user-match-statistics/:userId',
@@ -103,7 +102,7 @@ export abstract class DyNTS_Controller extends DyNTS_SingletonService {
    *   this.authService = AuthService.getInstance();
    *
    *   this.endpoints = [
-   *     new DyNTS_EndpointParams({
+   *     new DyNTS_Endpoint_Params({
    *       name: 'getUserMatchStatistics',
    *       type: DyNX_HttpCallType.get,
    *       endpoint: '/get/user-match-statistics/:userId',

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

@@ -0,0 +1,81 @@
+
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
+import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
+import { DyNTS_Endpoint_Params } from '../../_models/control-models/endpoint-params.control-model';
+import {
+  DyNTS_RoutingModule_Settings
+} from '../../_models/interfaces/routing-module-settings.interface';
+import { DyNTS_Controller } from './controller.service';
+import { DyNTS_RoutingModule } from './routing-module.service';
+
+describe('DyNTS_RoutingModule', () => {
+  let routingModule: DyNTS_RoutingModule;
+  let mockController: DyNTS_Controller;
+  let mockEndpoint: DyNTS_Endpoint_Params;
+
+  beforeEach(() => {
+    mockController = {
+      setupEndpoints: jasmine.createSpy('setupEndpoints'),
+      endpoints: [],
+    } as unknown as DyNTS_Controller;
+
+    mockEndpoint = {
+      endpoint: '/test',
+      type: DyNTS_HttpCallType.get,
+      getFullExecution: jasmine.createSpy('getFullExecution'),
+      security: DyNTS_RouteSecurity.open,
+    } as any as DyNTS_Endpoint_Params;
+
+    const settings: DyNTS_RoutingModule_Settings = {
+      route: '/test',
+      controllers: [ mockController ],
+    };
+
+    routingModule = new DyNTS_RoutingModule(settings);
+  });
+
+  it('should initialize with given settings', () => {
+    expect(routingModule.route).toContain('/test');
+    expect(routingModule.endpoints.length).toBe(0);
+  });
+
+  it('should setup routes by calling setupEndpoints on each controller', () => {
+    routingModule['setupRoutes']();
+    expect(mockController.setupEndpoints).toHaveBeenCalled();
+  });
+
+  it('should add endpoints from controllers to the routing module', () => {
+    mockController.endpoints = [ mockEndpoint ];
+    routingModule['setupRoutes']();
+    expect(routingModule.endpoints).toContain(mockEndpoint);
+  });
+
+  xit('should mount open routes correctly', () => {
+    routingModule.endpoints = [ mockEndpoint ];
+    routingModule['mountOpenRoute'](mockEndpoint);
+    expect(routingModule.openRouter.stack.length).toBeGreaterThan(0);
+  });
+
+  xit('should mount secure routes correctly', () => {
+    mockEndpoint.security = DyNTS_RouteSecurity.secure;
+    routingModule.endpoints = [ mockEndpoint ];
+    routingModule['mountSecureRoute'](mockEndpoint);
+    expect(routingModule.secureRouter.stack.length).toBeGreaterThan(0);
+  });
+
+  xit('should throw error for invalid route type in open route', () => {
+    mockEndpoint.type = 'invalid' as DyNTS_HttpCallType;
+    expect(() => routingModule['mountOpenRoute'](mockEndpoint)).toThrow(DyFM_Error);
+  });
+
+  xit('should throw error for invalid route type in secure route', () => {
+    mockEndpoint.type = 'invalid' as DyNTS_HttpCallType;
+    expect(() => routingModule['mountSecureRoute'](mockEndpoint)).toThrow(DyFM_Error);
+  });
+
+  it('should handle endpoint duplication error', () => {
+    routingModule.endpoints = [ mockEndpoint, mockEndpoint ];
+    expect(() => routingModule['mountRoutes']()).toThrowError(/ENDPOINT DUPLICATION/);
+  });
+});

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

@@ -4,41 +4,43 @@ import Express = require('express');
 /* import Mongoose from 'mongoose';
 import Express from 'express'; */
 
+import * as BodyParser from 'body-parser';
+import * as FileSystem from 'fs';
 import * as Http from 'http';
 import * as Https from 'https';
-import * as FileSystem from 'fs';
-import * as BodyParser from 'body-parser';
 
 /* import { version } from '../../../package.json'; */
 
-import { 
+import {
   DyFM_AnyError,
-  DyFM_Array, DyFM_Error, DyFM_error_defaults, 
-  DyFM_Error_Settings, 
-  DyFM_ErrorLevel, DyFM_Log, second, DyFM_wait, 
-  DyFM_errorFlag,
-  DyFM_delay
+  DyFM_Array,
+  DyFM_delay,
+  DyFM_Error, DyFM_error_defaults,
+  DyFM_Error_Settings,
+  DyFM_ErrorLevel, DyFM_Log,
+  DyFM_wait,
+  second
 } from '@futdevpro/fsm-dynamo';
 
-import { DyNTS_SingletonService } from '../base/singleton.service';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
 import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
-import { DyNTS_RoutingModule } from '../route/routing-module.service';
-import { DyNTS_GlobalService } from '../core/global.service';
+import { DyNTS_App_Params } from '../../_models/control-models/app-params.control-model';
+import {
+  DyNTS_AppSystemControls
+} from '../../_models/control-models/app-system-controls.control-model';
+import {
+  DyNTS_Endpoint_Params
+} from '../../_models/control-models/endpoint-params.control-model';
 import { DyNTS_Http_Settings } from '../../_models/control-models/http-settings.control-model';
-import { 
-  DyNTS_Certification_Settings 
+import {
+  DyNTS_Certification_Settings
 } from '../../_models/interfaces/certification-settings.interface';
-import { 
-  DyNTS_GlobalService_Settings 
+import {
+  DyNTS_GlobalService_Settings
 } from '../../_models/interfaces/global-service-settings.interface';
-import { DyNTS_App_Params } from '../../_models/control-models/app-params.control-model';
-import { 
-  DyNTS_Endpoint_Params 
-} from '../../_models/control-models/endpoint-params.control-model';
-import { 
-  DyNTS_AppSystemControls 
-} from '../../_models/control-models/app-system-controls.control-model';
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { DyNTS_SingletonService } from '../base/singleton.service';
+import { DyNTS_GlobalService } from '../core/global.service';
+import { DyNTS_RoutingModule } from '../route/routing-module.service';
 
 /**
  * This will be the MAIN service of our server project,
@@ -167,7 +169,7 @@ import { DyNTS_global_settings } from '../../_collections/global-settings.const'
  * getAppParams(): DyNTS_AppParams 
  * 
  * // this is where you connect your main services
- * getGlobalServiceSettings(): DyNTS_GlobalServiceSettings 
+ * getGlobalServiceSettings(): DyNTS_GlobalService_Settings 
  * 
  * // this is where you set up your ports
  * getPorts(): DyNTS_PortSettings