@futdevpro/nts-dynamo 1.9.45 → 1.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futdevpro/nts-dynamo",
-  "version": "01.09.45",
+  "version": "01.10.01",
   "description": "Dynamic NodeTS (NodeJS-Typescript), MongoDB Backend System Framework by Future Development Program Ltd.",
   "scripts": {
     "prep": "npm i rimraf nodemon -g",
@@ -90,11 +90,11 @@
   },
   "homepage": "https:/futdevpro.hu/projects/dynamo",
   "DISABLED": {
-    "@futdevpro/fsm-dynamo": "file:../tgz-collection/dynamo-fsm/futdevpro-fsm-dynamo-01.09.43.tgz",
+    "@futdevpro/fsm-dynamo": "file:../tgz-collection/dynamo-fsm/futdevpro-fsm-dynamo-01.10.02.tgz",
     "empty": ""
   },
   "peerDependencies": {
-    "@futdevpro/fsm-dynamo": "~1.9.43",
+    "@futdevpro/fsm-dynamo": "1.10.2",
 
     "@types/express": "~4.17.17",
     "@types/geoip-lite": "~1.4.1",
@@ -106,18 +106,18 @@
     "mongoose": "~5.13.20",
     "nodemailer": "~6.9.4",
     "rxjs": "~7.8.1",
-    "ts-node": "~10.9.1",
+    "ts-node": "~10.9.2",
     "body-parser": "~1.20.2"
   },
   "peerDevDependencies": {
   },
   "devDependencies": {
     "@types/jasmine": "~4.3.5",
-    "@typescript-eslint/eslint-plugin": "~6.7.4",
-    "@typescript-eslint/parser": "~6.7.4",
-    "eslint": "~8.51.0",
+    "@typescript-eslint/eslint-plugin": "^8.18.2",
+    "@typescript-eslint/parser": "^8.18.2",
+    "eslint": "~8.57.0",
     "eslint-plugin-max-params-no-constructor": "~0.0.4",
-    "eslint-plugin-unused-imports": "~3.0.0",
+    "eslint-plugin-unused-imports": "~4.1.4",
     "jasmine": "~5.0.2",
     "jasmine-ts": "~0.4.0",
     "socket.io": "~4.7.2",

package/spec/support/jasmine.json

@@ -1,4 +1,12 @@
 {
+  "reporters": [
+    {
+      "name": "jasmine-json-reporter",
+      "options": {
+        "pretty": true
+      }
+    }
+  ],
   "spec_dir": "build/",
   "spec_files": [
     "**/*.spec.ts",

package/src/_collections/archive.util.spec.ts

@@ -0,0 +1,22 @@
+
+import { DyNTS_getArchivedDBName, DyNTS_archiveSuffix } from './archive.util';
+
+describe('DyNTS_getArchivedDBName', () => {
+  it('should append the archive suffix to the database name', () => {
+    const dbName = 'TestDB';
+    const expectedArchivedName = `${dbName}${DyNTS_archiveSuffix}`;
+    expect(DyNTS_getArchivedDBName(dbName)).toBe(expectedArchivedName);
+  });
+
+  it('should return only the archive suffix when the database name is an empty string', () => {
+    const dbName = '';
+    const expectedArchivedName = DyNTS_archiveSuffix;
+    expect(DyNTS_getArchivedDBName(dbName)).toBe(expectedArchivedName);
+  });
+
+  it('should handle database names with special characters', () => {
+    const dbName = 'Test_DB-123!';
+    const expectedArchivedName = `${dbName}${DyNTS_archiveSuffix}`;
+    expect(DyNTS_getArchivedDBName(dbName)).toBe(expectedArchivedName);
+  });
+});

package/src/_models/control-models/api-call-params.control-model.spec.ts

@@ -0,0 +1,94 @@
+
+import { DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
+import { DyNTS_HttpResponseType } from '../../_enums/http/http-response-type.enum';
+import { DyNTS_ApiCall_Params, DyNTS_HttpOptions } from './api-call-params.control-model';
+
+describe('DyNTS_ApiCall_Params', () => {
+  it('should create an instance with default values', () => {
+    const params = new DyNTS_ApiCall_Params({
+      name: 'testCall',
+      type: DyNTS_HttpCallType.get,
+      endPoint: '/test/endpoint',
+      baseUrl: 'https://example.com/api',
+    });
+
+    expect(params.name).toBe('testCall');
+    expect(params.type).toBe(DyNTS_HttpCallType.get);
+    expect(params.endPoint).toBe('/test/endpoint');
+    expect(params.baseUrl).toBe('https://example.com/api');
+    expect(params.getFullResponse).toBe(false);
+    expect(params.httpOptions).toEqual({});
+  });
+
+  it('should create an instance with provided values', () => {
+    const httpOptions = new DyNTS_HttpOptions({
+      responseType: DyNTS_HttpResponseType.json,
+      headers: { 'Content-Type': 'application/json' },
+      observe: 'body',
+      reportProgress: true,
+      withCredentials: true,
+    });
+
+    const params = new DyNTS_ApiCall_Params({
+      name: 'testCall',
+      type: DyNTS_HttpCallType.post,
+      endPoint: '/test/endpoint',
+      baseUrl: 'https://example.com/api',
+      getFullResponse: true,
+      httpOptions: httpOptions,
+    });
+
+    expect(params.name).toBe('testCall');
+    expect(params.type).toBe(DyNTS_HttpCallType.post);
+    expect(params.endPoint).toBe('/test/endpoint');
+    expect(params.baseUrl).toBe('https://example.com/api');
+    expect(params.getFullResponse).toBe(true);
+    expect(params.httpOptions).toEqual(httpOptions);
+  });
+
+  xit('should replace deprecated endpoint parameter braces', () => {
+    spyOn(DyFM_Log, 'warn');
+
+    const params = new DyNTS_ApiCall_Params({
+      name: 'testCall',
+      type: DyNTS_HttpCallType.get,
+      endPoint: '/test/{param}/endpoint',
+      baseUrl: 'https://example.com/api',
+    });
+
+    expect(DyFM_Log.warn).toHaveBeenCalledWith(
+      'using {param} bracets in endpoint definitions will be deprecated... (/test/{param}/endpoint)' +
+      'use :param instead ({pathparam} --> :pathparam)'
+    );
+    expect(params.endPoint).toBe('/test/:param/endpoint');
+  });
+});
+
+describe('DyNTS_HttpOptions', () => {
+  it('should create an instance with default values', () => {
+    const options = new DyNTS_HttpOptions({});
+
+    expect(options.responseType).toBeUndefined();
+    expect(options.headers).toBeUndefined();
+    expect(options.observe).toBeUndefined();
+    expect(options.reportProgress).toBeUndefined();
+    expect(options.withCredentials).toBeUndefined();
+  });
+
+  it('should create an instance with provided values', () => {
+    const options = new DyNTS_HttpOptions({
+      responseType: DyNTS_HttpResponseType.json,
+      headers: { 'Content-Type': 'application/json' },
+      observe: 'body',
+      reportProgress: true,
+      withCredentials: true,
+    });
+
+    expect(options.responseType).toBe(DyNTS_HttpResponseType.json);
+    expect(options.headers).toEqual({ 'Content-Type': 'application/json' });
+    expect(options.observe).toBe('body');
+    expect(options.reportProgress).toBe(true);
+    expect(options.withCredentials).toBe(true);
+  });
+});

package/src/_models/control-models/app-params.control-model.spec.ts

@@ -0,0 +1,69 @@
+
+import { DyNTS_App_Params } from './app-params.control-model';
+
+describe('DyNTS_App_Params', () => {
+  it('should initialize with provided values', () => {
+    const params: DyNTS_App_Params = {
+      name: 'TestApp',
+      title: 'Test Application',
+      version: '1.0.0',
+      dbName: 'testdb',
+      dbUri: 'mongodb://localhost:27017/testdb',
+      systemName: 'Test-App',
+      systemShortCodeName: 'TA'
+    };
+
+    const appParams = new DyNTS_App_Params(params);
+
+    expect(appParams.name).toBe('TestApp');
+    expect(appParams.title).toBe('Test Application');
+    expect(appParams.version).toBe('1.0.0');
+    expect(appParams.dbName).toBe('testdb');
+    expect(appParams.dbUri).toBe('mongodb://localhost:27017/testdb');
+    expect(appParams.systemName).toBe('Test-App');
+    expect(appParams.systemShortCodeName).toBe('TA');
+  });
+
+  it('should set default values when optional parameters are not provided', () => {
+    const params: DyNTS_App_Params = {
+      name: 'TestApp',
+      version: '1.0.0',
+      dbName: 'testdb'
+    };
+
+    const appParams = new DyNTS_App_Params(params);
+
+    expect(appParams.name).toBe('TestApp');
+    expect(appParams.title).toBe('');
+    expect(appParams.version).toBe('1.0.0');
+    expect(appParams.dbName).toBe('testdb');
+    expect(appParams.dbUri).toBe('mongodb://localhost:27017/testdb');
+    expect(appParams.systemName).toBe('TestApp');
+    expect(appParams.systemShortCodeName).toBe('TA');
+  });
+
+  it('should generate systemShortCodeName from systemName if not provided', () => {
+    const params: DyNTS_App_Params = {
+      name: 'Test Application',
+      version: '1.0.0',
+      dbName: 'testdb',
+      systemName: 'Test-App'
+    };
+
+    const appParams = new DyNTS_App_Params(params);
+
+    expect(appParams.systemShortCodeName).toBe('TA');
+  });
+
+  it('should generate systemName from name if not provided', () => {
+    const params: DyNTS_App_Params = {
+      name: 'Test Application',
+      version: '1.0.0',
+      dbName: 'testdb'
+    };
+
+    const appParams = new DyNTS_App_Params(params);
+
+    expect(appParams.systemName).toBe('Test-Application');
+  });
+});

package/src/_models/control-models/app-system-controls.control-model.spec.ts

@@ -0,0 +1,31 @@
+
+import { DyNTS_AppSystemControls } from './app-system-controls.control-model';
+import { DyNTS_SystemControl } from './system-control.control-model';
+
+describe('DyNTS_AppSystemControls', () => {
+  let appSystemControls: DyNTS_AppSystemControls;
+
+  beforeEach(() => {
+    appSystemControls = new DyNTS_AppSystemControls();
+  });
+
+  it('should create an instance of DyNTS_AppSystemControls', () => {
+    expect(appSystemControls).toBeTruthy();
+  });
+
+  it('should initialize "app" as an instance of DyNTS_SystemControl', () => {
+    expect(appSystemControls.app).toBeInstanceOf(DyNTS_SystemControl);
+  });
+
+  it('should initialize "mongoose" as an instance of DyNTS_SystemControl', () => {
+    expect(appSystemControls.mongoose).toBeInstanceOf(DyNTS_SystemControl);
+  });
+
+  it('should initialize "httpServer" as an instance of DyNTS_SystemControl', () => {
+    expect(appSystemControls.httpServer).toBeInstanceOf(DyNTS_SystemControl);
+  });
+
+  it('should initialize "httpsServer" as an instance of DyNTS_SystemControl', () => {
+    expect(appSystemControls.httpsServer).toBeInstanceOf(DyNTS_SystemControl);
+  });
+});

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

@@ -2,10 +2,11 @@
 
 import { Request, Response } from 'express';
 
-import { DyFM_Array, DyFM_Error, DyFM_errorFlag, DyFM_Log, DyFM_Shared } from '@futdevpro/fsm-dynamo';
-import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
-import { DyNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
+import { DyFM_Array, DyFM_Error, DyFM_Log, DyFM_Shared } from '@futdevpro/fsm-dynamo';
+
 import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { DyNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
+import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
 import { DyNTS_GlobalService } from '../../_services/core/global.service';
 
 /**
@@ -114,7 +115,7 @@ export class DyNTS_Endpoint_Params {
           status: 406, 
           errorCode: 'NTS-EP0-C00',
           addECToUserMsg: true,
-          message: 'trying to create DyNTS_EndpointParams without endpoint value',
+          message: 'trying to create DyNTS_Endpoint_Params without endpoint value',
           userMessage: 
             'We encountered an unhandled Server Error, ' +
             'please contact the responsible development team.',
@@ -361,7 +362,7 @@ export class DyNTS_Endpoint_Params {
   ): void {
     if (DyNTS_global_settings.log_settings.highDetailedLogs) {
       DyFM_Log.H_error(
-        `\n\nDYNAMO MULTILEVEL ERROR:DyNTS_EndpointParams: error: ` +
+        `\n\nDYNAMO MULTILEVEL ERROR:DyNTS_Endpoint_Params: error: ` +
           `(${this.name}, ${this.endpoint})` +
         `\n(DYNAMO MULTILEVEL ERROR means, that the ERROR HANDLING is ALSO FAILED, ` +
           `and the error message was not sent.)` + 
@@ -370,7 +371,7 @@ export class DyNTS_Endpoint_Params {
       );
     } else {
       DyFM_Log.H_error(
-        `\n\nDYNAMO MULTILEVEL ERROR:DyNTS_EndpointParams: error: ` +
+        `\n\nDYNAMO MULTILEVEL ERROR:DyNTS_Endpoint_Params: error: ` +
           `(${this.name}, ${this.endpoint})` +
         `\n(DYNAMO MULTILEVEL ERROR means, that the ERROR HANDLING is ALSO FAILED, ` +
           `and the error message was not sent.)`

package/src/_models/control-models/http-settings.control-model.spec.ts

@@ -0,0 +1,66 @@
+
+import { DyNTS_Http_Settings } from './http-settings.control-model';
+import * as BodyParser from 'body-parser';
+
+describe('DyNTS_Http_Settings', () => {
+  it('should create an instance with default settings', () => {
+    const settings = new DyNTS_Http_Settings();
+
+    expect(settings.httpPort).toBeUndefined();
+    expect(settings.httpsPort).toBeUndefined();
+    expect(settings.httpUrlencoded).toEqual({
+      limit: '50mb',
+      extended: true,
+    } as BodyParser.OptionsUrlencoded);
+    expect(settings.httpJson).toEqual({
+      limit: '50mb',
+    } as BodyParser.OptionsJson);
+    expect(settings.httpsUrlencoded).toEqual({
+      limit: '50mb',
+      extended: true,
+    } as BodyParser.OptionsUrlencoded);
+    expect(settings.httpsJson).toEqual({
+      limit: '50mb',
+    } as BodyParser.OptionsJson);
+  });
+
+  it('should create an instance with provided settings', () => {
+    const customSettings: DyNTS_Http_Settings = {
+      httpPort: 8080,
+      httpsPort: 8443,
+      httpUrlencoded: {
+        limit: '100mb',
+        extended: false,
+      },
+      httpJson: {
+        limit: '100mb',
+      },
+      httpsUrlencoded: {
+        limit: '100mb',
+        extended: false,
+      },
+      httpsJson: {
+        limit: '100mb',
+      },
+    };
+
+    const settings = new DyNTS_Http_Settings(customSettings);
+
+    expect(settings.httpPort).toBe(8080);
+    expect(settings.httpsPort).toBe(8443);
+    expect(settings.httpUrlencoded).toEqual({
+      limit: '100mb',
+      extended: false,
+    } as BodyParser.OptionsUrlencoded);
+    expect(settings.httpJson).toEqual({
+      limit: '100mb',
+    } as BodyParser.OptionsJson);
+    expect(settings.httpsUrlencoded).toEqual({
+      limit: '100mb',
+      extended: false,
+    } as BodyParser.OptionsUrlencoded);
+    expect(settings.httpsJson).toEqual({
+      limit: '100mb',
+    } as BodyParser.OptionsJson);
+  });
+});

package/src/_models/control-models/system-control.control-model.spec.ts

@@ -0,0 +1,27 @@
+
+import { DyNTS_SystemControl } from './system-control.control-model';
+
+describe('DyNTS_SystemControl', () => {
+  let systemControl: DyNTS_SystemControl;
+
+  beforeEach(() => {
+    systemControl = new DyNTS_SystemControl();
+  });
+
+  it('should return true when init is false', () => {
+    systemControl.init = false;
+    expect(systemControl.getIsReady()).toBeTrue();
+  });
+
+  it('should return true when init is true and started is true', () => {
+    systemControl.init = true;
+    systemControl.started = true;
+    expect(systemControl.getIsReady()).toBeTrue();
+  });
+
+  it('should return false when init is true and started is false', () => {
+    systemControl.init = true;
+    systemControl.started = false;
+    expect(systemControl.getIsReady()).toBeFalse();
+  });
+});

package/src/_models/interfaces/global-service-settings.interface.ts

@@ -6,9 +6,9 @@ import { Request, Response } from 'express';
 
 import { DyFM_DataModel_Params } from '@futdevpro/fsm-dynamo';
 
-import { DyNTS_Service_Collection } from '../../_services/core/service-collection.service';
-import { DyNTS_EmailService } from '../../_services/core/email.service';
 import { DyNTS_AuthService } from '../../_services/core/auth.service';
+import { DyNTS_EmailService } from '../../_services/core/email.service';
+import { DyNTS_Service_Collection } from '../../_services/core/service-collection.service';
 
 
 export interface DyNTS_GlobalService_Settings {
@@ -25,7 +25,7 @@ export interface DyNTS_GlobalService_Settings {
   /**
    * you can setup data tables by passing a DyFM_DataModel_Params list at this point 
    */
-  dbModels?: DyFM_DataModel_Params[],
+  dbModels?: DyFM_DataModel_Params<any>[],
 
   /**
    * you can setup other services by passing a DyNTS_SingletonService list at this point

package/src/_modules/custom-data/custom-data.controller.ts

@@ -4,11 +4,11 @@ import { Request, Response } from 'express';
 import { DyFM_customDataModule_settings } from '@futdevpro/fsm-dynamo/custom-data';
 
 import { DyNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
-import { DyNTS_Controller } from '../../_services/route/controller.service';
-import { DyFM_CustomData_DataService } from './custom-data.data-service';
-import { 
-  DyNTS_Endpoint_Params 
+import {
+  DyNTS_Endpoint_Params
 } from '../../_models/control-models/endpoint-params.control-model';
+import { DyNTS_Controller } from '../../_services/route/controller.service';
+import { DyNTS_CustomData_DataService } from './custom-data.data-service';
 
 export class DyNTS_CustomData_Controller extends DyNTS_Controller {
 
@@ -25,7 +25,7 @@ export class DyNTS_CustomData_Controller extends DyNTS_Controller {
         endpoint: DyFM_customDataModule_settings.endPoints.getCustomData,
         tasks: [
           async (req: Request, res: Response): Promise<void> => {
-            const customDataService = new DyFM_CustomData_DataService({ 
+            const customDataService = new DyNTS_CustomData_DataService({ 
               _id: req.params.customId,
             });
 
@@ -47,7 +47,7 @@ export class DyNTS_CustomData_Controller extends DyNTS_Controller {
         endpoint: DyFM_customDataModule_settings.endPoints.modifyCustomData,
         tasks: [
           async (req: Request, res: Response, issuer: string): Promise<void> => {
-            const customDataService = new DyFM_CustomData_DataService(req.body, issuer);
+            const customDataService = new DyNTS_CustomData_DataService(req.body, issuer);
 
             await customDataService.saveData();
 

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

@@ -1,12 +1,13 @@
 
 
 
-import { 
-  DyFM_customData_dataParams, DyFM_CustomData 
+import {
+  DyFM_CustomData,
+  DyFM_customData_dataParams
 } from '@futdevpro/fsm-dynamo/custom-data';
 import { DyNTS_DataService } from '../../_services/base/data.service';
 
-export class DyFM_CustomData_DataService extends DyNTS_DataService<DyFM_CustomData> {
+export class DyNTS_CustomData_DataService extends DyNTS_DataService<DyFM_CustomData> {
 
   constructor(
     customData?: DyFM_CustomData,

package/src/_modules/mock/app-params.mock.spec.ts

@@ -0,0 +1,21 @@
+
+import { DyNTS_App_Params } from '../../_models/control-models/app-params.control-model';
+import { DyNTS_appParams_mock } from './app-params.mock';
+
+describe('DyNTS_appParams_mock', () => {
+  it('should create an instance of DyNTS_App_Params', () => {
+    expect(DyNTS_appParams_mock).toBeInstanceOf(DyNTS_App_Params);
+  });
+
+  it('should have the correct name', () => {
+    expect(DyNTS_appParams_mock.name).toBe('test');
+  });
+
+  it('should have the correct version', () => {
+    expect(DyNTS_appParams_mock.version).toBe('0.0.1');
+  });
+
+  it('should have the correct dbName', () => {
+    expect(DyNTS_appParams_mock.dbName).toBe('test');
+  });
+});

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);
+  });
+});