@futdevpro/nts-dynamo 1.10.9 → 1.10.11

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

@@ -1,3 +1,4 @@
+import { DyFM_Log } from '@futdevpro/fsm-dynamo';
 
 /**
  * This will hold and set the basic settings of an application
@@ -46,5 +47,29 @@ export class DyNTS_App_Params {
     this.dbUri = set.dbUri ?? `mongodb://localhost:27017/${this.dbName}`;
     this.systemName = set.systemName ?? this.name.replace(' ', '-');
     this.systemShortCodeName = set.systemShortCodeName ?? this.systemName.replace(/[^A-Z]/g, '');
+
+    if (!this.dbName) {
+      DyFM_Log.error(
+        'DyNTS_App_Params.constructor: ' +
+        `dbName is not set in "${this.name}" model.` +
+        'For future compatibility.'
+      );
+    }
+    
+    if (RegExp(/[A-Z]/).exec(this.dbName)) {
+      DyFM_Log.warn(
+        'DyNTS_App_Params.constructor: ' +
+        `dbName should be in snake_case in "${this.dbName}" model.` +
+        'For future compatibility.'
+      );
+    }
+
+    if (this.dbName?.includes('-')) {
+      DyFM_Log.warn(
+        'DyNTS_App_Params.constructor: ' +
+        `dbName should not contain "-" in "${this.dbName}" model.` +
+        'For future compatibility.'
+      );
+    }
   }
 }

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

@@ -3,13 +3,13 @@
 import { Request, Response } from 'express';
 
 import {
-  DyFM_Array, DyFM_Endpoint_SettingsBase, DyFM_Error, DyFM_HttpCallType, DyFM_Log, DyFM_Shared
+  DyFM_Array, DyFM_Endpoint_SettingsBase, DyFM_Error, DyFM_getStackLocation, DyFM_HttpCallType, 
+  DyFM_Log, DyFM_Shared
 } from '@futdevpro/fsm-dynamo';
 
 import { DyNTS_global_settings } from '../../_collections/global-settings.const';
 import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
 import { DyNTS_GlobalService } from '../../_services/core/global.service';
-import { DyNTS_getStackLocation } from '../../_collections/stack.util';
 
 /**
  * High level endpoint for API
@@ -140,7 +140,7 @@ export class DyNTS_Endpoint_Params<
       this.preProcesses = set.preProcesses ?? [];
       this.tasks = set.tasks ?? [];
       
-      this.stack = DyNTS_getStackLocation();
+      this.stack = DyFM_getStackLocation();
     } catch (error) {
       DyFM_Log.error(
         `\nEndpoint params setup failed: name: '${set.name}' ` +

package/src/_models/interfaces/global-settings.interface.ts

@@ -30,6 +30,11 @@ export interface DyNTS_Global_Settings {
    */
   systemShortCodeName?: string;
 
+  /**
+   * this is the version of the system, this will be used for the logs and errors
+   */
+  systemVersion: string;
+
   /**
    * 
    */

package/src/_modules/mock/data-model.mock.spec.ts

