@futdevpro/nts-dynamo 1.9.50 → 1.10.2

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,18 @@ import {
   DyFM_AnyError,
   DyFM_Array,
   DyFM_Data_Params,
-  DyFM_DataModel_Params, DyFM_DataProperty_Params,
+  DyFM_DataModel_Params,
+  DyFM_DataProperty_Params,
   DyFM_DBFilter,
+  DyFM_DBĐSort,
   DyFM_Error,
-  DyFM_Error_Settings, DyFM_ErrorLevel,
+  DyFM_Error_Settings,
+  DyFM_ErrorLevel,
   DyFM_Log,
   DyFM_Metadata,
-  DyFM_SearchQuery
+  DyFM_RangeValue,
+  DyFM_SearchQuery,
+  DyFM_SearchResult
 } from '@futdevpro/fsm-dynamo';
 
 import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
@@ -27,16 +32,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,22 +1088,34 @@ 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();
-      }
+      /* if (!query || Object.keys(query).length === 0) {
+        console.log('T1');
+        const allData: T[] = await this.getAll();
+
+        return {
+          results: allData,
+          totalItems: allData.length,
+        };
+      } */
 
       if (!query.filterBy) {
         query.filterBy = {};
       }
       
-      if (!query.page && !query.pageSize && !query.sortBy) {
-        return await this.dataDBService.find(query.filterBy);
-      }
+      /* if (!query.page && !query.pageSize && !query.sortBy) {
+        console.log('T2');
+        const dataFindResult: T[] = await this.dataDBService.find(query.filterBy);
+
+        return {
+          results: dataFindResult,
+          totalItems: dataFindResult.length,
+        };
+      } */
 
       if (!query.page) {
-        query.page = 1;
+        query.page = 0;
       }
 
       if (!query.pageSize) {
@@ -1106,16 +1123,43 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
         query.pageSize = DyNTS_global_settings.defaultPageSize;
       }
 
