@futdevpro/nts-dynamo 1.9.50 → 1.10.1

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

@@ -0,0 +1,47 @@
+
+import { Request, Response } from 'express';
+import { AuthService_Mock } from './auth-service.mock';
+
+describe('AuthService_Mock', () => {
+  let authServiceMock: AuthService_Mock;
+
+  beforeEach(() => {
+    authServiceMock = AuthService_Mock.getInstance();
+  });
+
+  it('should return a singleton instance', () => {
+    const instance1 = AuthService_Mock.getInstance();
+    const instance2 = AuthService_Mock.getInstance();
+    expect(instance1).toBe(instance2);
+  });
+
+  it('should return "accountId_mock" from getIssuerFromRequest', () => {
+    const req = {} as Request;
+    const issuer = authServiceMock.getIssuerFromRequest(req);
+    expect(issuer).toBe('accountId_mock');
+  });
+
+  it('should return "username_mock" from getUsernameFromRequest', () => {
+    const req = {} as Request;
+    const username = authServiceMock.getUsernameFromRequest(req);
+    expect(username).toBe('username_mock');
+  });
+
+  it('should have an authenticate_token method', async () => {
+    const req = {} as Request;
+    const res = {} as Response;
+    await expectAsync(authServiceMock.authenticate_token(req, res)).toBeResolved();
+  });
+
+  it('should have an authenticate_tokenSelf method', async () => {
+    const req = {} as Request;
+    const res = {} as Response;
+    await expectAsync(authServiceMock.authenticate_tokenSelf(req, res)).toBeResolved();
+  });
+
+  it('should have an authenticate_tokenPerm_accUsageData method', async () => {
+    const req = {} as Request;
+    const res = {} as Response;
+    await expectAsync(authServiceMock.authenticate_tokenPerm_accUsageData(req, res)).toBeResolved();
+  });
+});

package/src/_modules/mock/controller.mock.spec.ts

@@ -0,0 +1,26 @@
+
+import { DyNTS_Controller_Mock } from './controller.mock';
+import { DyNTS_endpoints_mock } from './endpoint.mock';
+
+describe('DyNTS_Controller_Mock', () => {
+  let controllerMock: DyNTS_Controller_Mock;
+
+  beforeEach(() => {
+    controllerMock = DyNTS_Controller_Mock.getInstance();
+  });
+
+  it('should create an instance of DyNTS_Controller_Mock', () => {
+    expect(controllerMock).toBeTruthy();
+    expect(controllerMock instanceof DyNTS_Controller_Mock).toBeTrue();
+  });
+
+  it('should setup endpoints correctly', () => {
+    controllerMock.setupEndpoints();
+    expect(controllerMock.endpoints).toEqual(DyNTS_endpoints_mock);
+  });
+
+  it('should return the same instance on multiple getInstance calls', () => {
+    const anotherInstance = DyNTS_Controller_Mock.getInstance();
+    expect(controllerMock).toBe(anotherInstance);
+  });
+});

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/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/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.ts

@@ -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/data.service.ts

@@ -3,13 +3,16 @@ import {
   DyFM_AnyError,
   DyFM_Array,
   DyFM_Data_Params,
-  DyFM_DataModel_Params, DyFM_DataProperty_Params,
+  DyFM_DataModel_Params,
+  DyFM_DataProperty_Params,
   DyFM_DBFilter,
   DyFM_Error,
-  DyFM_Error_Settings, DyFM_ErrorLevel,
+  DyFM_Error_Settings,
+  DyFM_ErrorLevel,
   DyFM_Log,
   DyFM_Metadata,
-  DyFM_SearchQuery
+  DyFM_SearchQuery,
+  DyFM_SearchResult
 } from '@futdevpro/fsm-dynamo';
 
 import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
@@ -27,16 +30,16 @@ import { DyNTS_DBService } from './db.service';
  * @example
  * export class UserMatchStatisticsService extends DyNTS_DataService<UserMatchStatistics> {
  *   constructor(
- *     set?: {
+ *     set: {
  *       data?: UserMatchStatistics,
- *       issuer?: string,
+ *       issuer: string,
  *     }
  *   ) {
  *     super(
  *       new UserMatchStatistics(set?.data),
  *       userMatchStatisticsModelParams
  *     );
- *     this.issuer = set?.issuer;
+ *     this.issuer = set.issuer;
  *   }
  * }
  */
@@ -1083,10 +1086,15 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
     }
   }
 
-  async searchData(query?: DyFM_SearchQuery<T>): Promise<T[]> {
+  async searchData(query?: DyFM_SearchQuery<T>): Promise<DyFM_SearchResult<T>> {
     try {
       if (!query || Object.keys(query).length === 0) {
-        return await this.getAll();
+        const allData: T[] = await this.getAll();
+
+        return {
+          results: allData,
+          total: allData.length,
+        };
       }
 
       if (!query.filterBy) {
@@ -1094,7 +1102,12 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
       }
       
       if (!query.page && !query.pageSize && !query.sortBy) {
-        return await this.dataDBService.find(query.filterBy);
+        const dataFindResult: T[] = await this.dataDBService.find(query.filterBy);
+
+        return {
+          results: dataFindResult,
+          total: dataFindResult.length,
+        };
       }
 
       if (!query.page) {
@@ -1110,12 +1123,18 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
         query.sortBy = { __lastModified: -1 };
       }
 
-      return await this.dataDBService.findWithPaging(
-        query.filterBy,
-        query.page,
-        query.pageSize,
-        query.sortBy
-      );
+      const dataFindWithPagingResult: T[] = 
+        await this.dataDBService.findWithPaging(
+          query.filterBy,
+          query.page,
+          query.pageSize,
+          query.sortBy
+        );
+
+      return {
+        results: dataFindWithPagingResult,
+        total: dataFindWithPagingResult.length,
+      };
     } catch (error) {
       throw new DyFM_Error({ 
         ...this._getDefaultErrorSettings('searchData', error),

package/src/_services/base/db.service.ts

@@ -104,7 +104,10 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
         throw new DyFM_Error({ 
           ...this._getDefaultErrorSettings('createData', error, issuer),
           errorCode: 'NTS-DBS-CD0',
-          additionalContent: { data, dataModel },
+          additionalContent: { 
+            data: data, 
+            dataModel: this.dataModel,
+          },
           message: 
             `createData failed, Create new "${this.dataParams.dbName}" was unsuccessful (NTS DB)`, 
           issuer,
@@ -1034,6 +1037,12 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
     }
 
     Object.values(properties).forEach((property: DyFM_DataProperty_Params<any>): void => {
+      if (!property) {
+        DyFM_Log.warn(`property is undefined on ${this.dataParams.dbName} (NTS DB)`);
+        
+        return;
+      }
+
       const beType = this.getBEType(property.type);
 
       if (

package/src/_services/base/singleton.service-base.ts

@@ -1,6 +1,4 @@
-import { DyFM_AnyError, DyFM_Error_Settings, DyFM_Error } from '@futdevpro/fsm-dynamo';
 
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
 
 /**
  *