@futdevpro/nts-dynamo 1.9.45 → 1.10.1

package/src/_modules/mock/data-model.mock.spec.ts

@@ -0,0 +1,109 @@
+
+import {
+  Dependency_Mock, dependency_mock_DataParams, Dependent_Mock, dependent_mock_DataParams
+} from './data-model.mock';
+
+describe('Dependency_Mock', () => {
+  it('should create an instance with default values', () => {
+    const instance = new Dependency_Mock();
+
+    expect(instance).toBeTruthy();
+    expect(instance.string).toBeUndefined();
+    expect(instance.number).toBeUndefined();
+    expect(instance.date).toBeUndefined();
+    expect(instance.boolean).toBeUndefined();
+    expect(instance.array).toBeUndefined();
+    expect(instance.object).toBeUndefined();
+    expect(instance.objectArray).toBeUndefined();
+    expect(instance.objectArrayArray).toBeUndefined();
+  });
+
+  it('should create an instance with provided values', () => {
+    const mockData: Dependency_Mock = {
+      string: 'test',
+      number: 42,
+      date: new Date(),
+      boolean: true,
+      array: [ 'a', 'b' ],
+      object: { key: 'value' },
+      objectArray: [{ key: 'value' }],
+      objectArrayArray: [[{ key: 'value' }]],
+    };
+    const instance = new Dependency_Mock(mockData);
+
+    expect(instance).toEqual(jasmine.objectContaining(mockData));
+  });
+});
+
+xdescribe('DyFM_DataModel_Params for Dependency_Mock', () => {
+  it('should have correct dataName and properties', () => {
+    expect(dependency_mock_DataParams.dataName).toBe('dependencyMock');
+    expect(dependency_mock_DataParams.properties).toEqual({
+      string: { type: 'string' },
+      number: { type: 'number' },
+      date: { type: 'Date' },
+      boolean: { type: 'boolean' },
+      array: { type: 'string[]' },
+      object: { type: 'any' },
+      objectArray: { type: 'any[]' },
+      objectArrayArray: { type: 'any[][]' },
+    });
+  });
+});
+
+describe('Dependent_Mock', () => {
+  it('should create an instance with default values', () => {
+    const instance = new Dependent_Mock();
+
+    expect(instance).toBeTruthy();
+    expect(instance.dependencyId).toBeUndefined();
+    expect(instance.string).toBeUndefined();
+    expect(instance.number).toBeUndefined();
+    expect(instance.date).toBeUndefined();
+    expect(instance.boolean).toBeUndefined();
+    expect(instance.array).toBeUndefined();
+    expect(instance.object).toBeUndefined();
+    expect(instance.objectArray).toBeUndefined();
+    expect(instance.objectArrayArray).toBeUndefined();
+  });
+
+  it('should create an instance with provided values', () => {
+    const mockData: Dependent_Mock = {
+      dependencyId: 'dep123',
+      string: 'test',
+      number: 42,
+      date: new Date(),
+      boolean: true,
+      array: [ 'a', 'b' ],
+      object: { key: 'value' },
+      objectArray: [{ key: 'value' }],
+      objectArrayArray: [[{ key: 'value' }]],
+    };
+    const instance = new Dependent_Mock(mockData);
+
+    expect(instance).toEqual(jasmine.objectContaining(mockData));
+  });
+});
+
+xdescribe('DyFM_DataModel_Params for Dependent_Mock', () => {
+  it('should have correct dataName and properties', () => {
+    expect(dependent_mock_DataParams.dataName).toBe('dependentMock');
+    expect(dependent_mock_DataParams.properties).toEqual({
+      dependencyId: {
+        type: 'string',
+        unique: true,
+        required: true,
+        isDependencyHook: true,
+        dependencyDataName: dependency_mock_DataParams.dataName,
+      },
+      string: { type: 'string' },
+      number: { type: 'number' },
+      date: { type: 'Date' },
+      boolean: { type: 'boolean' },
+      array: { type: 'string[]' },
+      object: { type: 'any' },
+      objectArray: { type: 'any[]' },
+      objectArrayArray: { type: 'any[][]' },
+    });
+  });
+});

package/src/_modules/mock/data-model.mock.ts

@@ -22,18 +22,18 @@ export class Dependency_Mock extends DyFM_Metadata {
   }
 }
 
