@futdevpro/nts-dynamo 1.9.39 → 1.9.40

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

@@ -2,7 +2,7 @@
 
 import { Request, Response } from 'express';
 
-import { DyFM_Array, DyFM_Error, DyFM_errorFlag, DyFM_Log } from '@futdevpro/fsm-dynamo';
+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 { DyNTS_global_settings } from '../../_collections/global-settings.const';
@@ -311,11 +311,22 @@ export class DyNTS_Endpoint_Params {
       DyFM_Log.error('');
           
     } catch (error) {
-      this.multiLevelError(error);
+      this.multiLevelError(
+        error,
+        { req, res, error, issuer }
+      );
     }
   }
 
-  private multiLevelError(error: any): void {
+  private multiLevelError(
+    error: any, 
+    errorInputs: { 
+      req: Request, 
+      res: Response, 
+      error: Error | DyFM_Error, 
+      issuer: string 
+    }
+  ): void {
     if (DyNTS_global_settings.log_settings.highDetailedLogs) {
       DyFM_Log.H_error(
         `\n\nDYNAMO MULTILEVEL ERROR:DyNTS_EndpointParams: error: ` +
@@ -334,6 +345,24 @@ export class DyNTS_Endpoint_Params {
       );
     }
 
+    try {
+      JSON.stringify(errorInputs.error);
+    } catch (error) {
+      DyFM_Log.error('error object is not serializable!');
+      let unresolvable;
+
+      try {
+        DyFM_Shared.resolveCirculation(errorInputs.error);
+      } catch (error) {
+        unresolvable = true;
+        DyFM_Log.error('error object is not resolvable!');
+      }
+      
+      if (!unresolvable) {
+        DyFM_Log.error('error object is resolvable! (use DyFM_Shared.resolveCirculation)');
+      }
+    }
+
     if (
       DyNTS_global_settings.log_settings.highDetailedLogs ||
       !(error instanceof DyFM_Error)

package/src/_modules/socket/_models/socket-client-service-params.control-model.ts

@@ -15,6 +15,7 @@ export class DyNTS_SocketClientService_Params extends DyFM_SocketClient_Params {
   ) {
     super(set);
 
-    DyFM_Log.H_info('T1000 (test this with custom address!)', this.address);
+    DyFM_Log.H_info(
+      'DyNTS_SocketClientService_Params (test this with custom address!)', this.address);
   }
 }

package/src/_modules/socket/_models/socket-presence.control-model.ts

@@ -105,7 +105,7 @@ export class DyNTS_SocketPresence {
       if (!socket.connected) {
         DyFM_Log.warn(
           `Emitting event '${event}' on socket(${this.serviceName})-(${index}) failed!` +
-          `\nERROR: socket[${socket.id}] is not connected! (it will be removed...)`
+          `\n  ERROR: socket[${socket.id}] is not connected! (it will be removed...)`
         );
 
         /* errors.push(

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

@@ -0,0 +1,207 @@
+
+import { 
+  DyFM_Metadata, DyFM_DataModel_Params, DyFM_Error
+} from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_DataService } from './data.service';
+import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
+import { DyNTS_GlobalService } from '../core/global.service';
+import { DyNTS_DBService } from './db.service';
+import { DyNTS_DBFilterSimple } from '../../_models/types/db-filter.type';
+
+// TODO: 3 type of archiving service system: 
+// 1.: within list (data have a list that have elements to archive)
+// 2.: separate db elements needs to be archived
+// 3.: from separate db elements to archive list elements
+
+export class DyNTS_ArchiveDataService<T extends DyFM_Metadata> extends DyNTS_DataService<T> {
+
+  originalDBService: DyNTS_DBService<T>;
+
+  constructor(
+    /**
+     * Initial data, this will be used by functions on default
+     */
+    data: T,
+    /**
+     * DB data prams will be used to connect to usable dbService on GlobalService
+     */
+    dataParams: DyFM_DataModel_Params,
+    /**
+     * Initial set for issuer to be able to follow the issuer's activity
+     */
+    issuer: string
+  ) {
+    const originalDataParams = { ...dataParams };
+    
+    dataParams = { 
+      ...dataParams,
+      dataName: DyNTS_getArchivedDBName(dataParams.dataName),
+    };
+    
+    super(data, dataParams, issuer);
+
+    this.originalDBService = DyNTS_GlobalService.getDBService<T>(originalDataParams);
+  }
+
+  async archiveDataById(id: string): Promise<T> {
+    try {
+      if (!id) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'archiveDataById',
+            new Error('archiveDataById failed, id is missing!')
+          ),
+
+          errorCode: 'NTS-ADS-ADI1',
+        });
+      }
+      
+      const data = await this.originalDBService.getDataById(id);
+
+      if (!data) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'archiveDataById',
+            new Error('archiveDataById failed, data not found!')
+          ),
+
+          errorCode: 'NTS-ADS-ADI2',
+          additionalContent: { 
+            id: id,
+          },
+        });
+      }
+
+      return await this.archiveData(data);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'archiveDataById',
+          error
+        ),
+
+        errorCode: 'NTS-ADS-ADI0',
+      });
+    }      
+  }
+
+  async getDataByOriginalId(originalId: string, dontSetToService?: boolean): Promise<T> {
+    try {
+      return await this.findData(
+        {
+          _originalId: originalId,
+        } as DyNTS_DBFilterSimple<T>, 
+        dontSetToService
+      );
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'getDataByOriginalId',
+          error
+        ),
+
+        errorCode: 'NTS-ADS-GDOI0',
+      });
+    }
+  }
+
+  async archiveData(data?: T, dontSetToService?: boolean): Promise<T> {
+    try {
+      data = this.ensureData(data);
+      
+      if (data?._originalId) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'archiveData',
+            new Error(
+              `archiveData failed, originalId is already exists! (${this.dataParams.dataName})`
+            )
+          ),
+
+          errorCode: 'NTS-ADS-AD1',
+        });
+      }
+
+      if (data?._archived) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'archiveData',
+            new Error(
+              `archiveData failed, data is already archived! (${this.dataParams.dataName})`
+            )
+          ),
+
+          errorCode: 'NTS-ADS-AD2',
+        });
+      }
+
+      if (!data?._id) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'archiveData',
+            new Error(`archiveData failed, id is missing! (${this.dataParams.dataName})`)
+          ),
+
+          errorCode: 'NTS-ADS-AD3',
+        });
+      }
+
+      await this.originalDBService.deleteDataById(data._id);
+
+      data._originalId = data._id;
+      data._archived = new Date();
+      delete data._id;
+
+      return await this.saveData(data, dontSetToService);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'archiveData',
+          error
+        ),
+
+        errorCode: 'NTS-ADS-AD0',
+      });
+    }
+  }
+
+  override async saveData(data?: T, dontSetToService?: boolean): Promise<T> {
+    try {
+      data = this.ensureData(data);
+  
+      if (!data?._originalId) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'saveData',
+            new Error(`saveData failed, originalId is missing! (${this.dataParams.dataName})`)
+          ),
+  
+          errorCode: 'NTS-ADS-SD1',
+        });
+      }
+  
+      if (!data?._archived) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'saveData',
+            new Error(`saveData failed, data is not archived! (${this.dataParams.dataName})`)
+          ),
+  
+          errorCode: 'NTS-ADS-SD2',
+        });
+      }
+      
+      return await super.saveData(data, dontSetToService);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'saveData',
+          error
+        ),
+
+        errorCode: 'NTS-ADS-SD0',
+      });
+    }
+  }
+}

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

