@futdevpro/fsm-dynamo 1.8.4 → 1.9.1

package/src/_models/control-models/data-property-params.control-model.ts

@@ -1,8 +1,8 @@
-import { Dynamo_BasicPropertyType } from '../../_enums/basic-property-type.enum';
+import { DynamoFM_BasicPropertyType } from '../../_enums/basic-property-type.enum';
 
-export class Dynamo_DataProperty_Settings {
+export class DynamoFM_DataProperty_Settings {
   key: string;
-  type: Dynamo_BasicPropertyType | string;
+  type: DynamoFM_BasicPropertyType | string;
 
   unique?: boolean;
   required?: boolean;
@@ -22,26 +22,26 @@ export class Dynamo_DataProperty_Settings {
   minlength?: number;
   maxlength?: number;
 
-  subObjectParams?: Dynamo_DataProperty_Params[];
+  subObjectParams?: DynamoFM_DataProperty_Params[];
 
   additionalValidators?: ((data: any/* : T[K] */) => void)[];
 }
 
 
-export type D_DataPropertyParams = Dynamo_DataProperty_Params;
-export type D_DPropPs = Dynamo_DataProperty_Params;
+export type DFM_DataPropertyParams = DynamoFM_DataProperty_Params;
+export type DFM_DPropPs = DynamoFM_DataProperty_Params;
 /**
  * This will be used for setting up db. 
  * DataServices also uses this to prehook tools, as db service and dependency db service.
  */
-export class Dynamo_DataProperty_Params extends Dynamo_DataProperty_Settings {
+export class DynamoFM_DataProperty_Params extends DynamoFM_DataProperty_Settings {
 
-  subObjectParams?: Dynamo_DataProperty_Params[] = [];
+  override subObjectParams?: DynamoFM_DataProperty_Params[] = [];
 
-  additionalValidators?: ((data: any/* : T[K] */) => void)[] = [];
+  override additionalValidators?: ((data: any) => void)[] = [];
 
   constructor(
-    set: Dynamo_DataProperty_Settings
+    set: DynamoFM_DataProperty_Settings
   ) {
     super();
     
@@ -80,19 +80,19 @@ export class Dynamo_DataProperty_Params extends Dynamo_DataProperty_Settings {
   // tslint:disable-next-line: ban-types
   getBEType?(): String | Number | Boolean | Object | Function | Array<any> | Date {
     switch (this.type) {
-      case Dynamo_BasicPropertyType.string:
+      case DynamoFM_BasicPropertyType.string:
         return String;
 
-      case Dynamo_BasicPropertyType.number:
+      case DynamoFM_BasicPropertyType.number:
         return Number;
 
-      case Dynamo_BasicPropertyType.boolean:
+      case DynamoFM_BasicPropertyType.boolean:
         return Boolean;
 
-      case Dynamo_BasicPropertyType.date:
+      case DynamoFM_BasicPropertyType.date:
         return Date;
 
-      case Dynamo_BasicPropertyType.object:
+      case DynamoFM_BasicPropertyType.object:
       default:
         if (this.type?.includes('[]')) {
           return Array;

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

@@ -1,36 +1,36 @@
 
 
-import { Dynamo_error_defaults } from '../../_constants/error-defaults.const';
-import { Dynamo_Log } from '../../_utils/log.util';
-import { Dynamo_Error } from './error.control-model';
+import { DynamoFM_error_defaults } from '../../_constants/error-defaults.const';
+import { DynamoFM_Log } from '../../_utils/log.util';
+import { DynamoFM_Error } from './error.control-model';
 
-describe('Dynamo_Error;', (): void => {
+describe('DynamoFM_Error;', (): void => {
   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;
+  let error_0: DynamoFM_Error;
+  let error_stack_1: DynamoFM_Error;
+  let error_stack_withoutSubErrors_1: DynamoFM_Error;
+  let error_stack_2: DynamoFM_Error;
+  let error_stack_withoutSubErrors_2: DynamoFM_Error;
+  let error_selfDefined: DynamoFM_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_defaults.message + 
+  const message_selfDefined: string = DynamoFM_error_defaults.message + 
     '; error.control-model.spec.js:78: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 userMessage_0: string = 'DynamoFM_Error TEST was TEST! (0)';
+  const userMessage_2: string = 'DynamoFM_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 issuer: string = 'DynamoFM_Error TEST User';
+  const issuerSystem: string = 'DynamoFM_FSM TEST';
   const issuerService_0: string = 'Service-0';
   const issuerService_1: string = 'Service-1';
 
@@ -45,7 +45,7 @@ describe('Dynamo_Error;', (): void => {
   beforeEach(async (): Promise<void> => {
     error_base = new Error(message_base);
 
-    error_0 = new Dynamo_Error({
+    error_0 = new DynamoFM_Error({
       userMessage: userMessage_0,
       addECToUserMsg: true,
       errorCode: errorCode_0,
@@ -55,7 +55,7 @@ describe('Dynamo_Error;', (): void => {
       error: error_base,
     });
 
-    error_stack_1 = new Dynamo_Error({
+    error_stack_1 = new DynamoFM_Error({
       message: message_1,
       errorCode: errorCode_1,
       issuerService: issuerService_1,
@@ -66,16 +66,16 @@ describe('Dynamo_Error;', (): void => {
 
     error_stack_withoutSubErrors_1 = {
       ...error_stack_1,
-    } as Dynamo_Error;
-    error_stack_withoutSubErrors_1.errors.forEach((error: Dynamo_Error): any => {
+    } as DynamoFM_Error;
+    error_stack_withoutSubErrors_1.errors.forEach((error: DynamoFM_Error): any => {
       const subError = { ...error };
 
-      delete (subError as Dynamo_Error).errors;
+      delete (subError as DynamoFM_Error).errors;
 
       return subError;
     });
 
-    error_stack_2 = new Dynamo_Error({
+    error_stack_2 = new DynamoFM_Error({
       message: message_2,
       userMessage: userMessage_2,
       addECToUserMsg: true,
@@ -85,26 +85,26 @@ describe('Dynamo_Error;', (): void => {
 
     error_stack_withoutSubErrors_2 = {
       ...error_stack_2,
-    } as Dynamo_Error;
-    error_stack_withoutSubErrors_2.errors.map((error: Dynamo_Error): any => {
+    } as DynamoFM_Error;
+    error_stack_withoutSubErrors_2.errors.map((error: DynamoFM_Error): any => {
       const subError = { ...error };
 
-      delete (subError as Dynamo_Error).errors;
+      delete (subError as DynamoFM_Error).errors;
 
       return subError;
     });
 
-    error_selfDefined = new Dynamo_Error();
+    error_selfDefined = new DynamoFM_Error();
   });
 
   if (log) afterAll(async (): Promise<void> => {
-    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(
+    DynamoFM_Log.testLog('error_stack_2:\n', error_stack_2);
+    DynamoFM_Log.testLog('error_stack_2.getFlat:\n', error_stack_2.getErrorsFlat());
+    DynamoFM_Log.testLog('error_stack_2.getSimplified:\n', error_stack_2.getErrorSimplified());
+    DynamoFM_Log.testLog('error_stack_withoutSubErrors_2:\n', error_stack_withoutSubErrors_2);
+    DynamoFM_Log.testLog('error_selfDefined:\n', error_selfDefined);
+    DynamoFM_Log.testLog('error_selfDefined.getFlat:\n', error_selfDefined.getErrorsFlat());
+    DynamoFM_Log.testLog(
       'error_selfDefined.getSimplified:\n', error_selfDefined.getErrorSimplified()
     );
   });
@@ -127,21 +127,21 @@ describe('Dynamo_Error;', (): void => {
     });
   });
 
-  describe('should be instance of Dynamo_Error;', (): void => {
-    it('error as Dynamo_Error object', (): void => {
-      expect(error_0).toBeInstanceOf(Dynamo_Error);
+  describe('should be instance of DynamoFM_Error;', (): void => {
+    it('error as DynamoFM_Error object', (): void => {
+      expect(error_0).toBeInstanceOf(DynamoFM_Error);
     });
 
-    it('error stack as Dynamo_Error object', (): void => {
-      expect(error_stack_1).toBeInstanceOf(Dynamo_Error);
+    it('error stack as DynamoFM_Error object', (): void => {
+      expect(error_stack_1).toBeInstanceOf(DynamoFM_Error);
     });
 
-    it('greater error stack as Dynamo_Error object', (): void => {
-      expect(error_stack_2).toBeInstanceOf(Dynamo_Error);
+    it('greater error stack as DynamoFM_Error object', (): void => {
+      expect(error_stack_2).toBeInstanceOf(DynamoFM_Error);
     });
 
-    it('self defined error as Dynamo_Error object', (): void => {
-      expect(error_selfDefined).toBeInstanceOf(Dynamo_Error);
+    it('self defined error as DynamoFM_Error object', (): void => {
+      expect(error_selfDefined).toBeInstanceOf(DynamoFM_Error);
     });
   });
 
@@ -159,7 +159,7 @@ describe('Dynamo_Error;', (): void => {
     });
 
     it('on self defined error', (): void => {
-      expect(error_selfDefined._errorCode).toBe(Dynamo_error_defaults.errorCode);
+      expect(error_selfDefined._errorCode).toBe(DynamoFM_error_defaults.errorCode);
     });
   });
 
@@ -177,7 +177,7 @@ describe('Dynamo_Error;', (): void => {
     });
 
     it('on self defined error', (): void => {
-      expect(error_selfDefined._errorCodes).toEqual([ Dynamo_error_defaults.errorCode ]);
+      expect(error_selfDefined._errorCodes).toEqual([ DynamoFM_error_defaults.errorCode ]);
     });
   });
 
@@ -242,18 +242,18 @@ describe('Dynamo_Error;', (): void => {
 
     it('on error_stack_1', (): void => {
       expect(error_stack_1.__userMessages).toEqual(
-        [ userMessageResult_0, Dynamo_error_defaults.userMessage ]
+        [ userMessageResult_0, DynamoFM_error_defaults.userMessage ]
       );
     });
 
     it('on error_stack_2', (): void => {
       expect(error_stack_2.__userMessages).toEqual(
-        [ userMessageResult_0, Dynamo_error_defaults.userMessage, userMessageResult_2 ]
+        [ userMessageResult_0, DynamoFM_error_defaults.userMessage, userMessageResult_2 ]
       );
     });
 
     it('on self defined error', (): void => {
-      expect(error_selfDefined.__userMessages).toEqual([ Dynamo_error_defaults.userMessage ]);
+      expect(error_selfDefined.__userMessages).toEqual([ DynamoFM_error_defaults.userMessage ]);
     });
   });
 
@@ -343,7 +343,7 @@ describe('Dynamo_Error;', (): void => {
     });
 
     it('on self defined error', (): void => {
-      expect(error_selfDefined.___issuer).toBe(Dynamo_error_defaults.issuer);
+      expect(error_selfDefined.___issuer).toBe(DynamoFM_error_defaults.issuer);
     });
   });
   
@@ -379,7 +379,7 @@ describe('Dynamo_Error;', (): void => {
     });
 
     it('on self defined error', (): void => {
-      expect(error_selfDefined.___issuerSystem).toBe(Dynamo_error_defaults.issuerSystem);
+      expect(error_selfDefined.___issuerSystem).toBe(DynamoFM_error_defaults.issuerSystem);
     });
   });
 
@@ -397,7 +397,7 @@ describe('Dynamo_Error;', (): void => {
     });
 
     it('on self defined error', (): void => {
-      expect(error_selfDefined.___issuerService).toBe(Dynamo_error_defaults.issuerService);
+      expect(error_selfDefined.___issuerService).toBe(DynamoFM_error_defaults.issuerService);
     });
   });
 
@@ -422,11 +422,11 @@ describe('Dynamo_Error;', (): void => {
       });
 
       it('should not have simplified.error.error', (): void => {
-        expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
+        expect((simplified.error as DynamoFM_Error)?.error).toBeUndefined();
       });
 
       it('should not have simplified.error.errors', (): void => {
-        expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
+        expect((simplified.error as DynamoFM_Error)?.errors).toBeUndefined();
       });
     });
 
@@ -448,11 +448,11 @@ describe('Dynamo_Error;', (): void => {
       });
 
       it('should not have simplified.error.error', (): void => {
-        expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
+        expect((simplified.error as DynamoFM_Error)?.error).toBeUndefined();
       });
 
       it('should not have simplified.error.errors', (): void => {
-        expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
+        expect((simplified.error as DynamoFM_Error)?.errors).toBeUndefined();
       });
     });
 
@@ -474,11 +474,11 @@ describe('Dynamo_Error;', (): void => {
       });
 
       it('should not have simplified.error.error', (): void => {
-        expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
+        expect((simplified.error as DynamoFM_Error)?.error).toBeUndefined();
       });
 
       it('should not have simplified.error.errors', (): void => {
-        expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
+        expect((simplified.error as DynamoFM_Error)?.errors).toBeUndefined();
       });
     });
 
@@ -500,11 +500,11 @@ describe('Dynamo_Error;', (): void => {
       });
 
       it('should not have simplified.error.error', (): void => {
-        expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
+        expect((simplified.error as DynamoFM_Error)?.error).toBeUndefined();
       });
 
       it('should not have simplified.error.errors', (): void => {
-        expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
+        expect((simplified.error as DynamoFM_Error)?.errors).toBeUndefined();
       });
     });
   });
@@ -534,7 +534,7 @@ describe('Dynamo_Error;', (): void => {
           expect(flat?.errors?.length).toBe(1);
         });
 
-        flat?.errors?.forEach((error: Dynamo_Error, index: number): void => {
+        flat?.errors?.forEach((error: DynamoFM_Error, index: number): void => {
           describe(`on error[${index}];`, (): void => {
             it('should be', (): void => {
               expect(error).toBeDefined();
@@ -549,11 +549,11 @@ describe('Dynamo_Error;', (): void => {
             });
 
             it(`should not have error[${index}].error.error`, (): void => {
-              expect((error.error as Dynamo_Error)?.error).toBeUndefined();
+              expect((error.error as DynamoFM_Error)?.error).toBeUndefined();
             });
 
             it(`should not have error[${index}].error.errors`, (): void => {
-              expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
+              expect((error.error as DynamoFM_Error)?.errors).toBeUndefined();
             });
           });
         });
@@ -582,7 +582,7 @@ describe('Dynamo_Error;', (): void => {
           expect(flat?.errors?.length).toBe(2);
         });
 
-        flat?.errors?.forEach((error: Dynamo_Error, index: number): void => {
+        flat?.errors?.forEach((error: DynamoFM_Error, index: number): void => {
           describe(`on error[${index}];`, (): void => {
             it('should be', (): void => {
               expect(error).toBeDefined();
@@ -597,11 +597,11 @@ describe('Dynamo_Error;', (): void => {
             });
 
             it('should not have error[${index}].error.error', (): void => {
-              expect((error.error as Dynamo_Error)?.error).toBeUndefined();
+              expect((error.error as DynamoFM_Error)?.error).toBeUndefined();
             });
 
             it('should not have error[${index}].error.errors', (): void => {
-              expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
+              expect((error.error as DynamoFM_Error)?.errors).toBeUndefined();
             });
           });
         });
@@ -630,7 +630,7 @@ describe('Dynamo_Error;', (): void => {
           expect(flat?.errors?.length).toBe(3);
         });
 
-        flat?.errors?.forEach((error: Dynamo_Error, index: number): void => {
+        flat?.errors?.forEach((error: DynamoFM_Error, index: number): void => {
           describe(`on error[${index}];`, (): void => {
             it('should be', (): void => {
               expect(error).toBeDefined();
@@ -645,11 +645,11 @@ describe('Dynamo_Error;', (): void => {
             });
 
             it(`should not have error[${index}].error.error`, (): void => {
-              expect((error.error as Dynamo_Error)?.error).toBeUndefined();
+              expect((error.error as DynamoFM_Error)?.error).toBeUndefined();
             });
 
             it(`should not have error[${index}].error.errors`, (): void => {
-              expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
+              expect((error.error as DynamoFM_Error)?.errors).toBeUndefined();
             });
           });
         });
@@ -678,7 +678,7 @@ describe('Dynamo_Error;', (): void => {
           expect(flat?.errors?.length).toBe(1);
         });
 
-        flat?.errors?.forEach((error: Dynamo_Error, index: number): void => {
+        flat?.errors?.forEach((error: DynamoFM_Error, index: number): void => {
           describe(`on error[${index}];`, (): void => {
             it('should be', (): void => {
               expect(error).toBeDefined();
@@ -693,11 +693,11 @@ describe('Dynamo_Error;', (): void => {
             });
 
             it(`should not have error[${index}].error.error`, (): void => {
-              expect((error.error as Dynamo_Error)?.error).toBeUndefined();
+              expect((error.error as DynamoFM_Error)?.error).toBeUndefined();
             });
 
             it(`should not have error[${index}].error.errors`, (): void => {
-              expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
+              expect((error.error as DynamoFM_Error)?.errors).toBeUndefined();
             });
           });
         });