@futdevpro/nts-dynamo 1.10.2 → 1.10.4

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

@@ -163,6 +163,9 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
    * also if dontSetToService is false or not setted, 
    * the data will be saved to the service, even if its not found
    * 
+   * if the data is not found, it will try to find it from the archive
+   * unless skipArchiveLoad is set to true
+   * 
    * @remarks 
    * If you need to get-save a data, if possible, 
    * use db-service update instead.
@@ -173,9 +176,15 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
    * 
    * @return {T} data: T
    */
-  async getDataById(id?: string, dontSetToService?: boolean): Promise<T> {
+  async getDataById(
+    id?: string, 
+    dontSetToService?: boolean, 
+    skipArchiveLoad?: boolean
+  ): Promise<T> {
     try {
-      if (!id && !this.data._id) {
+      id = id ?? this.data?._id;
+
+      if (!id) {
         throw new DyFM_Error({
           ...this._getDefaultErrorSettings(
             'getDataById', 
@@ -190,7 +199,13 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
         });
       }
 
-      const dataExists: T = await this.dataDBService.getDataById(id ?? this.data._id);
+      let dataExists: T = await this.dataDBService.getDataById(id);
+
+      if (this.haveArchiveDataService && !skipArchiveLoad) {
+        const archiveDataService: DyNTS_ArchiveDataService<T> = this.getArchiveDataService();
+        
+        dataExists = await archiveDataService.getDataByOriginalId(id, true);
+      }
 
       if (!dontSetToService) {
         this.data = dataExists;
@@ -875,6 +890,17 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
 
       this.data = await this.getDataById(id, true);
 
+      if (!this.data) {
+        throw new DyFM_Error({ 
+          ...this._getDefaultErrorSettings(
+            'deleteData',
+            new Error(`deleteData failed, data not found! (${this.dataParams.dataName})`)
+          ),
+          
+          errorCode: 'NTS-DS0-DD2',
+        });
+      }
+
       if (this.haveArchiveDataService) {
         const archive_DS: DyNTS_DataService<T> = this.getArchiveDataService();
         
@@ -1088,38 +1114,44 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
     }
   }
 
-  async searchData(query?: DyFM_SearchQuery<T>): Promise<DyFM_SearchResult<T>> {
+  async searchData(query?: DyFM_SearchQuery<T>, dataList?: T[]): Promise<DyFM_SearchResult<T>> {
     try {
-      /* if (!query || Object.keys(query).length === 0) {
-        console.log('T1');
-        const allData: T[] = await this.getAll();
+      const searchResult = await this.sortAndFilterDataList(query, dataList);
 
-        return {
-          results: allData,
-          totalItems: allData.length,
-        };
-      } */
+      if (query.page !== undefined && query.pageSize !== undefined) {
+        const start = query.page * query.pageSize;
+        const end = start + query.pageSize;
+
+        searchResult.results = searchResult.results.slice(start, end);
+      }
 
+      return searchResult;
+    } catch (error) {
+      throw new DyFM_Error({ 
+        ...this._getDefaultErrorSettings('searchData', error),
+        
+        errorCode: 'NTS-DS0-SD0',
+      });
+    }
+  }
+
+  async sortAndFilterDataList(
+    query: DyFM_SearchQuery<T>, 
+    dataList?: T[]
+  ): Promise<DyFM_SearchResult<T>> {
+    try {
       if (!query.filterBy) {
         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 = 0;
       }
 
       if (!query.pageSize) {
-        DyFM_Log.warn('searchData pageSize is not setted, setting to 10.');
+        DyFM_Log.warn(
+          `searchData pageSize is not setted, setting to ${DyNTS_global_settings.defaultPageSize}.`
+        );
         query.pageSize = DyNTS_global_settings.defaultPageSize;
       }
 
@@ -1127,16 +1159,12 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
         query.sortBy = [{ key: '__lastModified', order: -1 }];
       }
 
-      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();
+
+      if (!dataList) {
+        dataList = await this.getAll();
+      }
+
       const filterKeys = Object.keys(query.filterBy);
       const filterFunctionsByKey: { [key: string]: (dataProperty) => boolean } = {};
 
@@ -1169,7 +1197,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
     }
   }
 
-  private getFilterFunctionForKey<T>(
+  protected getFilterFunctionForKey<T>(
     key: string, 
     searchValue: T | T[] | DyFM_RangeValue<T>,
   ): (dataProperty) => boolean {
@@ -1201,9 +1229,27 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
       });
     }
 
+    
     switch (this.dataParams.properties[key].type) {
       case 'String':
-        return (dataProperty): boolean => dataProperty.includes(searchValue);
+        if (typeof searchValue !== 'string') {
+          throw new DyFM_Error({
+            ...this._getDefaultErrorSettings(
+              'getFilterFunctionForKey',
+              new Error(
+                `getFilterFunctionForKey failed, searchValue is not a string! ` +
+                `(${this.dataParams.dataName})`
+              )
+            ),
+
+            errorCode: 'NTS-DS0-GFF3',
+          });
+        }
+
+        const lowerCaseSearchValue: string = (searchValue as string).toLowerCase();
+
+        return (dataProperty): boolean => 
+          (dataProperty as string).toLowerCase().includes(lowerCaseSearchValue);
 
       case 'Date':
         if ((searchValue as DyFM_RangeValue).isRange) {
@@ -1268,7 +1314,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
     }
   }
 
-  private getSortFunctionForKey<T>(
+  protected getSortFunctionForKey<T>(
     key: string, 
     sortDirection: 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending'
   ): (a: T, b: T) => number {

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

@@ -1009,14 +1009,18 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
    */
   private getSchema(): mongoose.Schema {
     this.dataParams.properties = this.addMetadataToProperties(this.dataParams.properties);
+    
+    if (this.dataParams.dataName.includes(DyNTS_archiveSuffix)) {
+      this.dataParams.properties = this.addArchiveMetadataToProperties(this.dataParams.properties);
+    }
 
-    let schema: any = this.buildMongooseSchemaByModelParams(this.dataParams.properties);
+    const schema: any = this.buildMongooseSchemaByModelParams(this.dataParams.properties);
 
     /* schema = this.addMetadataToSchema(schema); */
 
-    if (this.dataParams.dataName.includes(DyNTS_archiveSuffix)) {
+    /* if (this.dataParams.dataName.includes(DyNTS_archiveSuffix)) {
       schema = this.addArchiveMetadataToSchema(schema);
-    }
+    } */
 
     if (schema['_id']) {
       delete schema['_id'];
@@ -1044,12 +1048,34 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
         return;
       }
 
+      if (!property.key) {
+        throw new DyFM_Error({
+          ...this._getDefaultErrorSettings(
+            'buildMongooseSchemaByModelParams',
+            new Error(
+              `property.key is undefined on ${this.dataParams.dbName} (NTS DB)` +
+              `(keys: ${Object.keys(properties)})`
+            )
+          ),
+          errorCode: 'NTS-DBS-BMSBP0',
+          additionalContent: { 
+            property,
+            dataParams: this.dataParams,
+          },
+        });
+      }
+
       const beType = this.getBEType(property.type);
 
+      /* TODO if (beType === Array && property.archiveable && !property.archiveListAfter) {
+        property.archiveListAfter = DyNTS_global_settings.archiveListAfter;
+      } */
+
       if (
         beType !== Object || 
         !property?.subObjectParams || 
-        (property?.subObjectParams && Object.keys(property.subObjectParams).length == 0)
+        (property?.subObjectParams && 
+          Object.keys(property.subObjectParams).length == 0)
       ) {
         schemaSettingsObj[property.key] = {
           type: beType,
@@ -1132,39 +1158,65 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
     return schema;
   } */
 
+  /**
+   * adds dynamo metadata settings to any mongoose schema building settings object
+   * @param properties properties to update
+   * @returns updated properties
+   */
   private addMetadataToProperties(properties: DyFM_DataProperties<T>): DyFM_DataProperties<T> {
+    // TOD: ezek a kikommentelt "required: true"-k kellenek, csak félő, hogy gondokat okoznak a 
+    // jelenlegi rendszerekben, ezért akkor kell majd visszarakni, ha lesz tesztelői ÉS fejlesztői kapacitás rá
     if (!properties.__created) {
-      properties.__created = { type: 'Date' };
+      properties.__created = { key: '__created', type: 'Date'/* , required: true */ };
     }
 
     if (!properties.__createdBy) {
-      properties.__createdBy = { type: 'String' };
+      properties.__createdBy = { key: '__createdBy', type: 'string'/* , required: true */ };
     }
 
     if (!properties.__lastModified) {
-      properties.__lastModified = { type: 'Date' };
+      properties.__lastModified = { key: '__lastModified', type: 'Date'/* , required: true */ };
     }
 
     if (!properties.__lastModifiedBy) {
-      properties.__lastModifiedBy = { type: 'String' };
+      properties.__lastModifiedBy = { key: '__lastModifiedBy', type: 'string'/* , required: true */ };
     }
 
     if (!properties._deleted) {
-      properties._deleted = { type: 'Date' };
+      properties._deleted = { key: '_deleted', type: 'Date' };
     }
 
     if (!properties._deletedBy) {
-      properties._deletedBy = { type: 'String' };
+      properties._deletedBy = { key: '_deletedBy', type: 'string' };
     }
 
     return properties;
   }
 
-  private addArchiveMetadataToSchema(schema: any): any {
+  /* private addArchiveMetadataToSchema(schema: any): any {
     schema._originalId = { type: String, required: true, index: true, unique: true };
     schema._archived = { type: Date, required: true };
 
     return schema;
+  } */
+
+  private addArchiveMetadataToProperties(
+    properties: DyFM_DataProperties<T>
+  ): DyFM_DataProperties<T> {
+    if (!properties._originalId) {
+      properties._originalId = { 
+        key: '_originalId', type: 'string', 
+        required: true, index: true, unique: true,
+      };
+    }
+
+    if (!properties._archived) {
+      properties._archived = { 
+        key: '_archived', type: 'Date', required: true, 
+      };
+    }
+
+    return properties;
   }
 
   /**

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

@@ -1,11 +1,11 @@
 
-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';
 
+import { DyFM_Error, DyFM_HttpCallType, DyFM_HttpResponseType } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_ApiCall_Params } from '../../_models/control-models/api-call-params.control-model';
+import { DyNTS_ApiCallInput_Params, DyNTS_ApiService } from './api.service';
+
 describe('DyNTS_ApiService', () => {
   let callParams: DyNTS_ApiCall_Params;
   let inputParams: DyNTS_ApiCallInput_Params;
@@ -14,10 +14,10 @@ describe('DyNTS_ApiService', () => {
     callParams = {
       baseUrl: 'http://example.com',
       endPoint: '/api/test',
-      type: DyNTS_HttpCallType.get,
+      type: DyFM_HttpCallType.get,
       httpOptions: {
         headers: {},
-        responseType: DyNTS_HttpResponseType.json,
+        responseType: DyFM_HttpResponseType.json,
       },
       name: 'Test API Call',
       getFullResponse: false,
@@ -30,29 +30,33 @@ describe('DyNTS_ApiService', () => {
   });
 
   it('should make a GET request successfully', async () => {
-    callParams.type = DyNTS_HttpCallType.get;
+    callParams.type = DyFM_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;
+    callParams.type = DyFM_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;
+    callParams.type = 'unsupported' as DyFM_HttpCallType;
 
     await expectAsync(DyNTS_ApiService.startApiCall(callParams, inputParams)).toBeRejectedWith(
       jasmine.any(DyFM_Error)
@@ -63,6 +67,7 @@ describe('DyNTS_ApiService', () => {
     const errorResponse = {
       response: { data: { flag: 'DYNAMO', message: 'Error' } },
     };
+
     spyOn(Axios, 'create').and.returnValue({
       get: jasmine.createSpy().and.returnValue(Promise.reject(errorResponse)),
     } as any);
@@ -74,6 +79,7 @@ describe('DyNTS_ApiService', () => {
 
   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);
@@ -85,6 +91,7 @@ describe('DyNTS_ApiService', () => {
 
   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);

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

@@ -1,12 +1,13 @@
 
+import * as Axios from 'axios';
+
 import {
-  DyFM_AnyError, DyFM_Error, DyFM_Error_Settings, DyFM_Log
+  DyFM_AnyError, DyFM_Error, DyFM_Error_Settings,
+  DyFM_HttpCallType, DyFM_HttpResponseType,
+  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';
@@ -75,7 +76,7 @@ export class DyNTS_ApiService {
       }
 
       switch (callParams.type) {
-        case DyNTS_HttpCallType.get:
+        case DyFM_HttpCallType.get:
           if (inputParams?.body) {
             DyFM_Log.warn(`WARNING you cant send body in get calls (${callParams.name})`);
           }
@@ -83,7 +84,7 @@ export class DyNTS_ApiService {
           a = await this.get<T_Response>(axios, url, callParams);
           break;
 
-        case DyNTS_HttpCallType.delete:
+        case DyFM_HttpCallType.delete:
           if (inputParams?.body) {
             DyFM_Log.warn('WARNING you cant send body in delete calls');
           }
@@ -91,9 +92,9 @@ export class DyNTS_ApiService {
           a = await this.delete<T_Response>(axios, url, callParams);
           break;
 
-        case DyNTS_HttpCallType.post:
-        case DyNTS_HttpCallType.put:
-        case DyNTS_HttpCallType.patch:
+        case DyFM_HttpCallType.post:
+        case DyFM_HttpCallType.put:
+        case DyFM_HttpCallType.patch:
           if (!inputParams?.body) {
             if (!inputParams) {
               inputParams = {};
@@ -109,7 +110,7 @@ export class DyNTS_ApiService {
           throw new DyFM_Error({
             ...this._getDefaultErrorSettings(
               'startApiCall',
-              new Error('wrong api call type')
+              new Error(`unknown api call type: ${callParams.type}`)
             ),
             errorCode: 'NTS-API-SAC0',
             additionalContent: {
@@ -117,16 +118,15 @@ export class DyNTS_ApiService {
               inputParams,
             },
           });
-          //DyFM_Log.error('DYNAMO-NTS ERROR: \n wrong api call type'/* , '\n\n', new Error() */);
-          break;
       }
 
-      if (callParams.getFullResponse) {
-        return a as T_Response /* Axios.AxiosResponse */;
+      return a;
+      /* if (callParams.getFullResponse) {
+        return a as T_Response Axios.AxiosResponse;
 
       } else {
         return a as T_Response;
-      }
+      } */
     } catch (error) {
       this.handleError<T_Body>(callParams, error, inputParams);
     }
@@ -176,7 +176,7 @@ export class DyNTS_ApiService {
       DyFM_Log.error(`\ncallParams:`, callParams);
     }
 
-    if (error && callParams?.httpOptions?.responseType === DyNTS_HttpResponseType.text) {
+    if (error && callParams?.httpOptions?.responseType === DyFM_HttpResponseType.text) {
       error.error = JSON.parse(error?.error);
     }
 

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

@@ -7,6 +7,7 @@ import {
   DyFM_DataModel_Params,
   DyFM_Error,
   DyFM_Error_Settings,
+  DyFM_global_settings,
   DyFM_Log,
   DyFM_Metadata
 } from '@futdevpro/fsm-dynamo';
@@ -111,6 +112,9 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
           const archiveModel: DyFM_DataModel_Params<any> = new DyFM_DataModel_Params<any>({
             ...dbModel,
             dataName: DyNTS_getArchivedDBName(dbModel.dataName),
+            properties: {
+              ...dbModel.properties,
+            },
           });
 
           dbModels.push(archiveModel);
@@ -136,7 +140,11 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
         try {
           this.instance.dbServiceCollection[dbModel.dataName] = new DyNTS_DBService(dbModel);
         } catch (error) {
-          DyFM_Log.error(`Failed to create DyNTS_DBService (${dbModel.dataName}).`, error);
+          if (error instanceof DyFM_Error && !DyFM_global_settings.log_settings.highDetailedLogs) {
+            error.logSimple(`Failed to create DyNTS_DBService (${dbModel.dataName}).`);
+          } else {
+            DyFM_Log.error(`Failed to create DyNTS_DBService (${dbModel.dataName}).`, error);
+          }
           
           throw new DyFM_Error({
             ...this.getDefaultErrorSettings('setDBServices', error, 'DyNTS_GlobalService'),

package/src/_services/route/controller.service.spec.ts

@@ -1,5 +1,6 @@
 
-import { DyNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
+import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
+
 import { DyNTS_Endpoint_Params } from '../../_models/control-models/endpoint-params.control-model';
 import { DyNTS_Controller } from './controller.service';
 
@@ -8,7 +9,7 @@ class TestController extends DyNTS_Controller {
     this.endpoints = [
       new DyNTS_Endpoint_Params({
         name: 'testEndpoint',
-        type: DyNTS_HttpCallType.get,
+        type: DyFM_HttpCallType.get,
         endpoint: '/test-endpoint',
         preProcesses: [],
         tasks: [

package/src/_services/route/controller.service.ts

@@ -25,7 +25,7 @@ import { DyNTS_SingletonService } from '../base/singleton.service';
  *     this.endpoints = [
  *       new DyNTS_Endpoint_Params({
  *         name: 'getUserMatchStatistics',
- *         type: DyNX_HttpCallType.get,
+ *         type: DyFM_HttpCallType.get,
  *         endpoint: '/get/user-match-statistics/:userId',
  *         preProcesses: [ this.authService.authenticate_tokenSelf ],
  *         tasks: [ 
@@ -56,7 +56,7 @@ export abstract class DyNTS_Controller extends DyNTS_SingletonService {
    * this.endpoints = [
    *   new DyNTS_Endpoint_Params({
    *     name: 'getUserMatchStatistics',
-   *     type: DyNX_HttpCallType.get,
+   *     type: DyFM_HttpCallType.get,
    *     endpoint: '/get/user-match-statistics/:userId',
    *     preProcesses: [ this.authService.authenticate_tokenSelf ],
    *     tasks: [ 
@@ -104,7 +104,7 @@ export abstract class DyNTS_Controller extends DyNTS_SingletonService {
    *   this.endpoints = [
    *     new DyNTS_Endpoint_Params({
    *       name: 'getUserMatchStatistics',
-   *       type: DyNX_HttpCallType.get,
+   *       type: DyFM_HttpCallType.get,
    *       endpoint: '/get/user-match-statistics/:userId',
    *       preProcesses: [ this.authService.authenticate_tokenSelf ],
    *       tasks: [ 

package/src/_services/route/routing-module.service.spec.ts

@@ -1,6 +1,6 @@
 
-import { DyFM_Error } from '@futdevpro/fsm-dynamo';
-import { DyNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
+import { DyFM_Error, DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
+
 import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
 import { DyNTS_Endpoint_Params } from '../../_models/control-models/endpoint-params.control-model';
 import {
@@ -22,7 +22,7 @@ describe('DyNTS_RoutingModule', () => {
 
     mockEndpoint = {
       endpoint: '/test',
-      type: DyNTS_HttpCallType.get,
+      type: DyFM_HttpCallType.get,
       getFullExecution: jasmine.createSpy('getFullExecution'),
       security: DyNTS_RouteSecurity.open,
     } as any as DyNTS_Endpoint_Params;
@@ -65,12 +65,12 @@ describe('DyNTS_RoutingModule', () => {
   });
 
   xit('should throw error for invalid route type in open route', () => {
-    mockEndpoint.type = 'invalid' as DyNTS_HttpCallType;
+    mockEndpoint.type = 'invalid' as DyFM_HttpCallType;
     expect(() => routingModule['mountOpenRoute'](mockEndpoint)).toThrow(DyFM_Error);
   });
 
   xit('should throw error for invalid route type in secure route', () => {
-    mockEndpoint.type = 'invalid' as DyNTS_HttpCallType;
+    mockEndpoint.type = 'invalid' as DyFM_HttpCallType;
     expect(() => routingModule['mountSecureRoute'](mockEndpoint)).toThrow(DyFM_Error);
   });