-      if (!query.sortBy) {
-        query.sortBy = { __lastModified: -1 };
+      if (!query.sortBy?.length) {
+        query.sortBy = [{ key: '__lastModified', order: -1 }];
       }
 
-      return await this.dataDBService.findWithPaging(
+      console.log('T3');
+      /* const dataFindWithPagingResult: T[] = await this.dataDBService.findWithPaging(
         query.filterBy,
         query.page,
         query.pageSize,
         query.sortBy
+      ); */
+      query.sortBy.reverse();
+      
+      let dataList: T[] = await this.getAll();
+      const filterKeys = Object.keys(query.filterBy);
+      const filterFunctionsByKey: { [key: string]: (dataProperty) => boolean } = {};
+
+      filterKeys.forEach((key: string): void => {
+        filterFunctionsByKey[key] = this.getFilterFunctionForKey(
+          key, query.filterBy[key]
+        );
+      });
+
+      query.sortBy.forEach((sort: DyFM_DBĐSort): void => {
+        dataList.sort(this.getSortFunctionForKey(sort.key, sort.order));
+      });
+
+      dataList = dataList.filter(
+        (data: T): boolean => filterKeys.every(
+          (key: string): boolean => filterFunctionsByKey[key](data[key])
+        )
       );
+
+      return {
+        results: dataList,
+        totalItems: dataList.length,
+      };
     } catch (error) {
       throw new DyFM_Error({ 
         ...this._getDefaultErrorSettings('searchData', error),
@@ -1125,6 +1169,180 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
     }
   }
 
+  private getFilterFunctionForKey<T>(
+    key: string, 
+    searchValue: T | T[] | DyFM_RangeValue<T>,
+  ): (dataProperty) => boolean {
+    if (!this.dataParams.properties[key]) {
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings(
+          'getFilterFunctionForKey',
+          new Error(
+            `getFilterFunctionForKey failed, key not found in dataParams ` +
+            `(${this.dataParams.dataName})`
+          )
+        ),
+
+        errorCode: 'NTS-DS0-GFF1',
+      });
+    }
+
+    if (searchValue === undefined) {
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings(
+          'getFilterFunctionForKey',
+          new Error(
+            `getFilterFunctionForKey failed, searchValue is missing! ` +
+            `(${this.dataParams.dataName})`
+          )
+        ),
+
+        errorCode: 'NTS-DS0-GFF2',
+      });
+    }
+
+    switch (this.dataParams.properties[key].type) {
+      case 'String':
+        return (dataProperty): boolean => dataProperty.includes(searchValue);
+
+      case 'Date':
+        if ((searchValue as DyFM_RangeValue).isRange) {
+          const rangeAsNumber = new DyFM_RangeValue<number>(
+            +new Date((searchValue as DyFM_RangeValue).from),
+            +new Date((searchValue as DyFM_RangeValue).to)
+          );
+
+          return (dataProperty): boolean => DyFM_RangeValue.isInRange(
+            +new Date(dataProperty), rangeAsNumber
+          );
+        }
+
+        if (Array.isArray(searchValue)) {
+          const searchValueAsDateArray = (searchValue as Date[]).map(
+            (date: Date): Date => new Date(date)
+          );
+
+          return (dataProperty): boolean => searchValueAsDateArray.includes(new Date(dataProperty));
+        }          
+          
+        const searchValueAsDate: Date = new Date(searchValue as Date);
+
+        return (dataProperty): boolean => new Date(dataProperty) === searchValueAsDate;
+
+      case 'Number':
+        if ((searchValue as DyFM_RangeValue).isRange) {
+          return (dataProperty): boolean => DyFM_RangeValue.isInRange(
+            dataProperty, searchValue as DyFM_RangeValue<number>
+          );
+        }
+
+        if (Array.isArray(searchValue)) {
+          return (dataProperty): boolean => (searchValue as number[]).includes(dataProperty);
+        }
+        
+        return (dataProperty): boolean => dataProperty === searchValue;
+
+      case 'Boolean':
+        return (dataProperty): boolean => dataProperty === searchValue;
+
+      default:
+        if ((searchValue as DyFM_RangeValue).isRange) {
+          throw new DyFM_Error({
+            ...this._getDefaultErrorSettings(
+              'getFilterFunctionForKey',
+              new Error(
+                `getFilterFunctionForKey failed, range search not implemented for this type ` +
+                `(${this.dataParams.dataName})`
+              )
+            ),
+
+            errorCode: 'NTS-DS0-GFF3',
+          });
+        }
+
+        if (Array.isArray(searchValue)) {
+          return (dataProperty): boolean => (searchValue as number[]).includes(dataProperty);
+        }
+        
+        return (dataProperty): boolean => dataProperty === searchValue;
+    }
+  }
+
+  private getSortFunctionForKey<T>(
+    key: string, 
+    sortDirection: 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending'
+  ): (a: T, b: T) => number {
+    if (!this.dataParams.properties[key]) {
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings(
+          'getSortFunctionForKey',
+          new Error(
+            `getSortFunctionForKey failed, key not found in dataParams ` +
+            `(${this.dataParams.dataName})`
+          )
+        ),
+
+        errorCode: 'NTS-DS0-GSF1',
+      });
+    }
+
+    const sortValue: 1 | -1 = (
+      sortDirection === 1 || sortDirection === 'asc' || sortDirection === 'ascending'
+    ) ? 1 : -1;
+
+    switch (this.dataParams.properties[key].type) {
+      case 'String':
+        return (a: T, b: T): number => (a as string).localeCompare(b as string) * sortValue;
+
+      case 'Date':
+        return (a: T, b: T): number => {
+          if (+new Date(a[key]) < +new Date(b[key])) {
+            return -sortValue;
+          } else if (+new Date(a[key]) > +new Date(b[key])) {
+            return sortValue;
+          } else {
+            return 0;
+          }
+        };
+
+      case 'Number':
+        return (a: T, b: T): number => {
+          if (a[key] < b[key]) {
+            return -sortValue;
+          } else if (a[key] > b[key]) {
+            return sortValue;
+          } else {
+            return 0;
+          }
+        };
+
+      case 'Boolean':
+        return (a: T, b: T): number => {
+          if (a[key] === b[key]) {
+            return 0;
+          }
+
+          if (a[key]) {
+            return sortValue;
+          }
+
+          return -sortValue;
+        };
+
+      default:
+        throw new DyFM_Error({
+          ...this._getDefaultErrorSettings(
+            'getSortFunctionForKey',
+            new Error(
+              `getSortFunctionForKey failed, sorting not implemented for this type ` +
+              `(${this.dataParams.dataName}, ${this.dataParams.properties[key].type})`
+            )
+          ),
+
+          errorCode: 'NTS-DS0-GSF2',
+        });
+    }
+  }
 
   /**
    * setting up dependency dataHook by DynamoBEDataModelParams

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,
@@ -707,6 +710,7 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
   /**
    * #MONGOOSE FUNCTION
    * Find the data first by any of its parameters
+   * WARNING: This function will not gives you back the total number of data in the database!
    * 
    * @param filterBy if you can, use unique parameters for find!
    * 
@@ -743,9 +747,9 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
     pageSize: number, 
     sort?: DyFM_DBSort<T>
   ): Promise<T[]> {
-    if (filterBy['_deleted'] === undefined) {
+    /* if (filterBy['_deleted'] === undefined) {
       filterBy['_deleted'] = null;
-    }
+    } */
 
     const dataList: T[] = await this.dataModel
       .find(filterBy)