-export const dependency_mock_DataParams = new DyFM_DataModel_Params({
+export const dependency_mock_DataParams = new DyFM_DataModel_Params<Dependency_Mock>({
   dataName: 'dependencyMock',
-  properties: [
-    { key: 'string', type: 'string' },
-    { key: 'number', type: 'number' },
-    { key: 'date', type: 'Date' },
-    { key: 'boolean', type: 'boolean' },
-    { key: 'array', type: 'string[]' },
-    { key: 'object', type: 'any' },
-    { key: 'objectArray', type: 'any[]' },
-    { key: 'objectArrayArray', type: 'any[][]' },
-  ],
+  properties: {
+    string: { type: 'string' },
+    number: { type: 'number' },
+    date: { type: 'Date' },
+    boolean: { type: 'boolean' },
+    array: { type: 'string[]' },
+    object: { type: 'any' },
+    objectArray: { type: 'any[]' },
+    objectArrayArray: { type: 'any[][]' },
+  },
 });
 
 ////////////////////////////////////////////////////////////////////
@@ -63,21 +63,21 @@ export class Dependent_Mock extends DyFM_Metadata {
   }
 }
 
-export const dependent_mock_DataParams = new DyFM_DataModel_Params({
+export const dependent_mock_DataParams = new DyFM_DataModel_Params<Dependent_Mock>({
   dataName: 'dependentMock',
-  properties: [
-    { key: 'dependencyId', type: 'string',
+  properties: {
+    dependencyId: { type: 'string',
       unique: true, required: true,
       isDependencyHook: true,
       dependencyDataName:  dependency_mock_DataParams.dataName,
     },
-    { key: 'string', type: 'string' },
-    { key: 'number', type: 'number' },
-    { key: 'date', type: 'Date' },
-    { key: 'boolean', type: 'boolean' },
-    { key: 'array', type: 'string[]' },
-    { key: 'object', type: 'any' },
-    { key: 'objectArray', type: 'any[]' },
-    { key: 'objectArrayArray', type: 'any[][]' },
-  ],
+    string: { type: 'string' },
+    number: { type: 'number' },
+    date: { type: 'Date' },
+    boolean: { type: 'boolean' },
+    array: { type: 'string[]' },
+    object: { type: 'any' },
+    objectArray: { type: 'any[]' },
+    objectArrayArray: { type: 'any[][]' },
+  },
 });

package/src/_modules/mock/email-service-collection.mock.spec.ts

@@ -0,0 +1,24 @@
+
+import { EmailServiceCollection_Mock } from './email-service-collection.mock';
+import { EmailService_Mock } from './email-service.mock';
+
+describe('EmailServiceCollection_Mock', () => {
+  let emailServiceCollectionMock: EmailServiceCollection_Mock;
+
+  beforeEach(() => {
+    emailServiceCollectionMock = EmailServiceCollection_Mock.getInstance();
+  });
+
+  it('should create an instance of EmailServiceCollection_Mock', () => {
+    expect(emailServiceCollectionMock).toBeTruthy();
+  });
+
+  it('should return a singleton instance', () => {
+    const anotherInstance = EmailServiceCollection_Mock.getInstance();
+    expect(emailServiceCollectionMock).toBe(anotherInstance);
+  });
+
+  it('should have a test property of type EmailService_Mock', () => {
+    expect(emailServiceCollectionMock.test).toBeInstanceOf(EmailService_Mock);
+  });
+});

package/src/_modules/mock/email-service.mock.spec.ts

@@ -0,0 +1,17 @@
+
+import {
+  DyNTS_EmailService
+} from '../../_services/core/email.service';
+import { EmailService_Mock } from './email-service.mock';
+
+describe('EmailService_Mock', () => {
+  let emailServiceMock: EmailService_Mock;
+
+  beforeEach(() => {
+    emailServiceMock = new EmailService_Mock();
+  });
+
+  it('should be an instance of DyNTS_EmailService', () => {
+    expect(emailServiceMock instanceof DyNTS_EmailService).toBeTrue();
+  });
+});

package/src/_modules/mock/socket-client.mock.spec.ts

@@ -0,0 +1,40 @@
+
+import { DyFM_SocketEvent, DyFM_SocketEvent_Key } from '@futdevpro/fsm-dynamo/socket';
+
+import {
+  DyNTS_SocketClientService_Params
+} from '../socket/_models/socket-client-service-params.control-model';
+import { SocketClient_Mock } from './socket-client.mock';
+
+describe('SocketClient_Mock', () => {
+  let socketClientMock: SocketClient_Mock;
+
+  beforeEach(() => {
+    socketClientMock = SocketClient_Mock.getInstance();
+  });
+
+  it('should create an instance of SocketClient_Mock', () => {
+    expect(socketClientMock).toBeTruthy();
+  });
+
+  it('should return the correct incoming events', () => {
+    const events = socketClientMock.getIncomingEvents();
+
+    expect(events.length).toBe(1);
+    expect(events[0]).toEqual(jasmine.any(DyFM_SocketEvent));
+    expect(events[0].name).toBe('connect');
+    expect(events[0].eventKey).toBe(DyFM_SocketEvent_Key.connect);
+    expect(events[0].tasks.length).toBe(1);
+    expect(events[0].tasks[0]).toEqual(jasmine.any(Function));
+  });
+
+  it('should return the correct parameters', () => {
+    const params = socketClientMock.getParams();
+
+    expect(params).toEqual(jasmine.any(DyNTS_SocketClientService_Params));
+    expect(params.service).toBe('-test-socket-target-');
+    expect(params.name).toBe('socket-client-mock');
+    expect(params.port).toBe(30303);
+    expect(params.socketOptions.reconnection).toBeTrue();
+  });
+});

package/src/_modules/mock/socket-client.mock.ts

@@ -1,8 +1,8 @@
 
 import { DyFM_SocketEvent, DyFM_SocketEvent_Key } from '@futdevpro/fsm-dynamo/socket';
 
-import { 
-  DyNTS_SocketClientService_Params 
+import {
+  DyNTS_SocketClientService_Params
 } from '../socket/_models/socket-client-service-params.control-model';
 import { DyNTS_SocketClient_ServiceBase } from '../socket/_services/socket-client.service';
 
@@ -24,8 +24,8 @@ export class SocketClient_Mock extends DyNTS_SocketClient_ServiceBase {
         tasks: [
           async (content: any, issuer: string) => {
             console.log('SocketClient_Mock: connect event received');
-          }
-        ]
+          },
+        ],
       }),
     ];
   }

