@futdevpro/fsm-dynamo 1.5.61 → 1.5.63

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

@@ -8,13 +8,15 @@ describe('Dynamo_Error;', () => {
   let error_base: Error;
   let error_0: Dynamo_Error;
   let error_stack_1: Dynamo_Error;
+  let error_stack_withoutSubErrors_1: Dynamo_Error;
   let error_stack_2: Dynamo_Error;
+  let error_stack_withoutSubErrors_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 message_selfDefined: string = dynamo_error_default.message + '; error.control-model.spec.js:69:29';
   
   const errorCode_0: string = 'ASD-ASD-001';
   const errorCode_1: string = 'ASD-ASD-002';
@@ -55,6 +57,15 @@ describe('Dynamo_Error;', () => {
       error: error_0,
     });
 
+    error_stack_withoutSubErrors_1 = {
+      ...error_stack_1,
+    } as Dynamo_Error;
+    error_stack_withoutSubErrors_1.errors.forEach((error: Dynamo_Error) => {
+      const subError = { ...error };
+      delete (subError as Dynamo_Error).errors;
+      return subError;
+    });
+
     error_stack_2 = new Dynamo_Error({
       message: message_2,
       userMessage: userMessage_2,
@@ -63,13 +74,26 @@ describe('Dynamo_Error;', () => {
       error: error_stack_1,
     });
 
+    error_stack_withoutSubErrors_2 = {
+      ...error_stack_2,
+    } as Dynamo_Error;
+    error_stack_withoutSubErrors_2.errors.map((error: Dynamo_Error) => {
+      const subError = { ...error };
+      delete (subError as Dynamo_Error).errors;
+      return subError;
+    });
+
     error_selfDefined = new Dynamo_Error();
   });
 
   if (log) afterAll(async () => {
-    Dynamo_Log.testLog(
-      'afterAll, error_stack_2:', error_stack_2, '\n\nselfDefined:', error_selfDefined
-    );
+    Dynamo_Log.testLog('error_stack_2:\n', error_stack_2);
+    Dynamo_Log.testLog('error_stack_2.getFlat:\n', error_stack_2.getErrorsFlat());
+    Dynamo_Log.testLog('error_stack_2.getSimplified:\n', error_stack_2.getErrorSimplified());
+    Dynamo_Log.testLog('error_stack_withoutSubErrors_2:\n', error_stack_withoutSubErrors_2);
+    Dynamo_Log.testLog('error_selfDefined:\n', error_selfDefined);
+    Dynamo_Log.testLog('error_selfDefined.getFlat:\n', error_selfDefined.getErrorsFlat());
+    Dynamo_Log.testLog('error_selfDefined.getSimplified:\n', error_selfDefined.getErrorSimplified());
   });
   
   describe('should be defined;', () => {
@@ -126,165 +150,165 @@ describe('Dynamo_Error;', () => {
     });
   });
 
-  describe('should have the proper _message;', () => {
+  describe('should have the proper _errorCodes;', () => {
     it('on error_0', () => {
-      expect(error_0._message).toBe(message_base);
+      expect(error_0._errorCodes).toEqual([ errorCode_0 ]);
     });
-
+    
     it('on error_stack_1', () => {
-      expect(error_stack_1._message).toBe(message_base);
+      expect(error_stack_1._errorCodes).toEqual([ errorCode_0, errorCode_1 ]);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2._message).toBe(message_base);
+      expect(error_stack_2._errorCodes).toEqual([ errorCode_0, errorCode_1, errorCode_2 ]);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined._message).toBe(message_selfDefined);
+      expect(error_selfDefined._errorCodes).toEqual([ dynamo_error_default.errorCode ]);
     });
   });
 
-  describe('should have the proper __userMessage;', () => {
+  describe('should have the proper _message;', () => {
     it('on error_0', () => {
-      expect(error_0.__userMessage).toBe(userMessageResult_0);
+      expect(error_0._message).toBe(message_base);
     });
 
     it('on error_stack_1', () => {
-      expect(error_stack_1.__userMessage).toBe(userMessageResult_0);
+      expect(error_stack_1._message).toBe(message_base);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2.__userMessage).toBe(userMessageResult_0);
+      expect(error_stack_2._message).toBe(message_base);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined.__userMessage).toBeUndefined();
+      expect(error_selfDefined._message).toBe(message_selfDefined);
     });
   });
 
-  describe('should have proper error;', () => {
+  describe('should have the proper _messages;', () => {
     it('on error_0', () => {
-      expect(error_0.error).toBe(error_base);
+      expect(error_0._messages).toEqual([ message_base ]);
     });
 
     it('on error_stack_1', () => {
-      expect(error_stack_1.error).toBe(error_base);
+      expect(error_stack_1._messages).toEqual([ message_base, message_1 ]);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2.error).toBe(error_base);
+      expect(error_stack_2._messages).toEqual([ message_base, message_1, message_2 ]);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined.error).toBeUndefined();
+      expect(error_selfDefined._messages).toEqual([ message_selfDefined ]);
     });
   });
 
-  describe('should have proper handled;', () => {
+  describe('should have the proper __userMessage;', () => {
     it('on error_0', () => {
-      expect(error_0.___handled).toBe(false);
+      expect(error_0.__userMessage).toBe(userMessageResult_0);
     });
 
     it('on error_stack_1', () => {
-      expect(error_stack_1.___handled).toBe(true);
+      expect(error_stack_1.__userMessage).toBe(userMessageResult_0);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2.___handled).toBe(true);
+      expect(error_stack_2.__userMessage).toBe(userMessageResult_0);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined.___handled).toBe(false);
+      expect(error_selfDefined.__userMessage).toBeUndefined();
     });
   });
 
-  describe('should have status: undefined;', () => {
+  describe('should have the proper __userMessages;', () => {
     it('on error_0', () => {
-      expect(error_0.___status).toBe(undefined);
+      expect(error_0.__userMessages).toEqual([ userMessageResult_0 ]);
     });
 
     it('on error_stack_1', () => {
-      expect(error_stack_1.___status).toBe(undefined);
+      expect(error_stack_1.__userMessages).toEqual([ userMessageResult_0, dynamo_error_default.userMessage ]);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2.___status).toBe(undefined);
+      expect(error_stack_2.__userMessages).toEqual([ userMessageResult_0, dynamo_error_default.userMessage, userMessageResult_2 ]);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined.___status).toBe(undefined);
+      expect(error_selfDefined.__userMessages).toEqual([ dynamo_error_default.userMessage ]);
     });
   });
 
-  describe('should have the proper _errorCodes;', () => {
+  describe('should have proper error;', () => {
     it('on error_0', () => {
-      expect(error_0._errorCodes).toEqual([ errorCode_0 ]);
+      expect(error_0.error).toBe(error_base);
     });
-    
+
     it('on error_stack_1', () => {
-      expect(error_stack_1._errorCodes).toEqual([ errorCode_0, errorCode_1 ]);
+      expect(error_stack_1.error).toBe(error_base);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2._errorCodes).toEqual([ errorCode_0, errorCode_1, errorCode_2 ]);
+      expect(error_stack_2.error).toBe(error_base);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined._errorCodes).toEqual([ dynamo_error_default.errorCode ]);
+      expect(error_selfDefined.error).toBeDefined();
     });
   });
 
-  describe('should have the proper _messages;', () => {
+  describe('should have the proper errors;', () => {
     it('on error_0', () => {
-      expect(error_0._messages).toEqual([ message_base ]);
+      expect(error_0.errors).toEqual([ error_base ]);
     });
 
     it('on error_stack_1', () => {
-      expect(error_stack_1._messages).toEqual([ message_base, message_1 ]);
+      expect(error_stack_1.errors).toEqual([ error_base, error_0 ]);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2._messages).toEqual([ message_base, message_1, message_2 ]);
+      expect(error_stack_2.errors).toEqual([ error_base, error_0, error_stack_1 ]);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined._messages).toEqual([ message_selfDefined ]);
+      expect(error_selfDefined?.errors?.length).toBe(1);
     });
   });
 
-  describe('should have the proper __userMessages;', () => {
+  describe('should have proper handled;', () => {
     it('on error_0', () => {
-      expect(error_0.__userMessages).toEqual([ userMessageResult_0 ]);
+      expect(error_0.___handled).toBe(false);
     });
 
     it('on error_stack_1', () => {
-      expect(error_stack_1.__userMessages).toEqual([ userMessageResult_0, dynamo_error_default.userMessage ]);
+      expect(error_stack_1.___handled).toBe(true);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2.__userMessages).toEqual([ userMessageResult_0, dynamo_error_default.userMessage, userMessageResult_2 ]);
+      expect(error_stack_2.___handled).toBe(true);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined.__userMessages).toEqual([ dynamo_error_default.userMessage ]);
+      expect(error_selfDefined.___handled).toBe(false);
     });
   });
 
-  describe('should have the proper errors;', () => {
+  describe('should have status: undefined;', () => {
     it('on error_0', () => {
-      expect(error_0.errors).toEqual([ error_base ]);
+      expect(error_0.___status).toBe(undefined);
     });
 
     it('on error_stack_1', () => {
-      expect(error_stack_1.errors).toEqual([ error_base, error_0 ]);
+      expect(error_stack_1.___status).toBe(undefined);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2.errors).toEqual([ error_base, error_0, error_stack_1 ]);
+      expect(error_stack_2.___status).toBe(undefined);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined.errors).toEqual([]);
+      expect(error_selfDefined.___status).toBe(undefined);
     });
   });
 
@@ -341,5 +365,309 @@ describe('Dynamo_Error;', () => {
       expect(error_selfDefined.___issuerService).toBe(dynamo_error_default.issuerService);
     });
   });
