@futdevpro/nts-dynamo 1.10.29 → 1.10.31

package/src/_modules/server/errors/errors.data-service.ts

@@ -22,8 +22,8 @@ import { DyNTS_DataService } from '../../../_services/base/data.service';
 
 export class DyNTS_Errors_DataService<
   T_Error extends DyFM_Error,
-  T_Errors extends DyFM_Errors<T_Error>
-> extends DyNTS_DataService<T_Errors> implements DyNTS_Errors_ControlService<T_Error, T_Errors> {
+  T_ErrorsRecord extends DyFM_Errors<T_Error>
+> extends DyNTS_DataService<T_ErrorsRecord> implements DyNTS_Errors_ControlService<T_Error, T_ErrorsRecord> {
 
   debugLog: boolean = false;
   readonly version: string = DyNTS_global_settings.systemVersion;
@@ -43,7 +43,11 @@ export class DyNTS_Errors_DataService<
     );
   } */
 
-  async recordError(data: T_Errors, issuer: string, alwaysRecord?: boolean): Promise<void> {
+  async recordError(
+    errorsRecord: T_ErrorsRecord, 
+    issuer: string, 
+    alwaysRecord?: boolean
+  ): Promise<void> {
     try {
       if (issuer && !this.issuer) {
         this.issuer = issuer;
@@ -60,11 +64,11 @@ export class DyNTS_Errors_DataService<
         return;
       }
 
-      if (!data && this.data) {
-        data = this.data;
+      if (!errorsRecord && this.data) {
+        errorsRecord = this.data;
       }
 
-      if (!data) {
+      if (!errorsRecord) {
         throw new DyFM_Error({
           ...this.getDefaultErrorSettings(
             'recordError',
@@ -75,59 +79,59 @@ export class DyNTS_Errors_DataService<
         });
       }
 
-      if ([ DyFM_ErrorLevel.user ].includes(data.level)) {
+      if ([ DyFM_ErrorLevel.user ].includes(errorsRecord.level)) {
         DyFM_Log.warn('error not saved (user level)');
 
         return;
       }
 
-      if (data.message?.includes('NullReferenceException')) {
-        data.message += '\n' + data.exception.split('() (at <')[0];
+      if (errorsRecord.message?.includes('NullReferenceException')) {
+        errorsRecord.message += '\n' + errorsRecord.exception.split('() (at <')[0];
       }
 
-      const duplicateError: T_Errors = await this.findData({
-        version: data.version,
-        message: data.message,
-      } as DyFM_DBFilter<T_Errors>, true);
+      const duplicateError: T_ErrorsRecord = await this.findData({
+        version: errorsRecord.version,
+        message: errorsRecord.message,
+      } as DyFM_DBFilter<T_ErrorsRecord>, true);
 
-      data.d_error = this.checkErrorIsStringifyableOrResolvable(data.d_error, this.issuer) as T_Error;
+      errorsRecord.d_error = this.checkErrorIsStringifyableOrResolvable(errorsRecord.d_error, this.issuer) as T_Error;
       
       try {
-        JSON.stringify(data);
+        JSON.stringify(errorsRecord);
       } catch (err) {
         DyFM_Log.error('error data is not stringifyable!');
 
         return;
       }
 
-      if (JSON.stringify(data).length > 16793000) {
-        data.additionalContent = {
+      if (JSON.stringify(errorsRecord).length > 16793000) {
+        errorsRecord.additionalContent = {
           message: 'error data was too big to save, removed additionalContent',
         };
-        data.error.additionalContent = {
+        errorsRecord.error.additionalContent = {
           message: 'error data was too big to save, removed additionalContent',
         };
 
-        if (JSON.stringify(data).length > 16793000) {
-          data.error.errors = [];
+        if (JSON.stringify(errorsRecord).length > 16793000) {
+          errorsRecord.error.errors = [];
         }
       }
 
       if (
         duplicateError && 
-        duplicateError?.message === data?.message
+        duplicateError?.message === errorsRecord?.message
       ) {
-        if (!data.__created) {
-          data.__created = new Date();
+        if (!errorsRecord.__created) {
+          errorsRecord.__created = new Date();
         }
 
         this.duplicationCounter = duplicateError.count + 1;
 
         await this.updateData({
-          filterBy: { _id: duplicateError._id } as DyFM_DBFilter<T_Errors>,
+          filterBy: { _id: duplicateError._id } as DyFM_DBFilter<T_ErrorsRecord>,
           update: { 
-            $inc: { count: 1, priority: this.getPriorityMultiplierByLevel(data?.level) },
-          } as DyNTS_DBUpdate<T_Errors>,
+            $inc: { count: 1, priority: this.getPriorityMultiplierByLevel(errorsRecord?.level) },
+          } as DyNTS_DBUpdate<T_ErrorsRecord>,
         });
 
         // ezt majd ha leülepedett, hogy biztos nem kellenek a deep duplication-ök 
@@ -148,20 +152,20 @@ export class DyNTS_Errors_DataService<
           '\ncount:', duplicateError.count + 1
         );
         DyFM_Log.error(
-          'ErrorMsg:', data?.message?.replace(/\n/g, '  \n')
+          'ErrorMsg:', errorsRecord?.message?.replace(/\n/g, '  \n')
         );
 
-        if (this.debugLog) DyFM_Log.error('Error:', data);
+        if (this.debugLog) DyFM_Log.error('Error:', errorsRecord);
       } else {
         DyFM_Log.log('error not found, saving....');
         DyFM_Log.error(
-          'ErrorMsg:', data?.message?.replace(/\n/g, '  \n')
+          'ErrorMsg:', errorsRecord?.message?.replace(/\n/g, '  \n')
         );        
 
-        if (this.debugLog) DyFM_Log.error('Error:', data);
+        if (this.debugLog) DyFM_Log.error('Error:', errorsRecord);
 
-        data.priority = this.getPriorityMultiplierByLevel(data?.level);
-        data.duplications.push(DyFM_clone(data));
+        errorsRecord.priority = this.getPriorityMultiplierByLevel(errorsRecord?.level);
+        errorsRecord.duplications.push(DyFM_clone(errorsRecord));
 
         this.duplicationCounter = 1;
 
@@ -185,20 +189,13 @@ export class DyNTS_Errors_DataService<
     }
   }
 
-  async handleInternalError(
-    error: DyFM_AnyError | any, 
+  protected async createErrorRecord(
+    error: DyFM_AnyError | any,
     issuer: string,
-    alwaysRecord?: boolean,
-  ): Promise<void> {
-    try {    
-      if (this.debugLog) DyFM_Log.log('handleInternalError');
-
-      if (issuer && !this.issuer) {
-        this.issuer = issuer;
-      }
-
+  ): Promise<T_ErrorsRecord> {
+    try {
       if ((error as DyFM_Error)?.flag?.includes(DyFM_errorFlag)) {
-        this.data = new DyFM_Errors({
+        return new DyFM_Errors({
           issuer: this.issuer,
           version: 'SERVER-' + this.version,
 
@@ -215,9 +212,9 @@ export class DyNTS_Errors_DataService<
             ),
 
           additionalContent: (error as DyFM_Error)?.additionalContent,
-        }) as T_Errors;       
+        }) as T_ErrorsRecord;       
       } else {
-        this.data = new DyFM_Errors({
+        return new DyFM_Errors({
           issuer: this.issuer,
           version: 'SERVER-' + this.version,
 
@@ -229,14 +226,58 @@ export class DyNTS_Errors_DataService<
 
           message: (error as Error)?.message,
           exceptionObj: (error as Error)?.stack?.split('\n'),
-        }) as T_Errors;
+        }) as T_ErrorsRecord;
       }
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('createErrorRecord', error),
+      });
+    }
+  }
+
+  async handleExternalError(
+    error: T_Error,
+    issuer: string,
+    alwaysRecord?: boolean,
+  ): Promise<void> {
+    try {
+      if (this.debugLog) DyFM_Log.log('handleExternalError');
+
+      if (issuer && !this.issuer) {
+        this.issuer = issuer;
+      }
+
+      const errorsRecord: T_ErrorsRecord = await this.createErrorRecord(error, this.issuer);
+
+      await this.recordError(errorsRecord, this.issuer, alwaysRecord);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('handleExternalError', error),
+
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-HE0`,
+      });
+    }
+  }
+
+  async handleInternalError(
+    error: DyFM_AnyError | any, 
+    issuer: string,
+    alwaysRecord?: boolean,
+  ): Promise<void> {
+    try {    
+      if (this.debugLog) DyFM_Log.log('handleInternalError');
+
+      if (issuer && !this.issuer) {
+        this.issuer = issuer;
+      }
+
+      const errorsRecord: T_ErrorsRecord = await this.createErrorRecord(error, this.issuer);
 
       /* if (!(error as FDP_Errors)?.flag?.includes('WB-ERROR-OBJECT')) {
         DyFM_Log.H_error('__ERROR__:', error);
       } */
 
-      await this.recordError(this.data, this.issuer, alwaysRecord);
+      await this.recordError(errorsRecord, this.issuer, alwaysRecord);
 
       if (
         DyNTS_global_settings.log_settings.highDetailedLogs ||
@@ -252,15 +293,11 @@ export class DyNTS_Errors_DataService<
         );
       }
     } catch (error) {
-      DyFM_Log.error('handleInternalError error:', error);
-      /* throw new DyFM_Error({
-        ...this.getDefaultErrorSettings(
-          'handleInternalError',
-          error
-        ),
-
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-HIE0`,
-      }); */
+      if (error instanceof DyFM_Error) {
+        error.logSimple('handleInternalError error');
+      } else {
+        DyFM_Log.error('handleInternalError error:', error);
+      }
     }
   }
 
@@ -272,7 +309,11 @@ export class DyNTS_Errors_DataService<
 
       JSON.stringify(error);
     } catch (err) {
-      DyFM_Log.error('error data is not stringifyable! trying to resolve...');
+      if (err instanceof DyFM_Error) {
+        err.logSimple('checkErrorIsStringifyableOrResolvable error');
+      } else {
+        DyFM_Log.error('checkErrorIsStringifyableOrResolvable error:', err);
+      }
 
       error = DyFM_Shared.resolveCirculation(error);
 
@@ -284,7 +325,11 @@ export class DyNTS_Errors_DataService<
         try {
           JSON.stringify(error);
         } catch (err) {
-          DyFM_Log.error('error data is not stringifyable! resolution failed! will not save!');
+          if (err instanceof DyFM_Error) {
+            err.logSimple('error data is not stringifyable! resolution failed! will not save!');
+          } else {
+            DyFM_Log.error('error data is not stringifyable! resolution failed! will not save!', err);
+          }
 
           return 'UNRESOLVABLE';
         }
@@ -323,13 +368,13 @@ export class DyNTS_Errors_DataService<
   async getErrorsFromDate(
     date: Date,
     issuer: string,
-  ): Promise<DyFM_Paged<T_Errors>> {
+  ): Promise<DyFM_Paged<T_ErrorsRecord>> {
     try {
       if (issuer && !this.issuer) {
         this.issuer = issuer;
       }
 
-      const errors: T_Errors[] = await this.findDataList({ __created: { $gte: date } });
+      const errors: T_ErrorsRecord[] = await this.findDataList({ __created: { $gte: date } });
 
       return DyFM_Array.paged(errors, 0, 100);
     } catch (error) {
@@ -354,6 +399,7 @@ export class DyNTS_Errors_DataService<
     } catch (error) {
       throw new DyFM_Error({
         ...this.getDefaultErrorSettings('deleteError', error),
+
         errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-DE0`,
       });
     }
@@ -369,12 +415,13 @@ export class DyNTS_Errors_DataService<
     } catch (error) {
       throw new DyFM_Error({
         ...this.getDefaultErrorSettings('deleteAllErrors', error),
+
         errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-DAE0`,
       });
     }
   }
 
-  async getErrorsInRange(range: DyFM_RelativeDate, issuer: string): Promise<DyFM_Paged<T_Errors>> {
+  async getErrorsInRange(range: DyFM_RelativeDate, issuer: string): Promise<DyFM_Paged<T_ErrorsRecord>> {
     try {
       if (issuer && !this.issuer) {
         this.issuer = issuer;
@@ -382,7 +429,7 @@ export class DyNTS_Errors_DataService<
 
       const fromDate: Date = DyFM_Time.getDateByRelativeDate(range);
 
-      let errors: T_Errors[] = await this.findDataList({ __lastModified: { $gte: fromDate } }); 
+      let errors: T_ErrorsRecord[] = await this.findDataList({ __lastModified: { $gte: fromDate } }); 
       errors = errors.sort(
         (a, b): number => b.priority - a.priority
       );
@@ -391,6 +438,7 @@ export class DyNTS_Errors_DataService<
     } catch (error) {
       throw new DyFM_Error({
         ...this.getDefaultErrorSettings('getErrorsInRange', error),
+
         errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-GIR0`,
       });
     }
@@ -401,7 +449,7 @@ export class DyNTS_Errors_DataService<
     pageSize: number,
     pageIndex: number,
     issuer: string,
-  ): Promise<DyFM_Paged<T_Errors>> {
+  ): Promise<DyFM_Paged<T_ErrorsRecord>> {
     try {
       if (issuer && !this.issuer) {
         this.issuer = issuer;
@@ -409,7 +457,7 @@ export class DyNTS_Errors_DataService<
 
       const fromDate: Date = DyFM_Time.getDateByRelativeDate(range);
 
-      let errors: T_Errors[] = await this.findDataList({ __lastModified: { $gte: fromDate } }); 
+      let errors: T_ErrorsRecord[] = await this.findDataList({ __lastModified: { $gte: fromDate } }); 
       errors = errors.sort(
         (a, b): number => b.priority - a.priority
       );
@@ -418,6 +466,7 @@ export class DyNTS_Errors_DataService<
     } catch (error) {
       throw new DyFM_Error({
         ...this.getDefaultErrorSettings('getErrorsPaged', error),
+
         errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-GIP0`,
       });
     }
@@ -428,7 +477,7 @@ export class DyNTS_Errors_DataService<
     pageSize: number,
     pageIndex: number,
     issuer: string,
-  ): Promise<DyFM_Paged<T_Errors>> {
+  ): Promise<DyFM_Paged<T_ErrorsRecord>> {
     try {
       if (issuer && !this.issuer) {
         this.issuer = issuer;
@@ -436,7 +485,7 @@ export class DyNTS_Errors_DataService<
 
       const fromDate: Date = DyFM_Time.getDateByRelativeDate(range);
 
-      let errors: T_Errors[] = await this.findDataList({ 
+      let errors: T_ErrorsRecord[] = await this.findDataList({ 
         __lastModified: { $gte: fromDate } 
       });
       errors = errors.sort(
@@ -447,15 +496,16 @@ export class DyNTS_Errors_DataService<
     } catch (error) {
       throw new DyFM_Error({
         ...this.getDefaultErrorSettings('getLastErrors', error),
+
         errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-GLE0`,
       });
     }
   }
 
   async searchErrors(
-    searchQuery: DyFM_SearchQuery<T_Errors>,
+    searchQuery: DyFM_SearchQuery<T_ErrorsRecord>,
     issuer: string,
-    ): Promise<DyFM_SearchResult<T_Errors>> {
+    ): Promise<DyFM_SearchResult<T_ErrorsRecord>> {
     try { 
       if (issuer && !this.issuer) {
         this.issuer = issuer;
@@ -465,6 +515,7 @@ export class DyNTS_Errors_DataService<
     } catch (error) {
       throw new DyFM_Error({
         ...this.getDefaultErrorSettings('searchErrors', error),
+        
         errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-EDS-SE0`,
       });
     }

package/src/_modules/server/server-status/server-status.control-service.ts

@@ -229,7 +229,7 @@ export abstract class DyNTS_ServerStatus_ControlService<
     }
   }
 
-  private async triggerCreateSnapshot(issuer: string): Promise<void> {
+  protected async triggerCreateSnapshot(issuer: string): Promise<void> {
     try {
       const snapshot: T_ServerStatusSnapshot = await this.getServerStatusSnapshot(issuer);
       const serverStatusSnapshot_CS: T_ServerStatusSnapshot_ControlService = 

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

@@ -1902,14 +1902,20 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
       keyIsUnique: dependencyParams.unique,
       keyIsRequired: dependencyParams.required,
     })));
+
+    if (this.depSettings.length === 1) {
+      this.depDataDBService = DyNTS_GlobalService.getDBServiceByKey(
+        this.depSettings[0].dbServiceKey
+      );
+    }
   }
 
   /**
    * 
    * @returns 
    */
-  getDependencyDataDBService(dBServiceKey: string): DyNTS_DBService<any> {
-    if (!dBServiceKey) {
+  getDependencyDataDBService(dBServiceKey?: string): DyNTS_DBService<any> {
+    if (!dBServiceKey && !this.depDataDBService) {
       throw new DyFM_Error({ 
         ...this._getDefaultErrorSettings(
           'getDependencyDataDBService',

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

@@ -490,7 +490,6 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
     }
   }
 
-  // eslint-disable-next-line max-lines-per-function
   async ready(timeout: number = this.defaultReadyTimeout): Promise<void> {
     try {
       if (this.fnLogs) DyFM_Log.log('\nfn:. ready');
@@ -968,10 +967,14 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
         await new Promise<void>((resolve, reject): void => {
           this.systemControls.httpsServer.init = true;
           this.httpsServer
-            .listen(this._portSettings.httpsPort, 'localhost', 0, (): void => {
-              this.systemControls.httpsServer.started = true;
-              DyFM_Log.success(
-                `\nHTTPS (secure) server is listening on port: ${this._portSettings.httpsPort}`
+            .listen(
+              this._portSettings.httpsPort, 
+              this.params.host, 
+              this.params.expressBacklog, 
+              (): void => {
+                this.systemControls.httpsServer.started = true;
+                DyFM_Log.success(
+                  `\nHTTPS (secure) server is listening on port: ${this._portSettings.httpsPort}`
               );
 
               resolve();
@@ -1027,14 +1030,19 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
         this.systemControls.httpServer.init = true;
         await new Promise<void>((resolve, reject): void => {
           this.httpServer = this.openExpress
-            .listen(this._portSettings.httpPort, (): void => {
-              this.systemControls.httpServer.started = true;
-              DyFM_Log.success(
-                `\nHTTP (open) server is listening on port: ${this._portSettings.httpPort}`
-              );
+            .listen(
+              this._portSettings.httpPort, 
+              this.params.host, 
+              this.params.expressBacklog, 
+              (): void => {
+                this.systemControls.httpServer.started = true;
+                DyFM_Log.success(
+                  `\nHTTP (open) server is listening on port: ${this._portSettings.httpPort}`
+                );
 
-              resolve();
-            })
+                resolve();
+              }
+            )
             .on('error', (error): void => {
               if (this.debugLog) DyFM_Log.error(`\nHTTP (open) server ERROR`, error);