package/src/_modules/mock/socket-server.mock.spec.ts

@@ -0,0 +1,44 @@
+
+import {
+  DyNTS_SocketServerService_Params
+} from '../socket/_models/socket-server-service-params.control-model';
+import { DyNTS_SocketServer_Mock } from './socket-server.mock';
+
+describe('DyNTS_SocketServer_Mock', () => {
+  let socketServerMock: DyNTS_SocketServer_Mock;
+
+  beforeEach(() => {
+    socketServerMock = DyNTS_SocketServer_Mock.getInstance();
+  });
+
+  it('should return an instance of DyNTS_SocketServer_Mock', () => {
+    expect(socketServerMock).toBeInstanceOf(DyNTS_SocketServer_Mock);
+  });
+
+  it('should return correct service parameters', () => {
+    const params = socketServerMock.getServiceParams();
+
+    expect(params).toBeInstanceOf(DyNTS_SocketServerService_Params);
+    expect(params.name).toBe('test');
+    expect(params.port).toBe(9393);
+  });
+
+  it('should return an empty array for incoming events', () => {
+    const events = socketServerMock.getIncomingEvents();
+
+    expect(events).toEqual([]);
+  });
+
+  /* it('should return correct presence from subscription event content', async () => {
+    const mockSocketSubscription = { issuerId: 'testIssuerId' };
+    const mockSocket = {} as Socket;
+
+    const presence = await socketServerMock.getPresenceFromSubscriptionEventContent(
+      mockSocketSubscription, mockSocket);
+
+    expect(presence).toBeInstanceOf(DyNTS_SocketPresence);
+    expect(presence.issuerLocalId).toBe('testIssuerId');
+    expect(presence.sockets).toEqual([ mockSocket ]);
+    expect(presence.issuer).toBe('ISSUER socketServer_Mock');
+  }); */
+});

package/src/_modules/mock/socket-server.mock.ts

@@ -1,11 +1,11 @@
-import { Socket } from 'socket.io';
 import { DyFM_SocketEvent } from '@futdevpro/fsm-dynamo/socket';
+import { Socket } from 'socket.io';
 