+
+  describe('should have get proper simplified;', () => {
+    let simplified;
+
+    describe('on error_0;', () => {
+      beforeEach(() => {
+        simplified = error_0.getErrorSimplified();
+      });
+      
+      it('should be defined', () => {
+        expect(simplified).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(simplified.error).toBeDefined();
+      });
+
+      it('should not have errors', () => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('should not have simplified.error.error', () => {
+        expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
+      });
+
+      it('should not have simplified.error.errors', () => {
+        expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
+      });
+    });
+
+    describe('on error_stack_1;', () => {
+      beforeEach(() => {
+        simplified = error_stack_1.getErrorSimplified();
+      });
+      
+      it('should be defined', () => {
+        expect(simplified).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(simplified.error).toBeDefined();
+      });
+
+      it('should not have errors', () => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('should not have simplified.error.error', () => {
+        expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
+      });
+
+      it('should not have simplified.error.errors', () => {
+        expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
+      });
+    });
+
+    describe('on error_stack_2;', () => {
+      beforeEach(() => {
+        simplified = error_stack_2.getErrorSimplified();
+      });
+      
+      it('should be defined', () => {
+        expect(simplified).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(simplified.error).toBeDefined();
+      });
+
+      it('should not have errors', () => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('should not have simplified.error.error', () => {
+        expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
+      });
+
+      it('should not have simplified.error.errors', () => {
+        expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
+      });
+    });
+
+    describe('on self defined error;', () => {
+      beforeEach(() => {
+        simplified = error_selfDefined.getErrorSimplified();
+      });
+      
+      it('should be defined', () => {
+        expect(simplified).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(simplified.error).toBeDefined();
+      });
+
+      it('should not have errors', () => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('should not have simplified.error.error', () => {
+        expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
+      });
+
+      it('should not have simplified.error.errors', () => {
+        expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
+      });
+    });
+  });
+
+  describe('should have get proper flat;', () => {
+    let flat;
+
+    describe('on error_0;', () => {
+      beforeEach(() => {
+        flat = error_0.getErrorsFlat();
+      });
+      
+      it('should be defined', () => {
+        expect(flat).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(flat.error).toBeDefined();
+      });
+
+      describe('errors...;', () => {
+        it('should have errors', () => {
+          expect(flat?.errors).toBeDefined();
+        });
+        
+        it('should have 1 errors', () => {
+          expect(flat?.errors?.length).toBe(1);
+        });
+
+        flat?.errors?.forEach((error: Dynamo_Error, index: number) => {
+          describe(`on error[${index}];`, () => {
+            it('should be', () => {
+              expect(error).toBeDefined();
+            });
+
+            it(`should have error[${index}].error`, () => {
+              expect(error.error).toBeDefined();
+            });
+
+            it(`should not have error[${index}].errors`, () => {
+              expect(error.errors).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.error`, () => {
+              expect((error.error as Dynamo_Error)?.error).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.errors`, () => {
+              expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
+            });
+          });
+        });
+      });
+    });
+
+    describe('on error_stack_1;', () => {
+      beforeEach(() => {
+        flat = error_stack_1.getErrorsFlat();
+      });
+      
+      it('should be defined', () => {
+        expect(flat).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(flat.error).toBeDefined();
+      });
+
+      describe('errors...;', () => {
+        it('should have errors', () => {
+          expect(flat?.errors).toBeDefined();
+        });
+        
+        it('should have 2 errors', () => {
+          expect(flat?.errors?.length).toBe(2);
+        });
+
+        flat?.errors?.forEach((error: Dynamo_Error, index: number) => {
+          describe(`on error[${index}];`, () => {
+            it('should be', () => {
+              expect(error).toBeDefined();
+            });
+
+            it(`should have error[${index}].error`, () => {
+              expect(error.error).toBeDefined();
+            });
+
+            it(`should not have error[${index}].errors`, () => {
+              expect(error.errors).toBeUndefined();
+            });
+
+            it('should not have error[${index}].error.error', () => {
+              expect((error.error as Dynamo_Error)?.error).toBeUndefined();
+            });
+
+            it('should not have error[${index}].error.errors', () => {
+              expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
+            });
+          });
+        });
+      });
+    });
+
+    describe('on error_stack_2;', () => {
+      beforeEach(() => {
+        flat = error_stack_2.getErrorsFlat();
+      });
+      
+      it('should be defined', () => {
+        expect(flat).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(flat.error).toBeDefined();
+      });
+
+      describe('errors...;', () => {
+        it('should have errors', () => {
+          expect(flat?.errors).toBeDefined();
+        });
+        
+        it('should have 3 errors', () => {
+          expect(flat?.errors?.length).toBe(3);
+        });
+
+        flat?.errors?.forEach((error: Dynamo_Error, index: number) => {
+          describe(`on error[${index}];`, () => {
+            it('should be', () => {
+              expect(error).toBeDefined();
+            });
+
+            it(`should have error[${index}].error`, () => {
+              expect(error.error).toBeDefined();
+            });
+
+            it(`should not have error[${index}].errors`, () => {
+              expect(error.errors).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.error`, () => {
+              expect((error.error as Dynamo_Error)?.error).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.errors`, () => {
+              expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
+            });
+          });
+        });
+      });
+    }); 
+
+    describe('on self defined error;', () => {
+      beforeEach(() => {
+        flat = error_selfDefined.getErrorsFlat();
+      });
+      
+      it('should be defined', () => {
+        expect(flat).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(flat.error).toBeDefined();
+      });
+
+      describe('errors...;', () => {
+        it('should have errors', () => {
+          expect(flat?.errors).toBeDefined();
+        });
+        
+        it('should have 1 errors', () => {
+          expect(flat?.errors?.length).toBe(1);
+        });
+
+        flat?.errors?.forEach((error: Dynamo_Error, index: number) => {
+          describe(`on error[${index}];`, () => {
+            it('should be', () => {
+              expect(error).toBeDefined();
+            });
+
+            it(`should have error[${index}].error`, () => {
+              expect(error.error).toBeDefined();
+            });
+
+            it(`should not have error[${index}].errors`, () => {
+              expect(error.errors).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.error`, () => {
+              expect((error.error as Dynamo_Error)?.error).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.errors`, () => {
+              expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
+            });
+          });
+        });
+      });
+    });
+  });
 });
 

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

@@ -66,7 +66,6 @@ export class Dynamo_Error extends Dynamo_Metadata {
       /** set simple properties */
       this.___handled = Boolean(set?.handled ?? (set?.error as Dynamo_Error)?.___handled);
       this.___status = set?.status ?? (set?.error as Dynamo_Error)?.___status;
-
       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;
@@ -75,6 +74,10 @@ export class Dynamo_Error extends Dynamo_Metadata {
       if (!set.errorCode) {
         set.errorCode = dynamo_error_default.errorCode;
       }
+      /** set default error (self defined) */
+      if (!set?.error) {
+        set.error = new Error();
+      }
 
       /** set errorCodes */
       const previousErrorCodes: string[] = [];
@@ -98,9 +101,9 @@ export class Dynamo_Error extends Dynamo_Metadata {
         /** 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 {
+        } else if ((set.error as Error).stack) {
         /** error not defined */
-          const posFull = new Error().stack.split('\n')?.[2]?.split('\\');
+          const posFull = (set.error as Error).stack.split('\n')?.[2]?.split('\\');
           set.message = dynamo_error_default.message + '; ' + posFull[posFull.length - 1];
         }
       }
@@ -126,7 +129,7 @@ export class Dynamo_Error extends Dynamo_Metadata {
       if (!set.userMessage) {
         set.userMessage = dynamo_error_default.userMessage;
       }
-      if (set.addECToUserMsg && set.errorCode) {
+      if (set.addECToUserMsg && set.userMessage !== dynamo_error_default.userMessage && set.errorCode) {
         set.userMessage += `\nErrorCode: ${set.errorCode}`
       }
       this.__userMessages = [ ...previousUserMessages, set?.userMessage ].filter(Boolean);
@@ -145,6 +148,17 @@ export class Dynamo_Error extends Dynamo_Metadata {
       }
       this.errors = [ ...previousErrors, set?.error ].filter(Boolean);
       this.error = this.errors?.[0];
+      this.errors.map((error: Error | Dynamo_Error) => {
+        if ((error as Dynamo_Error)?.flag?.includes('DYNAMO')) {
+          const subError = { ...error };
+          
+          if ((subError as Dynamo_Error)?.errors) {
+            delete (subError as Dynamo_Error).errors;
+          }
+
+          return subError;
+        }
+      });
       
       if (set?.modestLog) {
         console.error(this._message ?? this.__userMessage ?? this.error)
@@ -168,29 +182,38 @@ export class Dynamo_Error extends Dynamo_Metadata {
 
     delete error.errors;
 
-    if ((error.error as Dynamo_Error)?.errors) {
-      delete (error.error as Dynamo_Error).errors;
-    }
     if ((error.error as Dynamo_Error)?.error) {
       delete (error.error as Dynamo_Error).error;
     }
+    if ((error.error as Dynamo_Error)?.errors) {
+      delete (error.error as Dynamo_Error).errors;
+    }
 
     return error;
   }
 
   getErrorsFlat(): Dynamo_Error {
     const error = { ...this };
+    
+    if ((error.error as Dynamo_Error)?.error) {
+      delete (error.error as Dynamo_Error).error;
+    }
+    if ((error.error as Dynamo_Error)?.errors) {
+      delete (error.error as Dynamo_Error).errors;
+    }
+
+    error.errors.map((err: Dynamo_Error) => {
+      const subError = { ...err };
 
-    error.errors.forEach((err: Dynamo_Error) => {
-      if (err.errors) {
-        delete err.errors;
+      if (subError.errors) {
+        delete subError.errors;
       }
 
-      if ((err.error as Dynamo_Error)?.errors) {
-        delete (err.error as Dynamo_Error).errors;
+      if ((subError.error as Dynamo_Error)?.errors) {
+        delete (subError.error as Dynamo_Error).errors;
       }
-      if ((err.error as Dynamo_Error)?.error) {
-        delete (err.error as Dynamo_Error).error;
+      if ((subError.error as Dynamo_Error)?.error) {
+        delete (subError.error as Dynamo_Error).error;
       }
     });