@futdevpro/fsm-dynamo 1.5.56 → 1.5.59

package/src/_models/control-models/error.control-model.spec.ts

@@ -0,0 +1,345 @@
+
+
+import { Dynamo_Error_default } from '../../_constants/error-defaults.const';
+import { Dynamo_Log } from '../../_utils/log.util';
+import { Dynamo_Error } from './error.control-model';
+
+describe('Dynamo_Error;', () => {
+  let error_base: Error;
+  let error_0: Dynamo_Error;
+  let error_stack_1: Dynamo_Error;
+  let error_stack_2: Dynamo_Error;
+  let error_selfDefined: Dynamo_Error;
+
+  const message_base: string = '-TEST ERROR: something failed!-';
+  const message_1: string = 'TEST ERROR MSG (1)';
+  const message_2: string = 'TEST ERROR MSG (2)';
+  const message_selfDefined: string = Dynamo_Error_default.message + '; error.control-model.spec.js:55:29';
+  
+  const errorCode_0: string = 'ASD-ASD-001';
+  const errorCode_1: string = 'ASD-ASD-002';
+  const errorCode_2: string = 'ASD-ASD-003';
+
+  const userMessage_0: string = 'Dynamo_Error TEST was TEST! (0)';
+  const userMessage_2: string = 'Dynamo_Error TEST was TEST! (2)';
+
+  const userMessageResult_0: string = userMessage_0 + `\nErrorCode: ${errorCode_0}`;
+  const userMessageResult_2: string = userMessage_2 + `\nErrorCode: ${errorCode_2}`;
+
+  const issuer: string = 'Dynamo_Error TEST User'
+  const issuerSystem: string = 'Dynamo_FSM TEST';
+  const issuerService_0: string = 'Service-0';
+  const issuerService_1: string = 'Service-1';
+  
+  const log: boolean = false;
+  /* const log: boolean = true; */
+
+  beforeEach(async () => {
+    error_base = new Error(message_base);
+
+    error_0 = new Dynamo_Error({
+      userMessage: userMessage_0,
+      addECToUserMsg: true,
+      errorCode: errorCode_0,
+      issuerSystem: issuerSystem,
+      issuer: issuer,
+      issuerService: issuerService_0,
+      error: error_base,
+    });
+
+    error_stack_1 = new Dynamo_Error({
+      message: message_1,
+      errorCode: errorCode_1,
+      issuerService: issuerService_1,
+      error: error_0,
+    });
+
+    error_stack_2 = new Dynamo_Error({
+      message: message_2,
+      userMessage: userMessage_2,
+      addECToUserMsg: true,
+      handled: true,
+      errorCode: errorCode_2,
+      error: error_stack_1,
+    });
+
+    error_selfDefined = new Dynamo_Error();
+  });
+
+  if (log) afterAll(async () => {
+    Dynamo_Log.testLog(
+      'afterAll, error_stack_2:', error_stack_2, '\n\nselfDefined:', error_selfDefined
+    );
+  });
+  
+  describe('should be defined;', () => {
+    it('error object', () => {
+      expect(error_0).toBeDefined();
+    });
+
+    it('error stack object', () => {
+      expect(error_stack_1).toBeDefined();
+    });
+
+    it('greater error stack object', () => {
+      expect(error_stack_2).toBeDefined();
+    });
+
+    it('self defined error object', () => {
+      expect(error_selfDefined).toBeDefined();
+    });
+  });
+
+  describe('should be instance of Dynamo_Error;', () => {
+    it('error as Dynamo_Error object', () => {
+      expect(error_0).toBeInstanceOf(Dynamo_Error);
+    });
+
+    it('error stack as Dynamo_Error object', () => {
+      expect(error_stack_1).toBeInstanceOf(Dynamo_Error);
+    });
+
+    it('greater error stack as Dynamo_Error object', () => {
+      expect(error_stack_2).toBeInstanceOf(Dynamo_Error);
+    });
+
+    it('self defined error as Dynamo_Error object', () => {
+      expect(error_selfDefined).toBeInstanceOf(Dynamo_Error);
+    });
+  });
+
+  describe('should have the proper _errorCode;', () => {
+    it('on error_0', () => {
+      expect(error_0._errorCode).toBe(errorCode_0);
+    });
+
+    it('on error_stack_1', () => {
+      expect(error_stack_1._errorCode).toBe(errorCode_1);
+    });
+
+    it('on error_stack_2', () => {
+      expect(error_stack_2._errorCode).toBe(errorCode_2);
+    });
+
+    it('on self defined error', () => {
+      expect(error_selfDefined._errorCode).toBe(Dynamo_Error_default.errorCode);
+    });
+  });
+
+  describe('should have the proper _message;', () => {
+    it('on error_0', () => {
+      expect(error_0._message).toBe(message_base);
+    });
+
+    it('on error_stack_1', () => {
+      expect(error_stack_1._message).toBe(message_1);
+    });
+
+    it('on error_stack_2', () => {
+      expect(error_stack_2._message).toBe(message_2);
+    });
+
+    it('on self defined error', () => {
+      expect(error_selfDefined._message).toBe(message_selfDefined);
+    });
+  });
+
+  describe('should have the proper __userMessage;', () => {
+    it('on error_0', () => {
+      expect(error_0.__userMessage).toBe(userMessageResult_0);
+    });
+
+    it('on error_stack_1', () => {
+      expect(error_stack_1.__userMessage).toBe(userMessageResult_0);
+    });
+
+    it('on error_stack_2', () => {
+      expect(error_stack_2.__userMessage).toBe(userMessageResult_2);
+    });
+
+    it('on self defined error', () => {
+      expect(error_selfDefined.__userMessage).toBeUndefined();
+    });
+  });
+
+  describe('should have proper error;', () => {
+    it('on error_0', () => {
+      expect(error_0.error).toBe(error_base);
+    });
+
+    it('on error_stack_1', () => {
+      expect(error_stack_1.error).toBe(error_0);
+    });
+
+    it('on error_stack_2', () => {
+      expect(error_stack_2.error).toBe(error_stack_1);
+    });
+
+    it('on self defined error', () => {
+      expect(error_selfDefined.error).toBeUndefined();
+    });
+  });
+
+  describe('should have proper handled;', () => {
+    it('on error_0', () => {
+      expect(error_0.___handled).toBe(false);
+    });
+
+    it('on error_stack_1', () => {
+      expect(error_stack_1.___handled).toBe(false);
+    });
+
+    it('on error_stack_2', () => {
+      expect(error_stack_2.___handled).toBe(true);
+    });
+
+    it('on self defined error', () => {
+      expect(error_selfDefined.___handled).toBe(false);
+    });
+  });
+
+  describe('should have status: undefined;', () => {
+    it('on error_0', () => {
+      expect(error_0.___status).toBe(undefined);
+    });
+
+    it('on error_stack_1', () => {
+      expect(error_stack_1.___status).toBe(undefined);
+    });
+
+    it('on error_stack_2', () => {
+      expect(error_stack_2.___status).toBe(undefined);
+    });
+
+    it('on self defined error', () => {
+      expect(error_selfDefined.___status).toBe(undefined);
+    });
+  });
+
+  describe('should have the proper _errorCodes;', () => {
+    it('on error_0', () => {
+      expect(error_0._errorCodes).toEqual([ errorCode_0 ]);
+    });
+    
+    it('on error_stack_1', () => {
+      expect(error_stack_1._errorCodes).toEqual([ errorCode_1, errorCode_0 ]);
+    });
+
+    it('on error_stack_2', () => {
+      expect(error_stack_2._errorCodes).toEqual([ errorCode_2, errorCode_1, errorCode_0 ]);
+    });
+
+    it('on self defined error', () => {
+      expect(error_selfDefined._errorCodes).toEqual([ Dynamo_Error_default.errorCode ]);
+    });
+  });
+
+  describe('should have the proper _messages;', () => {
+    it('on error_0', () => {
+      expect(error_0._messages).toEqual([ message_base ]);
+    });
+
+    it('on error_stack_1', () => {
+      expect(error_stack_1._messages).toEqual([ message_1, message_base ]);
+    });
+
+    it('on error_stack_2', () => {
+      expect(error_stack_2._messages).toEqual([ message_2, message_1, message_base ]);
+    });
+
+    it('on self defined error', () => {
+      expect(error_selfDefined._messages).toEqual([ message_selfDefined ]);
+    });
+  });
+
+  describe('should have the proper __userMessages;', () => {
+    it('on error_0', () => {
+      expect(error_0.__userMessages).toEqual([ userMessageResult_0 ]);
+    });
+
+    it('on error_stack_1', () => {
+      expect(error_stack_1.__userMessages).toEqual([ Dynamo_Error_default.userMessage, userMessageResult_0  ]);
+    });
+
+    it('on error_stack_2', () => {
+      expect(error_stack_2.__userMessages).toEqual([ userMessageResult_2, Dynamo_Error_default.userMessage, userMessageResult_0 ]);
+    });
+
+    it('on self defined error', () => {
+      expect(error_selfDefined.__userMessages).toEqual([ Dynamo_Error_default.userMessage ]);
+    });
+  });
+
+  describe('should have the proper errors;', () => {
+    it('on error_0', () => {
+      expect(error_0.errors).toEqual([ error_base ]);
+    });
+
+    it('on error_stack_1', () => {
+      expect(error_stack_1.errors).toEqual([ error_0, error_base ]);
+    });
+
+    it('on error_stack_2', () => {
+      expect(error_stack_2.errors).toEqual([ error_stack_1, error_0, error_base ]);
+    });
+
+    it('on self defined error', () => {
+      expect(error_selfDefined.errors).toEqual([]);
+    });
+  });
+
+  describe('should have the proper issuer;', () => {
+    it('on error_0', () => {
+      expect(error_0.___issuer).toBe(issuer);
+    });
+
+    it('on error_stack_1', () => {
+      expect(error_stack_1.___issuer).toBe(issuer);
+    });
+
+    it('on error_stack_2', () => {
+      expect(error_stack_2.___issuer).toBe(issuer);
+    });
+
+    it('on self defined error', () => {
+      expect(error_selfDefined.___issuer).toBe(Dynamo_Error_default.issuer);
+    });
+  });
+
+  describe('should have the proper issuerSystem;', () => {
+    it('on error_0', () => {
+      expect(error_0.___issuerSystem).toBe(issuerSystem);
+    });
+
+    it('on error_stack_1', () => {
+      expect(error_stack_1.___issuerSystem).toBe(issuerSystem);
+    });
+
+    it('on error_stack_2', () => {
+      expect(error_stack_2.___issuerSystem).toBe(issuerSystem);
+    });
+
+    it('on self defined error', () => {
+      expect(error_selfDefined.___issuerSystem).toBe(Dynamo_Error_default.issuerSystem);
+    });
+  });
+
+  describe('should have the proper issuerService;', () => {
+    it('on error_0', () => {
+      expect(error_0.___issuerService).toBe(issuerService_0);
+    });
+
+    it('on error_stack_1', () => {
+      expect(error_stack_1.___issuerService).toBe(issuerService_1);
+    });
+
+    it('on error_stack_2', () => {
+      expect(error_stack_2.___issuerService).toBe(issuerService_1);
+    });
+
+    it('on self defined error', () => {
+      expect(error_selfDefined.___issuerService).toBe(Dynamo_Error_default.issuerService);
+    });
+  });
+});
+