@@ -3,12 +3,12 @@ import {
   DyFM_Metadata, DyFM_DataModel_Params, DyFM_DataProperty_Params, DyFM_Error,
   DyFM_Log, DyFM_AnyError, DyFM_Error_Settings, DyFM_ErrorLevel 
 } from '@futdevpro/fsm-dynamo';
+
 import { DyNTS_DBFilter } from '../../_models/types/db-filter.type';
 import { DyNTS_DBUpdate } from '../../_models/types/db-update.type';
-
-import { DyNTS_DBService } from './db.service';
-import { DyNTS_GlobalService } from '../core/global.service';
 import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { DyNTS_GlobalService } from '../core/global.service';
+import { DyNTS_DBService } from './db.service';
 
 // TODO: 2 type of archiving service system: within list, or separate db elements
 
@@ -79,12 +79,13 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
     } catch (error) {
       throw new DyFM_Error({
         ...this._getDefaultErrorSettings('constructor', error),
-        message: `The dataService construction failed for "${dataParams?.dataName}". ` +
-          `at "${this.serviceName}" (${this.constructor.name})` +
-          `\nMaybe you forgot to add the dbService to the GlobalService?\n\n`,
-        level: DyFM_ErrorLevel.critical,
         
         errorCode: 'NTS-DS0-C00',
+        message: 
+          `The dataService construction failed for "${dataParams?.dataName}". ` +
+          `at "${this.serviceName}" (${this.constructor.name})` +
+          `\nMaybe you forgot to add the dbService to the GlobalService?\n\n`,
+        level: DyFM_ErrorLevel.critical,        
       });
       /* DyFM_Log.error(
         `\nDyNTS_DataService ERROR: ` +
@@ -371,7 +372,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
           
           errorCode: 'NTS-DS0-GLD2',
           additionalContent: { 
-            data: this.data 
+            data: this.data, 
           },
         });
       }
@@ -579,24 +580,32 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
    * //
    */
   async updateData(
-    set: { filterBy?: DyNTS_DBFilter<T>, update: DyNTS_DBUpdate<T> }
+    set: { filterBy?: DyNTS_DBFilter<T>, update: DyNTS_DBUpdate<T> }, 
+    dontUpdateModified?: boolean
   ): Promise<void> {
     try {
       if (set.filterBy) {
-        await this.dataDBService.updateOne(set.filterBy, set.update, this.issuer);
+        await this.dataDBService.updateOne(
+          set.filterBy, 
+          set.update, 
+          this.issuer, 
+          dontUpdateModified
+        );
 
       } else if (this.data._id) {
         await this.dataDBService.updateOne(
           { _id: this.data._id } as DyNTS_DBFilter<T>, 
           set.update, 
-          this.issuer
+          this.issuer,
+          dontUpdateModified
         );
 
       } else if (this.depKey && this.data[this.depKey]) {
         await this.dataDBService.updateOne(
           { [this.depKey]: this.data[this.depKey] } as DyNTS_DBFilter<T>, 
           set.update, 
-          this.issuer
+          this.issuer,
+          dontUpdateModified
         );
 
       } else {
@@ -629,6 +638,25 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
     }
   }
 
+  protected ensureData(data?: T): T {
+    if (!data && this.data) {
+      data = this.data;
+    }
+
+    if (!data) {
+      throw new DyFM_Error({ 
+        ...this._getDefaultErrorSettings(
+          'saveData', 
+          new Error(`no data to save! (${this.dataParams.dataName})`)
+        ),
+        
+        errorCode: 'NTS-DS0-ED0',
+      });
+    }
+
+    return data;
+  }
+
   /**
    * modifies data if the data have ID and already exists in the DB, 
    * creates new if the ID is not present or cant find in DB, 
@@ -640,22 +668,9 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
    * (when you simultaneously trying to change the same data's 
    * different values from different flows)
    */
-  async saveData(data?: T, dontSetToService?: boolean): Promise<T> {
+  async saveData(data?: T, dontSetToService?: boolean, dontUpdateModified?: boolean): Promise<T> {
     try {
-      if (!data && this.data) {
-        data = this.data;
-      }
-
-      if (!data) {
-        throw new DyFM_Error({ 
-          ...this._getDefaultErrorSettings(
-            'saveData', 
-            new Error(`no data to save! (${this.dataParams.dataName})`)
-          ),
-          
-          errorCode: 'NTS-DS0-SD4',
-        });
-      }
+      data = this.ensureData(data);
 
       await this.validateForSave(data);
 
@@ -694,7 +709,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
         }
 
         // if data exists do modify
-        data = await this.dataDBService.modifyData(data, this.issuer);
+        data = await this.dataDBService.modifyData(data, this.issuer, dontUpdateModified);
 
         if (!dontSetToService) {
           this.data = data;
@@ -726,7 +741,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
 
           if (dataExists) {
             // if data exists do modify
-            data = await this.dataDBService.modifyData(data, this.issuer);
+            data = await this.dataDBService.modifyData(data, this.issuer, dontUpdateModified);
 
             if (!dontSetToService) {
               this.data = data;
@@ -800,8 +815,12 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
           errorCode: 'NTS-DS0-DD1',
         });
       }
-          
+
       await this.dataDBService.deleteDataById(id);
+
+      if (this.data._id === id) {
+        delete this.data._id;
+      }
     } catch (error) {
       if (error?.errorCode == 'NTS-DS0-DD1') {
         throw error;
@@ -820,21 +839,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
    */
   async validateForSave(data?: T): Promise<void> {
     try {
-      if (!data) {
-        data = this.data;
-      }
-
-      if (!data) {
-        throw new DyFM_Error({ 
-          ...this._getDefaultErrorSettings(
-            'validateForSave',
-            new Error(`validateForSave failed, no data provided! (${this.dataParams.dataName})`)
-          ),
-          
-          status: 522, 
-          errorCode: 'NTS-DS0-VD4',
-        });
-      }
+      data = this.ensureData(data);
 
       for (const element of this.dataParams.properties) {
         // basic required validations

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

@@ -8,6 +8,7 @@ import {
 } from '@futdevpro/fsm-dynamo';
 import { DyNTS_DBFilter } from '../../_models/types/db-filter.type';
 import { DyNTS_DBUpdate } from '../../_models/types/db-update.type';
+import { DyNTS_archiveSuffix } from '../../_collections/archive.util';
 
 /**
  * DB Service for MongoDB
@@ -125,9 +126,11 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
    * @param data data
    * @returns data
    */
-  async modifyData(data: T, issuer: string): Promise<T> {
-    data.__lastModified = new Date();
-    data.__lastModifiedBy = issuer;
+  async modifyData(data: T, issuer: string, dontUpdateModified?: boolean): Promise<T> {
+    if (!dontUpdateModified) {
+      data.__lastModified = new Date();
+      data.__lastModifiedBy = issuer;
+    }
 
     /** 
      * EZ A SZAR TELJESEN SZAR, nem friss, nem a db-be mentett adatokat ad vissza, 
@@ -718,9 +721,16 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
    * @param update update
    * @returns data
    */
-  async findByIdAndUpdate(id: string, update: DyNTS_DBUpdate<T>, issuer: string): Promise<T> {
-    update.__lastModified = new Date();
-    update.__lastModifiedBy = issuer;
+  async findByIdAndUpdate(
+    id: string, 
+    update: DyNTS_DBUpdate<T>, 
+    issuer: string, 
+    dontUpdateModified?: boolean
+  ): Promise<T> {
+    if (!dontUpdateModified) {
+      update.__lastModified = new Date();
+      update.__lastModifiedBy = issuer;
+    }
 
     let newData: T = await this.dataModel
       .findByIdAndUpdate(id, update)
@@ -796,10 +806,13 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
   async updateOne(
     filterBy: DyNTS_DBFilter<T>, 
     update: DyNTS_DBUpdate<T>, 
-    issuer: string
+    issuer: string, 
+    dontUpdateModified?: boolean
   ): Promise<void> {
-    update.__lastModified = new Date();
-    update.__lastModifiedBy = issuer;
+    if (!dontUpdateModified) {
+      update.__lastModified = new Date();
+      update.__lastModifiedBy = issuer;
+    }
     
     await this.dataModel
       .updateOne(filterBy, update)
@@ -869,10 +882,13 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
   async updateMany(
     filterBy: DyNTS_DBFilter<T>, 
     update: DyNTS_DBUpdate<T>, 
-    issuer: string
+    issuer: string, 
+    dontUpdateModified?: boolean
   ): Promise<void> {
-    update.__lastModified = new Date();
-    update.__lastModifiedBy = issuer;
+    if (!dontUpdateModified) {
+      update.__lastModified = new Date();
+      update.__lastModifiedBy = issuer;
+    }
 
     await this.dataModel
       .updateMany(filterBy, update)
@@ -939,7 +955,11 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
   private getSchema(): mongoose.Schema {
     let schema: any = this.buildMongooseSchemaByModelParams();
 
-    schema = this.addDyFM_MetadataToSchema(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']) {
@@ -1039,7 +1059,7 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
    * @param schema schema to update
    * @returns updated schema
    */
-  private addDyFM_MetadataToSchema(schema: any): any {
+  private addMetadataToSchema(schema: any): any {
     schema.__created = { type: Date };
     schema.__createdBy = { type: String };
     schema.__lastModified = { type: Date };
@@ -1048,6 +1068,13 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
     return schema;
   }
 
+  private addArchiveMetadataToSchema(schema: any): any {
+    schema._originalId = { type: String, required: true, index: true, unique: true };
+    schema._archived = { type: Date, required: true };
+
+    return schema;
+  }
+
   /**
    * sets depDataKey
    */

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

@@ -23,6 +23,8 @@ import { DyNTS_Service_Collection } from './service-collection.service';
 /* import { DyNTS_EmailServiceCollection } from './email-service-collection.service'; */
 import { DyNTS_SingletonService } from '../base/singleton.service';
 import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+/* import { DyNTS_archiveFlag } from '../../_collections/archive-flag.const'; */
+import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
 
 /**
  * This is the main Global/Core Service Collection used by DynamoBE, 
@@ -84,6 +86,18 @@ export class DyNTS_GlobalService extends DyNTS_SingletonService {
   private static async setDBServices(dbModels?: DyFM_DataModel_Params[]): Promise<void> {    
     try {
       this.instance.dbServiceCollection = {};
+
+      dbModels?.forEach((dbModel: DyFM_DataModel_Params): void => {
+        if (dbModel.addArchive) {
+          const archiveModel: DyFM_DataModel_Params = new DyFM_DataModel_Params({
+            ...dbModel,
+            dataName: DyNTS_getArchivedDBName(dbModel.dataName),
+          });
+
+          dbModels.push(archiveModel);
+        }
+      });
+
       dbModels?.forEach((dbModel: DyFM_DataModel_Params): void => {
         if (!dbModel.constructed) {
           throw new DyFM_Error({

package/src/_services/server/app.server.ts

@@ -271,32 +271,36 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
   constructor(extended?: boolean){
     super();
     
-    process.on('unhandledRejection', (reason: object, p_passWhatIsThis: any): void => {
-      DyFM_Log.H_error(
-        'Unhandled Rejection: ', p_passWhatIsThis?.toString()?.split('at')?.[0], 
-        '\n    Rejection reason:', reason?.toString()?.split('at')?.[0],
-        '\n\n    Stack:', 
-        (reason as any)?.stack?.replaceAll?.('\n    at', '\n      at'),
-      );
-
-      try {
-        DyNTS_GlobalService.globalErrorHandler?.(
-          new DyFM_Error({
-            errorCode: 'NTS-AS0-BASE-UR',
-            message: 'Unhandled Rejection!',
-            error: new Error(p_passWhatIsThis),
-            additionalContent: { 
-              reason: reason, 
-              p_noIdeaWhatIsThisFromProcessRejection: p_passWhatIsThis,
-            },
-            level: DyFM_ErrorLevel.critical,
-          })
+    process.on(
+      'unhandledRejection', 
+      (reason_theError: object, p_passWhatIsThis_maybeThePromise: any): void => {
+        DyFM_Log.H_error(
+          'Unhandled Rejection: ', (p_passWhatIsThis_maybeThePromise as Promise<any>)?.toString(), 
+          '\n    Rejection reason:', (reason_theError as Error)?.stack?.split('at')?.[0],
+          /* '\n    ErrorCode:', (reason as any)?.code, */
+          '\n\n    Stack:', 
+          (reason_theError as Error)?.stack?.replaceAll?.('\n    at', '\n      at'),
         );
 
-      } catch (error) {
-        DyFM_Log.error('globalErrorHandler (MULTILEVEL) ERROR:', error);
+        try {
+          DyNTS_GlobalService.globalErrorHandler?.(
+            new DyFM_Error({
+              errorCode: 'NTS-AS0-BASE-UR',
+              message: 'Unhandled Rejection!',
+              error: reason_theError as Error,
+              additionalContent: { 
+                reason: reason_theError, 
+                rejectedPromise: p_passWhatIsThis_maybeThePromise,
+              },
+              level: DyFM_ErrorLevel.critical,
+            })
+          );
+
+        } catch (error) {
+          DyFM_Log.error('globalErrorHandler (MULTILEVEL) ERROR:', error);
+        }
       }
-    });
+    );
 
     this.asyncConstruct(extended).catch((error: any): void => {
       if (
@@ -313,7 +317,7 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
         );
       }
 
-      DyFM_Log.H_warn('T1000\n', error?.additionalContent);
+      DyFM_Log.H_warn('asyncConstruct error\n', error?.additionalContent);
     });
   }