-import { 
-  DyNTS_SocketPresence 
+import {
+  DyNTS_SocketPresence
 } from '../socket/_models/socket-presence.control-model';
-import { 
-  DyNTS_SocketServerService_Params 
+import {
+  DyNTS_SocketServerService_Params
 } from '../socket/_models/socket-server-service-params.control-model';
 import { DyNTS_SocketServerService } from '../socket/_services/socket-server.service';
 

package/src/_modules/socket/_models/socket-client-service-params.control-model.spec.ts

@@ -0,0 +1,30 @@
+
+import { DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_SocketClientService_Params } from './socket-client-service-params.control-model';
+
+describe('DyNTS_SocketClientService_Params', () => {
+  it('should create an instance with default address', () => {
+    const params = new DyNTS_SocketClientService_Params({});
+
+    expect(params).toBeTruthy();
+    expect(params.address).toBe('ws://localhost');
+  });
+
+  it('should log information on creation', () => {
+    spyOn(DyFM_Log, 'H_info');
+
+    const params = new DyNTS_SocketClientService_Params({});
+
+    expect(DyFM_Log.H_info).toHaveBeenCalledWith(
+      'DyNTS_SocketClientService_Params (test this with custom address!)',
+      'ws://localhost'
+    );
+  });
+
+  xit('should allow overriding the address', () => {
+    const customAddress = 'ws://custom-address';
+    const params = new DyNTS_SocketClientService_Params({ address: customAddress });
+
+    expect(params.address).toBe(customAddress);
+  });
+});

package/src/_modules/socket/_models/socket-server-service-params.control-model.spec.ts

@@ -0,0 +1,33 @@
+
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_SocketSecurity } from '../_enums/socket-security.enum';
+import { DyNTS_SocketServerService_Params } from './socket-server-service-params.control-model';
+
+describe('DyNTS_SocketServerService_Params', () => {
+  it('should create an instance with provided values', () => {
+    const params = {
+      name: 'TestSocket',
+      port: 8080,
+      security: DyNTS_SocketSecurity.secure,
+    };
+
+    const instance = new DyNTS_SocketServerService_Params(params);
+
+    expect(instance.name).toBe('TestSocket');
+    expect(instance.port).toBe(8080);
+    expect(instance.security).toBe(DyNTS_SocketSecurity.secure);
+  });
+
+  it('should use default security if not provided', () => {
+    const params = {
+      name: 'TestSocket',
+      port: 8080,
+    };
+
+    const instance = new DyNTS_SocketServerService_Params(params);
+
+    expect(instance.name).toBe('TestSocket');
+    expect(instance.port).toBe(8080);
+    expect(instance.security).toBe(DyNTS_global_settings.defaultSocketSecurity);
+  });
+});

package/src/_modules/socket/_services/socket-server.service.spec.ts

@@ -4,7 +4,7 @@ import { DyNTS_SocketServer_Mock } from '../../mock/socket-server.mock';
 
 describe('DyNTS_SocketServerService', () => {
   it('should create an instance', () => {
-    expect(new DyNTS_SocketServer_Mock()).toBeTruthy();
+    expect(DyNTS_SocketServer_Mock.getInstance()).toBeTruthy();
   });
 });
 

package/src/_modules/socket/_services/socket-server.service.ts

@@ -64,7 +64,7 @@ export abstract class DyNTS_SocketServerService<
     `We encountered an unhandled Socket Server Error, ` +
     `\nplease contact the responsible development team.`;
 
-  constructor(){
+  protected constructor(){
     super();
 
     this.asyncConstructor().catch((error: any) => {
@@ -222,7 +222,7 @@ export abstract class DyNTS_SocketServerService<
           }));
         }
 
-        this.subscriptionEvent.socketName = this.params.name;
+        this.subscriptionEvent.name = this.params.name;
       } else {
         DyFM_Log.error(
           'getPresenceFromSubscriptionEventContent is not set', 

package/src/_modules/test/get-test-routing-module.util.ts

@@ -1,8 +1,8 @@
 
 import { DyFM_testModule_settings } from '@futdevpro/fsm-dynamo/test';
 import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
-import { 
-  DyNTS_RoutingModule_Settings 
+import {
+  DyNTS_RoutingModule_Settings
 } from '../../_models/interfaces/routing-module-settings.interface';
 import { DyNTS_RoutingModule } from '../../_services/route/routing-module.service';
 import { DyNTS_Test_Controller } from './test.controller';

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

@@ -2,17 +2,17 @@
 import { Request, Response } from 'express';
 
 import { DyFM_RelativeDate } from '@futdevpro/fsm-dynamo';
-import { 
-  DyFM_usageModule_settings, DyFM_UsageSession 
+import {
+  DyFM_usageModule_settings, DyFM_UsageSession
 } from '@futdevpro/fsm-dynamo/usage';
 
 import { DyNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
+import {
+  DyNTS_Endpoint_Params
+} from '../../_models/control-models/endpoint-params.control-model';
 import { DyNTS_AuthService } from '../../_services/core/auth.service';
-import { DyNTS_Controller } from '../../_services/route/controller.service';
 import { DyNTS_GlobalService } from '../../_services/core/global.service';
-import { 
-  DyNTS_Endpoint_Params 
-} from '../../_models/control-models/endpoint-params.control-model';
+import { DyNTS_Controller } from '../../_services/route/controller.service';
 import { DyNTS_Usage_DataService } from './usage.data-service';
 
 export class DyNTS_Usage_Controller extends DyNTS_Controller {
@@ -106,10 +106,12 @@ export class DyNTS_Usage_Controller extends DyNTS_Controller {
         endpoint: DyFM_usageModule_settings.endPoints.getUsageData,
         preProcesses: [ this.authService.authenticate_tokenPerm_accUsageData ],
         tasks: [
-          async (req: Request, res: Response): Promise<void> => {
+          async (req: Request, res: Response, issuer: string): Promise<void> => {
             const range: DyFM_RelativeDate = req.params.range as DyFM_RelativeDate;
 
-            const usageService = new DyNTS_Usage_DataService();
+            const usageService = new DyNTS_Usage_DataService({
+              issuer: issuer,
+            });
 
             await usageService.getUsage(range);
 

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

@@ -1,8 +1,11 @@
 
+import { DyFM_Error, DyFM_RelativeDate, DyFM_Time } from '@futdevpro/fsm-dynamo';
+import {
+  DyFM_DailyUsageData,
+  DyFM_UsageData,
+  DyFM_UsageSession, DyFM_usageSession_dataParams
+} from '@futdevpro/fsm-dynamo/usage';
 import { Request } from 'express';
-import { DyFM_Error, DyFM_Time, DyFM_RelativeDate } from '@futdevpro/fsm-dynamo';
-import { DyFM_UsageSession, DyFM_usageSession_dataParams, DyFM_UsageData, 
-  DyFM_DailyUsageData } from '@futdevpro/fsm-dynamo/usage';
 
 import { DyNTS_DataService } from '../../_services/base/data.service';
 import { DyNTS_Shared } from '../../_services/shared.static-service';
@@ -12,18 +15,18 @@ export class DyNTS_Usage_DataService extends DyNTS_DataService<DyFM_UsageSession
   simplifiedDailyUsage: DyFM_DailyUsageData[] = [];
 
   constructor(
-    set?: {
+    set: {
       usageSession?: DyFM_UsageSession,
       usageData?: DyFM_UsageData[],
-      issuer?: string,
+      issuer: string,
     }
   ) {
     super(
       new DyFM_UsageSession(set?.usageSession),
       DyFM_usageSession_dataParams,
-      set?.issuer
+      set.issuer
     );
-    this.usageData = set?.usageData ? set?.usageData : [];
+    this.usageData = set?.usageData ?? [];
   }
 
   getLocationDataFromRequest(req: Request): void {

package/src/_services/base/archive-data.service.ts

@@ -3,7 +3,7 @@ import {
   DyFM_DataModel_Params,
   DyFM_DBFilterSimple,
   DyFM_Error,
-  DyFM_Metadata,
+  DyFM_Metadata
 } from '@futdevpro/fsm-dynamo';
 
 import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
@@ -28,7 +28,7 @@ export class DyNTS_ArchiveDataService<T extends DyFM_Metadata> extends DyNTS_Dat
     /**
      * DB data prams will be used to connect to usable dbService on GlobalService
      */
-    dataParams: DyFM_DataModel_Params,
+    dataParams: DyFM_DataModel_Params<T>,
     /**
      * Initial set for issuer to be able to follow the issuer's activity
      */