package/src/_models/control-models/error.control-model.ts

@@ -1,155 +1,151 @@
-
+import { Dynamo_Error_default } from '../../_constants/error-defaults.const';
+import { Dynamo_Log } from '../../_utils/log.util';
+import { Dynamo_Metadata } from '../data-models/metadata.data-model';
 
 export type D_Error = Dynamo_Error;
-export class Dynamo_Error {
-  readonly flag = 'DYNAMO ERROR OBJECT';
-  handled: boolean;
-  status: number;
 
-  errorCode: string;
-  errorCodes: string[] = [];
+export class Dynamo_Error extends Dynamo_Metadata {
+  readonly flag = 'DYNAMO-ERROR-OBJECT-v2';
+
+  _errorCode: string;
+  _errorCodes: string[] = [];
+
+  _message: string;
+  _messages: string[] = [];
+
+  __userMessage: string;
+  __userMessages: string[] = [];
 
-  error: any;
-  errors: any[] = [];
+  ___handled: boolean;
+  ___status: number;
 
-  message: string;
-  messages: string[] = [];
+  ___issuer: string;
+  ___issuerSystem: string;
+  ___issuerService: string;
 
-  userMessage: string;
-  userMessages: string[] = [];
+  error: Error | Dynamo_Error;
+  errors: (Error | Dynamo_Error)[] = [];
 
   constructor(
     set?: {
-      handled?: boolean;
-      status?: number,
-
-      errorCode?: string;
-      errorCodes?: string[];
+      _id?: string,
 
-      error?: any,
-      errors?: any[],
+      handled?: boolean,
+      status?: number,
 
+      errorCode?: string,
       message?: string,
-      messages?: string[],
-
       userMessage?: string,
-      userMessages?: string[],
       addECToUserMsg?: boolean,
+
+      error?: Error | Dynamo_Error,
+
+      issuer?: string,
+      issuerSystem?: string,
+      issuerService?: string,
       
       modestLog?: boolean,
       log?: boolean,
+
+      __created?: Date,
+      __createdBy?: string,
+      __lastModified?: Date,
+      __lastModifiedBy?: string,
+      __v?: number,
     }
   ) {
+    super(set, { issuer: set?.issuerService ?? (set?.error as Dynamo_Error)?.___issuerService ?? Dynamo_Error_default.issuerService });
+    
     try {
-      this.handled = !!set.handled;
+      if (!set) {
+        set = {};
+      }
 
-      if (set) {
-        this.status = set.status ?? set?.error?.status;
+      /** set simple properties */
+      this.___handled = Boolean(set?.handled ?? (set?.error as Dynamo_Error)?.___handled);
+      this.___status = set?.status ?? (set?.error as Dynamo_Error)?.___status;
 
-        if (set.errorCode) {
-          this.errorCodes.push(set.errorCode);
-        }
-        if (set.message) {
-          this.messages.push(set.message);
-        }
-        if (set.userMessage) {
-          this.userMessages.push(set.userMessage);
-        }
+      this.___issuer = set?.issuer ?? (set?.error as Dynamo_Error)?.___issuer ?? Dynamo_Error_default.issuer;
+      this.___issuerSystem = set?.issuerSystem ?? (set?.error as Dynamo_Error)?.___issuerSystem ?? Dynamo_Error_default.issuerSystem;
+      this.___issuerService = set?.issuerService ?? (set?.error as Dynamo_Error)?.___issuerService ?? Dynamo_Error_default.issuerService;
 
-        if (set.error) {
-          if (set.error.error) {
-            this.errors.push(set.error.error);
-          }
-          
-          if (set.error.errors) {
-            if (Array.isArray(set.error.errors)) {
-              this.errors.push(...set.error.errors);
-            } else {
-              this.errors.push(set.error.errors);
-            }
-          }
-
-          if (set.error.errorCode) {
-            this.errorCodes.push(set.error.errorCode);
-          }
-          if (set.error.errorCodes) {
-            if (Array.isArray(set.error.errorCodes)) {
-              this.errorCodes.push(...set.error.errorCodes);
-            } else {
-              this.errorCodes.push(set.error.errorCodes);
-            }
-          }
-
-          if (set.error.message) {
-            this.messages.push(set.error.message);
-          } else if (set.error._message) {
-            this.messages.push(set.error._message);
-          }
-          if (set.error.messages) {
-            if (Array.isArray(set.error.messages)) {
-              if (set.error.messages[0] == this.messages[0]) {
-                set.error.messages.shift();
-              }
-              this.messages.push(...set.error.messages);
-            } else {
-              this.messages.push(set.error.messages);
-            }
-          }
-
-          if (set.error.userMessage) {
-            this.userMessages.push(set.error.userMessage);
-          }
-          if (set.error.userMessages) {            
-            if (Array.isArray(set.error.userMessages)) {
-              /* if (set.error.userMessages[0] == this.userMessages[0]) {
-                set.error.userMessages.shift();
-              } */
-              this.userMessages.push(...set.error.userMessages);
-            } else {
-              this.userMessages.push(set.error.userMessages);
-            }
-          }
-        }
+      /** set default error code */
+      if (!set.errorCode) {
+        set.errorCode = Dynamo_Error_default.errorCode;
       }
 
-      this.errorCode = set?.errorCode ?? this.errorCodes[0];
-      this.userMessage = set?.userMessage ?? this.userMessages[0];
-      this.message = set?.message ?? this.messages[0];
-      this.error = set?.error ?? this.errors[0] ?? new Error(this.message);
-
-      if (0 < this.errorCodes.length && this.errorCode === this.errorCodes[0]) {
-        this.errorCodes.shift();
+      /** set errorCodes */
+      const previousErrorCodes: string[] = [];
+      if ((set?.error as Dynamo_Error)?._errorCodes) {
+        previousErrorCodes.push(...(set?.error as Dynamo_Error)?._errorCodes);
       }
-      if (0 < this.userMessages.length && this.userMessage === this.userMessages[0]) {
-        this.userMessages.shift();
+      if (!set.errorCode) {
+        set.errorCode = Dynamo_Error_default.errorCode;
       }
-      if (0 < this.messages.length && this.message === this.messages[0]) {
-        this.messages.shift();
+      this._errorCodes = [ set?.errorCode, ...previousErrorCodes ].filter(Boolean);
+      this._errorCode = this._errorCodes?.[0];
+
+      /** set message */
+      if (!set.message) {
+        /** simple - non-dynamo - error */
+        if (!(set?.error as Dynamo_Error)?.flag?.includes('DYNAMO') && (set?.error as Error)?.message) {
+          set.message = (set?.error as Error)?.message;
+        } else {
+        /** error not defined */
+          const posFull = new Error().stack.split('\n')?.[2]?.split('\\');
+          set.message = Dynamo_Error_default.message + '; ' + posFull[posFull.length - 1];
+        }
       }
-      if (0 < this.errors.length && this.error === this.errors[0]) {
-        this.errors.shift();
+      /** set messages */
+      const previousMessages: string[] = [];
+      if ((set?.error as Dynamo_Error)?._messages) {
+        previousMessages.push(...(set?.error as Dynamo_Error)?._messages);
+      } else if ((set?.error as Error)?.message) {
+        previousErrorCodes.push((set?.error as Error)?.message);
       }
+      this._messages = [ set?.message, ...previousMessages ].filter(Boolean);
+      this._message = this._messages?.[0];
 
-      if (set.addECToUserMsg) {
-        this.userMessage += `\nErrorCode: ${this.errorCode}`
+      /** set userMessages */
+      const previousUserMessages: string[] = [];
+      if ((set?.error as Dynamo_Error)?.__userMessages) {
+        previousUserMessages.push(...(set?.error as Dynamo_Error)?.__userMessages);
+      }
+      if (!set.userMessage) {
+        set.userMessage = Dynamo_Error_default.userMessage;
       }
+      if (set.addECToUserMsg && set.errorCode) {
+        set.userMessage += `\nErrorCode: ${set.errorCode}`
+      }
+      this.__userMessages = [ set?.userMessage, ...previousUserMessages ].filter(Boolean);
+      this.__userMessage = this.__userMessages.filter((msg: string) => msg && msg !== Dynamo_Error_default.userMessage)?.[0];
 
+      /** set errors */
+      const previousErrors: (Error | Dynamo_Error)[] = [];
+      if ((set?.error as Dynamo_Error)?.errors) {
+        previousErrors.push(...(set?.error as Dynamo_Error)?.errors);
+      }
+      this.errors = [ set?.error, ...previousErrors ].filter(Boolean);
+      this.error = this.errors?.[0];
+      
       if (set?.modestLog) {
-        console.error(this.message ?? this.userMessage ?? this.error)
+        console.error(this._message ?? this.__userMessage ?? this.error)
       }
       if (set?.log) {
         console.error(this);
       }
     } catch (error) {
-      console.error('Internal Dynamo ERROR: Failed to create Dynamo_Error...', error, set);
-      /* throw new Error('Internal Dynamo ERROR: Failed to create Dynamo_Error...'); */
+      Dynamo_Log.error(
+        '\n\nInternal Dynamo ERROR: Failed to create Dynamo_Error...' +
+        '\nerror:\n', error, 
+        '\n\ntrace:', new Error(), 
+        '\n\nset:', set, 
+        '\n\n'
+      );
     }
   }
 }
 
-
-
-
 /*
 
 //                  //

package/src/_models/control-models/poll.control-model.ts

@@ -67,8 +67,6 @@ export class Dynamo_Poll<T> {
           }
           throw new Dynamo_Error({
             message: 'DYNAMO ERROR: \nDynamoPoll: pollDo was UNSUCCESSFUL',
-            error: new Error(error),
-            errors: [ error ]
           });
         });
       });

package/src/_models/data-models/metadata.data-model.ts

@@ -1,4 +1,4 @@
-
+import { Dynamo_Error } from '../control-models';
 
 export type D_Metadata = Dynamo_Metadata;
 export type D_MetaD = Dynamo_Metadata;
@@ -12,14 +12,59 @@ export class Dynamo_Metadata {
   __v?: number;
 
   constructor(
-    set?: Dynamo_Metadata
+    set?: Dynamo_Metadata,
+    forceInit?: { 
+      id?: string,
+      issuer: string,
+    },
+    forceUpdate?: {
+      throwOnMissingId?: boolean,
+      issuer: string,
+    },
   ){
     if (set) {
       if (!set._id && set._id !== undefined) { 
-        delete set._id;
+        set._id = undefined;
+      }
+
+      this._id = set._id;
+      this.__created = set.__created;
+      this.__createdBy = set.__createdBy;
+      this.__lastModified = set.__lastModified;
+      this.__lastModifiedBy = set.__lastModifiedBy;
+      this.__v = set.__v;
+    }
+
+    if (forceInit?.issuer) {
+      if (!this._id && forceInit.id) {
+        this._id = forceInit.id;
+      }
+      if (!this.__created) {
+        this.__created = new Date();
       }
+      if (!this.__createdBy) {
+        this.__createdBy = forceInit.issuer;
+      }
+      if (!this.__lastModified) {
+        this.__lastModified = new Date();
+      }
+      if (!this.__lastModifiedBy) {
+        this.__lastModifiedBy = forceInit.issuer;
+      }
+      if (!this.__v) {
+        this.__v = 0;
+      }
+    }
 
-      Object.assign(this, set);
+    if (forceUpdate?.issuer) {
+      if (!this._id && forceUpdate.throwOnMissingId) {
+        throw new Dynamo_Error({
+          message: `Dynamo_Metadata.constructor: missing _id`,
+        });
+      }
+      this.__lastModified = new Date();
+      this.__lastModifiedBy = forceUpdate.issuer;
+      this.__v = this.__v ? this.__v + 1 : 1;
     }
   }
 }

package/src/_models/interfaces/error-defaults.interface.ts

@@ -0,0 +1,11 @@
+
+
+export interface Dynamo_Error_Defaults {
+  errorCode: string;
+  message: string;
+  userMessage: string;
+  issuer: string;
+  issuerService: string;
+  issuerSystem: string;
+}
+