@@ -37,7 +37,7 @@ describe('Dependency_Mock', () => {
 
 xdescribe('DyFM_DataModel_Params for Dependency_Mock', () => {
   it('should have correct dataName and properties', () => {
-    expect(dependency_mock_DataParams.dataName).toBe('dependencyMock');
+    expect(dependency_mock_DataParams.dataName).toBe('dependency_mock');
     expect(dependency_mock_DataParams.properties).toEqual({
       string: { type: 'string' },
       number: { type: 'number' },
@@ -87,7 +87,7 @@ describe('Dependent_Mock', () => {
 
 xdescribe('DyFM_DataModel_Params for Dependent_Mock', () => {
   it('should have correct dataName and properties', () => {
-    expect(dependent_mock_DataParams.dataName).toBe('dependentMock');
+    expect(dependent_mock_DataParams.dataName).toBe('dependent_mock');
     expect(dependent_mock_DataParams.properties).toEqual({
       dependencyId: {
         type: 'string',

package/src/_modules/server/error/error.controller.ts

@@ -0,0 +1,210 @@
+
+import { Request, Response } from 'express';
+
+import { DyFM_Array, DyFM_Error, DyFM_HttpCallType, DyFM_Errors } from '@futdevpro/fsm-dynamo';
+import { DyNTS_Controller } from '../../../_services/route/controller.service';
+import { DyNTS_Endpoint_Params } from '../../../_models/control-models/endpoint-params.control-model';
+import { DyNTS_Error_DataService } from './error.data-service';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+
+export abstract class DyNTS_Error_Controller<
+  T_Error extends DyFM_Errors = any,
+  T_ErrorDataService extends DyNTS_Error_DataService = any
+> extends DyNTS_Controller {
+
+  /* static getInstance(): FDPNTS_Error_Controller {
+    return FDPNTS_Error_Controller.getSingletonInstance();
+  } */
+
+  /* protected abstract errorDataService: FDPNTS_Error_DataService<T_Error>; */
+  protected abstract getErrorDataService?(
+    set?: { data?: T_Error, issuer?: string }
+  ): T_ErrorDataService;
+  protected readonly additionalEndpoints: DyNTS_Endpoint_Params[] = [];
+
+  setupEndpoints(): void {
+    /* if (!this.getErrorDataService) {
+      throw new DyFM_Error({
+        message: 'getUserDataService() method not implemented in Error_Controller.',
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-ERC-001`,
+      });
+    } */
+
+    if (!this.additionalEndpoints) {
+      throw new DyFM_Error({
+        message: 'additionalEndpoints must be defined in Error_Controller.',
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-ERC-002`,
+      });
+    }
+
+    this.endpoints = [
+      new DyNTS_Endpoint_Params({
+        name: 'logError',
+        type: DyFM_HttpCallType.post,
+        endpoint: '/error/log',
+        tasks: [
+          async (req: Request, res: Response, issuer?: string): Promise<void> => {
+            const error_DS: T_ErrorDataService = this.getErrorDataService({
+              data: req.body,
+              issuer: issuer ?? req.body?.issuer ?? 'unknown-client',
+            });
+
+            await error_DS.preProcessWBError();
+
+            await error_DS.recordError();
+
+            res.send({
+              result: 'error logged',
+            });
+          },
+        ],
+      }),
+
+      new DyNTS_Endpoint_Params({
+        name: 'markErrorDone',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/error/mark-done/:errorId',
+        tasks: [
+          async (req: Request, res: Response, issuer?: string): Promise<void> => {
+            const error_DS: T_ErrorDataService = this.getErrorDataService({
+              issuer: issuer,
+            });
+  
+            await error_DS.deleteData(req.params.errorId, true);
+  
+            res.send({
+              result: 'error deleted',
+            });
+          },
+        ],
+      }),
+      
+      new DyNTS_Endpoint_Params({
+        name: 'markAllErrorDone',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/error/mark-all-done',
+        tasks: [
+          async (req: Request, res: Response, issuer?: string): Promise<void> => {
+            const error_DS: T_ErrorDataService = this.getErrorDataService({
+              issuer: issuer,
+            });
+  
+            await error_DS.deleteAllData(true);
+  
+            res.send({
+              result: 'all error deleted',
+            });
+          },
+        ],
+      }),
+
+      /* new DyNTS_Endpoint_Params({
+        name: 'markErrorDone',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/mark-error-done/:errorId',
+        tasks: [
+          async (req: Request, res: Response, issuer?: string): Promise<void> => {
+            const errorDataService: FDPNTS_Error_DataService<Error_T> = this.getErrorDataService({
+              data: { _id: req.params.errorId },
+              issuer: issuer,
+            });
+
+            await errorDataService.deleteData();
+
+            res.send({
+              result: 'error deleted',
+            });
+          },
+        ],
+      }), */
+
+      new DyNTS_Endpoint_Params({
+        name: 'getErrors',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/error/get-range/:range',
+        tasks: [
+          async (req: Request, res: Response, issuer: string) : Promise<void> => {
+            const error_DS: T_ErrorDataService = this.getErrorDataService({
+              issuer: issuer,
+            });
+
+            res.send(
+              (await error_DS.getAll()).sort(
+                (a, b): number => b.priority - a.priority
+              ).slice(0, 10)
+            );
+          },
+        ],
+      }),
+
+      new DyNTS_Endpoint_Params({
+        name: 'getErrorsPaged',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/error/get-paged/:range/:pageSize/:pageIndex',
+        tasks: [
+          async (req: Request, res: Response, issuer: string) : Promise<void> => {
+            const error_DS: T_ErrorDataService = this.getErrorDataService({
+              issuer: issuer,
+            });
+
+            let pageSize: number = req.params.pageSize ? +req.params.pageSize : 30;
+            let pageIndex: number = req.params.pageIndex ? +req.params.pageIndex : 0;
+
+            // TODO: temporary fix for too big error list loads
+            if (30 < pageSize) {
+              pageSize = 30;
+              pageIndex = 0;
+            }
+
+            res.send(
+              (await error_DS.getAll()).sort(
+                (a, b): number => b.priority - a.priority
+              ).slice(pageIndex * pageSize, (pageIndex + 1) * pageSize)
+            );
+          },
+        ],
+      }),
+
+      new DyNTS_Endpoint_Params({
+        name: 'getLastErrors',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/error/get-last-paged/:range/:pageSize/:pageIndex',
+        tasks: [
+          async (req: Request, res: Response, issuer: string) : Promise<void> => {
+            const error_DS: T_ErrorDataService = this.getErrorDataService({
+              issuer: issuer,
+            });
+
+            let pageSize: number = req.params.pageSize ? +req.params.pageSize : 30;
+            let pageIndex: number = req.params.pageIndex ? +req.params.pageIndex : 0;
+
+            // TODO: temporary fix for too big error list loads
+            if (30 < pageSize) {
+              pageSize = 30;
+              pageIndex = 0;
+            }
+
+            res.send(
+              DyFM_Array.paged(
+                (await error_DS.getAll()).sort(
+                  (a, b): number => +b.__lastModified - +a.__lastModified
+                ),
+                pageIndex, pageSize
+              )
+              /* (await errorDataService.getAll()).sort(
+                (a, b): number => +b.__lastModified - +a.__lastModified
+              ).slice(pageIndex * pageSize, (pageIndex + 1) * pageSize) */
+            );
+          },
+        ],
+      }),
+
+      ...this.additionalEndpoints,
+    ];
+  }
+}
+
+
+
+
+

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

@@ -0,0 +1,337 @@
+
+
+
+
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_DBUpdate } from '../../../_models/types/db-update.type';
+import { DyNTS_DataService } from '../../../_services/base/data.service';
+
+import {
+  DyFM_AnyError,
+  DyFM_DBFilter,
+  DyFM_DataModel_Params, DyFM_Error, DyFM_ErrorLevel, DyFM_Error_Settings,
+  DyFM_Log, DyFM_Shared, DyFM_clone, DyFM_errorFlag, DyFM_Errors
+} from '@futdevpro/fsm-dynamo';
+
+
+export class DyNTS_Error_DataService<
+  T_Error extends DyFM_Errors = any
+> extends DyNTS_DataService<T_Error> {
+
+  debugLog: boolean = false;
+  readonly version: string = DyNTS_global_settings.systemVersion;
+  protected duplicationCounter: number;
+
+  /* constructor(
+    set: {
+      data?: T_Error,
+      issuer: string,
+    },
+    dataParams: DyFM_DataModel_Params<T_Error>
+  ) {
+    super(
+      new FDP_Error(set?.data) as T_Error,
+      dataParams,
+      set.issuer
+    );
+  } */
+
+  async recordError(data?: T_Error, alwaysRecord?: boolean): Promise<void> {
+    try {
+      if (
+        !alwaysRecord &&
+        this.data?.version?.includes('dev') || 
+        this.data?.version?.includes('alpha') || 
+        this.data?.version?.includes('beta')
+      ) {
+        DyFM_Log.warn('error not saved (dev version)');
+
+        return;
+      }
+
+      if (!data && this.data) {
+        data = this.data;
+      }
+
+      if (!data) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings(
+            'recordError',
+            new Error('error data is not defined')
+          ),
+  
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-EDS-RE1`,
+        });
+      }
+
+      if ([ DyFM_ErrorLevel.user ].includes(data.level)) {
+        DyFM_Log.warn('error not saved (user level)');
+
+        return;
+      }
+
+      if (data.message?.includes('NullReferenceException')) {
+        data.message += '\n' + data.exception.split('() (at <')[0];
+      }
+
+      const duplicateError: T_Error = await this.findData({
+        version: data.version,
+        message: data.message,
+      } as DyFM_DBFilter<T_Error>, true);
+
+      data.d_error = this.checkErrorIsStringifyableOrResolvable(data.d_error) as DyFM_Error;
+      
+      try {
+        JSON.stringify(data);
+      } catch (err) {
+        DyFM_Log.error('error data is not stringifyable!');
+
+        return;
+      }
+
+      if (JSON.stringify(data).length > 16793000) {
+        data.additionalContent = {
+          message: 'error data was too big to save, removed additionalContent',
+        };
+        data.error.additionalContent = {
+          message: 'error data was too big to save, removed additionalContent',
+        };
+
+        if (JSON.stringify(data).length > 16793000) {
+          data.error.errors = [];
+        }
+      }
+
+      if (
+        duplicateError && 
+        duplicateError?.message === data?.message
+      ) {
+        if (!data.__created) {
+          data.__created = new Date();
+        }
+
+        this.duplicationCounter = duplicateError.count + 1;
+
+        await this.updateData({
+          filterBy: { _id: duplicateError._id } as DyFM_DBFilter<T_Error>,
+          update: { 
+            $inc: { count: 1, priority: this.getPriorityMultiplierByLevel(data?.level) },
+          } as DyNTS_DBUpdate<T_Error>,
+        });
+
+        // ezt majd ha leülepedett, hogy biztos nem kellenek a deep duplication-ök 
+        // (a WB-ban kellhettek a user és pc config info-k)
+        /* if (!duplicateError.duplications.includes(data.stackTrace)) {
+          await this.updateData({
+            filterBy: { _id: duplicateError._id } as DyFM_DBFilter<Error_T>,
+            update: { 
+              $push: { duplications: DyFM_clone(data) },
+            } as DyNTS_DBUpdate<Error_T>,
+          }).catch((pushError) => {
+            DyFM_Log.error('pushError:', pushError);
+          });
+        } */
+
+        DyFM_Log.error(
+          'error found, not saving ("known" error), but increased count, ' +
+          '\ncount:', duplicateError.count + 1
+        );
+        DyFM_Log.error(
+          'ErrorMsg:', data?.message?.replace(/\n/g, '  \n')
+        );
+
+        if (this.debugLog) DyFM_Log.error('Error:', data);
+      } else {
+        DyFM_Log.log('error not found, saving....');
+        DyFM_Log.error(
+          'ErrorMsg:', data?.message?.replace(/\n/g, '  \n')
+        );        
+
+        if (this.debugLog) DyFM_Log.error('Error:', data);
+
+        data.priority = this.getPriorityMultiplierByLevel(data?.level);
+        data.duplications.push(DyFM_clone(data));
+
+        this.duplicationCounter = 1;
+
+        await this.saveData();
+        DyFM_Log.warn('error saved');
+      }
+    } catch (error) {
+      DyFM_Log.error('recordError error:', error);
+      /* throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'recordError',
+          error
+        ),
+
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-EDS-RE0`,
+      }); */
+    }
+  }
+
+  async preProcessWBError(): Promise<void> {
+    try {
+      const innerError = this.data?.error;
+
+      if (
+        innerError && 
+        !innerError?.message &&
+        !innerError?.userMessage &&
+        !innerError?.d_error?.message &&
+        !innerError?.d_error?.userMessage
+      ) {
+        delete this.data.error;
+      }
+
+      const innerDError: DyFM_Error = this.data?.d_error;
+
+      if (
+        innerDError && 
+        !innerDError?._message &&
+        !innerDError?.__userMessage &&
+        !innerDError?._errorCode
+      ) {
+        delete this.data.d_error;
+      }
+
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'preProcessWBError',
+          error
+        ),
+
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-EDS-PPE0`,
+      });
+    }
+  }
+
+  async handleInternalError(
+    error: DyFM_AnyError | any, 
+    issuer: string,
+    alwaysRecord?: boolean,
+  ): Promise<void> {
+    try {    
+      if (this.debugLog) DyFM_Log.log('handleInternalError');
+
+      if ((error as DyFM_Error)?.flag?.includes(DyFM_errorFlag)) {
+        this.data = new DyFM_Errors({
+          issuer: issuer,
+          version: 'SERVER-' + this.version,
+
+          source: 'INTERNAL-SERVER-ERROR: ' + (error as DyFM_Error)?.___issuerService,
+
+          stackTrace: (error as DyFM_Error)?._errorCodes,
+          error: (error as DyFM_Error)?.getErrorSimplified?.(),
+          level: (error as DyFM_Error)?.level ?? DyFM_ErrorLevel.error,
+
+          message: (error as DyFM_Error)?._message,
+          exceptionObj: 
+            (error as DyFM_Error)?.errors?.map(
+              (e: DyFM_Error): DyFM_Error_Settings | ''  => e?.getErrorSimplified?.() ?? ''
+            ),
+
+          additionalContent: (error as DyFM_Error)?.additionalContent,
+        }) as T_Error;       
+      } else {
+        this.data = new DyFM_Errors({
+          issuer: issuer,
+          version: 'SERVER-' + this.version,
+
+          source: 'UNEXPECTED-SERVER-ERROR',
+
+          stackTrace: (error as Error)?.stack.split('\n'),
+          error: error,
+          level: DyFM_ErrorLevel.critical,
+
+          message: (error as Error)?.message,
+          exceptionObj: (error as Error)?.stack?.split('\n'),
+        }) as T_Error;
+      }
+
+      /* if (!(error as FDP_Error)?.flag?.includes('WB-ERROR-OBJECT')) {
+        DyFM_Log.H_error('__ERROR__:', error);
+      } */
+
+      await this.recordError(this.data, alwaysRecord);
+
+      if (
+        DyNTS_global_settings.log_settings.highDetailedLogs ||
+        !(error instanceof DyFM_Error)
+      ) {
+        DyFM_Log.H_error(
+          `FDPNTS_Error_DataService handling InternalError...`,
+          `\n    ERROR:`, error
+        );
+      } else {
+        error.logSimple(
+          `FDPNTS_Error_DataService handling InternalError...`
+        );
+      }
+    } catch (error) {
+      DyFM_Log.error('handleInternalError error:', error);
+      /* throw new DyFM_Error({
+        ...this.getDefaultErrorSettings(
+          'handleInternalError',
+          error
+        ),
+
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|FDPNTS-EDS-HIE0`,
+      }); */
+    }
+  }
+
+  private checkErrorIsStringifyableOrResolvable(error: DyFM_Error): DyFM_Error | 'UNRESOLVABLE' {
+    try {
+      JSON.stringify(error);
+    } catch (err) {
+      DyFM_Log.error('error data is not stringifyable! trying to resolve...');
+
+      error = DyFM_Shared.resolveCirculation(error) as DyFM_Error;
+
+      try {
+        JSON.stringify(error);
+      } catch (err) {
+        delete error.additionalContent;
+
+        try {
+          JSON.stringify(error);
+        } catch (err) {
+          DyFM_Log.error('error data is not stringifyable! resolution failed! will not save!');
+
+          return 'UNRESOLVABLE';
+        }
+
+        DyFM_Log.error('error data was too big to save, removed additionalContent');
+      }
+    }   
+
+    return error;
+  }
+
+  private getPriorityMultiplierByLevel(level: DyFM_ErrorLevel): number {
+    switch (level) {
+      case DyFM_ErrorLevel.critical: 
+      case DyFM_ErrorLevel.fatal:
+        return 1000;
+
+      case DyFM_ErrorLevel.error:
+      case DyFM_ErrorLevel.serious:
+        return 100;
+
+      case DyFM_ErrorLevel.warning: 
+        return 10;
+
+      case DyFM_ErrorLevel.info: 
+      case DyFM_ErrorLevel.debug:
+      case DyFM_ErrorLevel.known:
+        return 0.01;
+
+      case DyFM_ErrorLevel.user:        
+      default: 
+        return 0;
+    }
+  }
+
+}

package/src/_modules/server/index.ts

@@ -0,0 +1,11 @@
+
+// ERROR
+export * from './error/error.controller';
+export * from './error/error.data-service';
+
+// SERVER-STATUS
+export * from './server-status/server-status.control-service';
+export * from './server-status/server-status.controller';
+
+
+