@@ -1004,17 +1008,17 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
    * @returns schema
    */
   private getSchema(): mongoose.Schema {
-    let schema: any = this.buildMongooseSchemaByModelParams();
+    this.dataParams.properties = this.addMetadataToProperties(this.dataParams.properties);
+
+    let schema: any = this.buildMongooseSchemaByModelParams(this.dataParams.properties);
 
-    schema = this.addMetadataToSchema(schema);
+    /* schema = this.addMetadataToSchema(schema); */
 
     if (this.dataParams.dataName.includes(DyNTS_archiveSuffix)) {
       schema = this.addArchiveMetadataToSchema(schema);
     }
 
-    // tslint:disable-next-line: no-string-literal
     if (schema['_id']) {
-      // tslint:disable-next-line: no-string-literal
       delete schema['_id'];
     }
 
@@ -1026,14 +1030,20 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
    * @param properties DynamoBEDataPropertyParams
    * @returns mongoose schema object
    */
-  private buildMongooseSchemaByModelParams(properties?: DyFM_DataProperties<T>): any {
+  private buildMongooseSchemaByModelParams(properties: DyFM_DataProperties<T>): any {
     const schemaSettingsObj = {};
 
-    if (!properties) {
+    /* if (!properties) {
       properties = this.dataParams.properties;
-    }
+    } */
 
     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 (
@@ -1076,7 +1086,7 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
 
   private getBEType(
     type: string
-  ): String | Number | Boolean | Object | Function | Array<any> | Date {
+  ): string | number | boolean | object | Function | Array<any> | Date {
     switch (type.toLocaleLowerCase()) {
 
       case 'string':
@@ -1110,7 +1120,7 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
    * @param schema schema to update
    * @returns updated schema
    */
-  private addMetadataToSchema(schema: any): any {
+  /* private addMetadataToSchema(schema: any): any {
     schema.__created = { type: Date };
     schema.__createdBy = { type: String };
     schema.__lastModified = { type: Date };
@@ -1120,6 +1130,34 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
     schema._deletedBy = { type: String };
     
     return schema;
+  } */
+
+  private addMetadataToProperties(properties: DyFM_DataProperties<T>): DyFM_DataProperties<T> {
+    if (!properties.__created) {
+      properties.__created = { type: 'Date' };
+    }
+
+    if (!properties.__createdBy) {
+      properties.__createdBy = { type: 'String' };
+    }
+
+    if (!properties.__lastModified) {
+      properties.__lastModified = { type: 'Date' };
+    }
+
+    if (!properties.__lastModifiedBy) {
+      properties.__lastModifiedBy = { type: 'String' };
+    }
+
+    if (!properties._deleted) {
+      properties._deleted = { type: 'Date' };
+    }
+
+    if (!properties._deletedBy) {
+      properties._deletedBy = { type: 'String' };
+    }
+
+    return properties;
   }
 
   private addArchiveMetadataToSchema(schema: any): any {

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';
 
 /**
  * 

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

@@ -0,0 +1,96 @@
+
+import { DyNTS_ApiService, DyNTS_ApiCallInput_Params } from './api.service';
+import { DyNTS_ApiCall_Params } from '../../_models/control-models/api-call-params.control-model';
+import { DyNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
+import { DyNTS_HttpResponseType } from '../../_enums/http/http-response-type.enum';
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+import Axios from 'axios';
+
+describe('DyNTS_ApiService', () => {
+  let callParams: DyNTS_ApiCall_Params;
+  let inputParams: DyNTS_ApiCallInput_Params;
+
+  beforeEach(() => {
+    callParams = {
+      baseUrl: 'http://example.com',
+      endPoint: '/api/test',
+      type: DyNTS_HttpCallType.get,
+      httpOptions: {
+        headers: {},
+        responseType: DyNTS_HttpResponseType.json,
+      },
+      name: 'Test API Call',
+      getFullResponse: false,
+    };
+
+    inputParams = {
+      pathParams: { id: '123' },
+      body: { key: 'value' },
+    };
+  });
+
+  it('should make a GET request successfully', async () => {
+    callParams.type = DyNTS_HttpCallType.get;
+    const response = { data: { success: true } };
+    spyOn(Axios, 'create').and.returnValue({
+      get: jasmine.createSpy().and.returnValue(Promise.resolve(response)),
+    } as any);
+
+    const result = await DyNTS_ApiService.startApiCall(callParams, inputParams);
+    expect(result).toEqual(response.data);
+  });
+
+  it('should handle a POST request successfully', async () => {
+    callParams.type = DyNTS_HttpCallType.post;
+    const response = { data: { success: true } };
+    spyOn(Axios, 'create').and.returnValue({
+      post: jasmine.createSpy().and.returnValue(Promise.resolve(response)),
+    } as any);
+
+    const result = await DyNTS_ApiService.startApiCall(callParams, inputParams);
+    expect(result).toEqual(response.data);
+  });
+
+  it('should throw an error for unsupported HTTP method', async () => {
+    callParams.type = 'unsupported' as DyNTS_HttpCallType;
+
+    await expectAsync(DyNTS_ApiService.startApiCall(callParams, inputParams)).toBeRejectedWith(
+      jasmine.any(DyFM_Error)
+    );
+  });
+
+  it('should handle error response with DYNAMO flag', async () => {
+    const errorResponse = {
+      response: { data: { flag: 'DYNAMO', message: 'Error' } },
+    };
+    spyOn(Axios, 'create').and.returnValue({
+      get: jasmine.createSpy().and.returnValue(Promise.reject(errorResponse)),
+    } as any);
+
+    await expectAsync(DyNTS_ApiService.startApiCall(callParams, inputParams)).toBeRejectedWith(
+      jasmine.any(DyFM_Error)
+    );
+  });
+
+  it('should handle DNS error', async () => {
+    const error = { code: 'ENOTFOUND' };
+    spyOn(Axios, 'create').and.returnValue({
+      get: jasmine.createSpy().and.returnValue(Promise.reject(error)),
+    } as any);
+
+    await expectAsync(DyNTS_ApiService.startApiCall(callParams, inputParams)).toBeRejectedWith(
+      jasmine.any(DyFM_Error)
+    );
+  });
+
+  it('should handle connection refused error', async () => {
+    const error = { code: 'ECONNREFUSED' };
+    spyOn(Axios, 'create').and.returnValue({
+      get: jasmine.createSpy().and.returnValue(Promise.reject(error)),
+    } as any);
+
+    await expectAsync(DyNTS_ApiService.startApiCall(callParams, inputParams)).toBeRejectedWith(
+      jasmine.any(DyFM_Error)
+    );
+  });
+});