@futdevpro/nts-dynamo 1.9.45 → 1.10.1

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

@@ -2,13 +2,17 @@
 import {
   DyFM_AnyError,
   DyFM_Array,
-  DyFM_DataModel_Params, DyFM_DataProperty_Params,
+  DyFM_Data_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';
@@ -26,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;
  *   }
  * }
  */
@@ -56,7 +60,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
   depKeyIsRequired?: boolean;
   private depDataDBService: DyNTS_DBService<any>;
 
-  dataParams: DyFM_DataModel_Params;
+  dataParams: DyFM_DataModel_Params<T>;
 
   readonly defaultErrorUserMsg: string = 
     `We encountered an unhandled Data Service Error, ` +
@@ -73,7 +77,8 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
     /**
      * DB data prams will be used to connect to usable dbService on GlobalService
      */
-    dataParams: DyFM_DataModel_Params,
+    /* dataParams: DyFM_DataModel_Params, */
+    dataParams: DyFM_Data_Params<T>,
     /**
      * Initial set for issuer to be able to follow the issuer's activity
      */
@@ -1005,66 +1010,68 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
     try {
       data = this.ensureData(data);
 
-      for (const element of this.dataParams.properties) {
-        // basic required validations
-        if (
-          (
-            element.required ||
-            element.index
-          ) && (
-            data[element.key] === null || 
-            data[element.key] === undefined
-          )
-        ) {
-          throw new DyFM_Error({ 
-            ...this._getDefaultErrorSettings(
-              'validateForSave',
-              new Error(
-                `validateForSave failed, "${element.key}" is missing! ` +
-                `(${this.dataParams.dataName})`
-              )
-            ),
-
-            status: 522, 
-            errorCode: 'NTS-DS0-VD1',
-            userMessage: this.defaultValidationErrorUserMsg,
-            additionalContent: {
-              data: data,
-            },
-          });
-        }
-
-        // specific Date validation
-        if (element.type === 'Date' && 
-          !(new Date(data[element.key]) instanceof Date)
-        ) {
-          throw new DyFM_Error({
-            ...this._getDefaultErrorSettings(
-              'validateForSave',
-              new Error(
-                `validateForSave failed, "${element.key}" is not a date! ` +
-                `(${this.dataParams.dataName})`
-              )
-            ),
+      Object.values(this.dataParams.properties).forEach(
+        (element: DyFM_DataProperty_Params<any>) => {
+          // basic required validations
+          if (
+            (
+              element.required ||
+              element.index
+            ) && (
+              data[element.key] === null || 
+              data[element.key] === undefined
+            )
+          ) {
+            throw new DyFM_Error({ 
+              ...this._getDefaultErrorSettings(
+                'validateForSave',
+                new Error(
+                  `validateForSave failed, "${element.key}" is missing! ` +
+                  `(${this.dataParams.dataName})`
+                )
+              ),
+
+              status: 522, 
+              errorCode: 'NTS-DS0-VD1',
+              userMessage: this.defaultValidationErrorUserMsg,
+              additionalContent: {
+                data: data,
+              },
+            });
+          }
 
-            status: 522, 
-            errorCode: 'NTS-DS0-VD2',
-            userMessage: this.defaultValidationErrorUserMsg,
-            additionalContent: {
-              data: data,
-            },
-          });
-        }
+          // specific Date validation
+          if (element.type === 'Date' && 
+            !(new Date(data[element.key]) instanceof Date)
+          ) {
+            throw new DyFM_Error({
+              ...this._getDefaultErrorSettings(
+                'validateForSave',
+                new Error(
+                  `validateForSave failed, "${element.key}" is not a date! ` +
+                  `(${this.dataParams.dataName})`
+                )
+              ),
+
+              status: 522, 
+              errorCode: 'NTS-DS0-VD2',
+              userMessage: this.defaultValidationErrorUserMsg,
+              additionalContent: {
+                data: data,
+              },
+            });
+          }
 
-        // call additional validators
-        if (element.additionalValidators) {
-          for (let j = 0; j < element.additionalValidators.length; j++) {
-            element.additionalValidators[j](
-              data[element.key]
-            );
+          // call additional validators
+          if (element.additionalValidators) {
+            for (let j = 0; j < element.additionalValidators.length; j++) {
+              element.additionalValidators[j](
+                data[element.key]
+              );
+            }
           }
         }
-      }
+      );
     } catch (error) {
       if ([ 'NTS-DS0-VD1', 'NTS-DS0-VD2' ].includes(error?.errorCode)) {
         throw error;
@@ -1079,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) {
@@ -1090,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) {
@@ -1106,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),
@@ -1126,9 +1149,10 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
    * setting up dependency dataHook by DynamoBEDataModelParams
    */
   private lookForDependencyDataSettings(): void {
-    const dependencyParam: DyFM_DataProperty_Params = this.dataParams.properties.find(
-      (modelParams: DyFM_DataProperty_Params): boolean => modelParams.isDependencyHook
-    );
+    const dependencyParam: DyFM_DataProperty_Params<any> = 
+      Object.values(this.dataParams.properties).find(
+        (modelParams: DyFM_DataProperty_Params<any>): boolean => modelParams.isDependencyHook
+      );
 
     if (dependencyParam) {
       this.depKey = dependencyParam.key;

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

@@ -4,7 +4,9 @@ import { Schema } from 'mongoose';
 
 import {
   DyFM_AnyError,
-  DyFM_DataModel_Params, DyFM_DataProperty_Params,
+  DyFM_DataModel_Params,
+  DyFM_DataProperties,
+  DyFM_DataProperty_Params,
   DyFM_DBFilter, DyFM_DBFilterSimple, DyFM_DBSort,
   DyFM_Error,
   DyFM_Error_Settings, DyFM_ErrorLevel,
@@ -36,7 +38,7 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
    * schemaSettings also MUST contain specific types that differs from the listed above (Array, Date)
    */
   constructor(
-    public dataParams: DyFM_DataModel_Params
+    public dataParams: DyFM_DataModel_Params<T>
   ){
     try {
       this.serviceName = this.constructor?.name;
@@ -102,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,
@@ -349,7 +354,7 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
         _deleted: new Date(), 
         _deletedBy: issuer,
       }, 
-      issuer
+      /* issuer */
     ).catch(
       (error): void => {
         throw new DyFM_Error({ 
@@ -392,7 +397,7 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
         __lastModified: new Date(),
         __lastModifiedBy: issuer,
       }, 
-      issuer
+      /* issuer */
     ).catch((error): void => {
       throw new DyFM_Error({ 
         ...this._getDefaultErrorSettings('restoreDeletedById', error, issuer),
@@ -531,55 +536,63 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
       filter[this.depDataName] = { $in: narrowByDependencyIds };      
     }
 
-    this.dataParams.properties.forEach((modelParam: DyFM_DataProperty_Params): void => {
-      if (
-        (filterBy[modelParam.key] !== null && filterBy[modelParam.key] !== undefined) || 
-        filterBy[modelParam.key + 'Range']
-      ) {
-        if (modelParam.key.includes('Range') || modelParam.type.includes('[]')) {
-          // inverz search filter (for Range and Array functions)
-          if (modelParam.key.includes('Range')) {
-            const searchParamKeyWithoutRange = modelParam.key.split('Range')[0];
-
-            if (
-              filterBy[searchParamKeyWithoutRange] !== null && 
-              filterBy[searchParamKeyWithoutRange] !== undefined
-            ) {
-              filter[modelParam.key] = {
-                from: { $lte: filterBy[searchParamKeyWithoutRange] },
-                to: { $gte: filterBy[searchParamKeyWithoutRange] },
-              };
+    Object.values(this.dataParams.properties).forEach(
+      (modelParam: DyFM_DataProperty_Params<any>): void => {
+        if (
+          (filterBy[modelParam.key] !== null && filterBy[modelParam.key] !== undefined) || 
+          filterBy[modelParam.key + 'Range']
+        ) {
+          if (modelParam.key.includes('Range') || modelParam.type.includes('[]')) {
+            // inverz search filter (for Range and Array functions)
+            if (modelParam.key.includes('Range')) {
+              const searchParamKeyWithoutRange = modelParam.key.split('Range')[0];
+
+              if (
+                filterBy[searchParamKeyWithoutRange] !== null && 
+                filterBy[searchParamKeyWithoutRange] !== undefined
+              ) {
+                filter[modelParam.key] = {
+                  from: { $lte: filterBy[searchParamKeyWithoutRange] },
+                  to: { $gte: filterBy[searchParamKeyWithoutRange] },
+                };
+              }
+            } else {
+              if (
+                filterBy[modelParam.key] !== null && 
+                filterBy[modelParam.key] !== undefined
+              ) {
+                filter[modelParam.key] = { $in: filterBy[modelParam.key] };
+              }
             }
           } else {
-            if (
+            // basic search filter
+            if (filterBy[modelParam.key + 'Range']) {
+              if (
+                filterBy[modelParam.key + 'Range'].from || 
+                filterBy[modelParam.key + 'Range'].to
+              ) {
+                filter[modelParam.key] = {};
+
+                if (filterBy[modelParam.key + 'Range'].from) {
+                  filter[modelParam.key].$gte = filterBy[modelParam.key + 'Range'].from;
+                }
+
+                if (filterBy[modelParam.key + 'Range'].to) {
+                  filter[modelParam.key].$lte = filterBy[modelParam.key + 'Range'].to;
+                }
+              }
+            } else if (
               filterBy[modelParam.key] !== null && 
               filterBy[modelParam.key] !== undefined
             ) {
-              filter[modelParam.key] = { $in: filterBy[modelParam.key] };
-            }
-          }
-        } else {
-          // basic search filter
-          if (filterBy[modelParam.key + 'Range']) {
-            if (filterBy[modelParam.key + 'Range'].from || filterBy[modelParam.key + 'Range'].to) {
-              filter[modelParam.key] = {};
-
-              if (filterBy[modelParam.key + 'Range'].from) {
-                filter[modelParam.key].$gte = filterBy[modelParam.key + 'Range'].from;
+              if (filterBy[modelParam.key].lenght > 0) {
+                filter[modelParam.key] = { $in: filterBy[modelParam.key] };
               }
-
-              if (filterBy[modelParam.key + 'Range'].to) {
-                filter[modelParam.key].$lte = filterBy[modelParam.key + 'Range'].to;
-              }
-            }
-          } else if (filterBy[modelParam.key] !== null && filterBy[modelParam.key] !== undefined) {
-            if (filterBy[modelParam.key].lenght > 0) {
-              filter[modelParam.key] = { $in: filterBy[modelParam.key] };
             }
           }
         }
       }
-    });
+    );
 
     let dataList: T[] = await this.dataModel
       .find(filter)
@@ -1013,23 +1026,29 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
 
   /**
    * builds mongoose schema building settings object by dynamoDataModelParamsList
-   * @param params DynamoBEDataPropertyParams
+   * @param properties DynamoBEDataPropertyParams
    * @returns mongoose schema object
    */
-  private buildMongooseSchemaByModelParams(params?: DyFM_DataProperty_Params[]): any {
+  private buildMongooseSchemaByModelParams(properties?: DyFM_DataProperties<T>): any {
     const schemaSettingsObj = {};
 
-    if (!params) {
-      params = this.dataParams.properties;
+    if (!properties) {
+      properties = this.dataParams.properties;
     }
 
-    params.forEach((property: DyFM_DataProperty_Params): void => {
+    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 (
         beType !== Object || 
         !property?.subObjectParams || 
-        property?.subObjectParams?.length == 0
+        (property?.subObjectParams && Object.keys(property.subObjectParams).length == 0)
       ) {
         schemaSettingsObj[property.key] = {
           type: beType,
@@ -1123,12 +1142,15 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
    * sets depDataKey
    */
   private lookForDependencyDataSettings(): void {
-    const dependencyParam: DyFM_DataProperty_Params = this.dataParams.properties.find(
-      (modelParams: DyFM_DataProperty_Params): boolean => modelParams.isDependencyHook
-    );
+    const dependencyParam: DyFM_DataProperty_Params<any> = 
+      Object.values(this.dataParams.properties).find(
+        (modelParams: DyFM_DataProperty_Params<any>): boolean => modelParams.isDependencyHook
+      );
     
-    if (this.dataParams.properties.filter(
-      (modelParams: DyFM_DataProperty_Params): boolean => modelParams.isDependencyHook).length > 1
+    if (
+      Object.values(this.dataParams.properties).filter(
+        (modelParams: DyFM_DataProperty_Params<any>): boolean => modelParams.isDependencyHook
+      ).length > 1
     ) {
       throw new DyFM_Error({
         ...this._getDefaultErrorSettings(

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

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

@@ -1,15 +1,15 @@
 
-import * as Axios from 'axios';
-import { 
-  DyFM_AnyError, DyFM_Error, DyFM_Error_Settings, DyFM_Log 
+import {
+  DyFM_AnyError, DyFM_Error, DyFM_Error_Settings, DyFM_Log
 } from '@futdevpro/fsm-dynamo';
+import * as Axios from 'axios';
 
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
 import { DyNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
 import { DyNTS_HttpResponseType } from '../../_enums/http/http-response-type.enum';
 import {
   DyNTS_ApiCall_Params
 } from '../../_models/control-models/api-call-params.control-model';
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
 
 export interface DyNTS_ApiCallInput_Params<T_Body = any> {
   pathParams?: {
@@ -45,7 +45,7 @@ export class DyNTS_ApiService {
   public static async startApiCall<T_Response, T_Body = any>(
     /**
      * you must setup the basic api call params with this.
-     * follow the instructions in the constructor: new DyNTS_ApiCallParams({ ... })
+     * follow the instructions in the constructor: new DyNTS_ApiCall_Params({ ... })
      */
     callParams: DyNTS_ApiCall_Params,
     /**
@@ -77,7 +77,7 @@ export class DyNTS_ApiService {
       switch (callParams.type) {
         case DyNTS_HttpCallType.get:
           if (inputParams?.body) {
-            DyFM_Log.warn('WARNING you cant send body in get calls');
+            DyFM_Log.warn(`WARNING you cant send body in get calls (${callParams.name})`);
           }
 
           a = await this.get<T_Response>(axios, url, callParams);
@@ -133,7 +133,7 @@ export class DyNTS_ApiService {
   }
 
   /* private static setupQueryParams<T_Body = any>(
-    inputParams: DyNTS_ApiCallInputParams<T_Body>, callParams: DyNTS_ApiCallParams) {
+    inputParams: DyNTS_ApiCallInputParams<T_Body>, callParams: DyNTS_ApiCall_Params) {
     const httpParams = new HttpParams();
 
     for (const queryParamKey in inputParams.queryParams) {