@futdevpro/fsm-dynamo 1.7.2 → 1.7.5

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

@@ -5,6 +5,42 @@ import { Dynamo_Metadata } from '../data-models/metadata.data-model';
 
 export type D_Error = Dynamo_Error;
 
+export interface Dynamo_ErrorSettings {
+  _id?: string;
+
+  handled?: boolean;
+  status?: number;
+
+  errorCode?: string;
+  message?: string;
+  userMessage?: string;
+  userMessageTranslateCode?: string;
+  addECToUserMsg?: boolean;
+
+  error?: Error | Dynamo_Error;
+  errors?: (Error | Dynamo_Error)[];
+
+  issuer?: string;
+  issuerSystem?: string;
+  issuerService?: string;
+
+  level?: Dynamo_ErrorLevel;
+
+  levelUpThis?: boolean;
+  additionalContent?: any;
+  
+  modestLog?: boolean;
+  log?: boolean;
+
+  __created?: Date;
+  __createdBy?: string;
+  __lastModified?: Date;
+  __lastModifiedBy?: string;
+  __v?: number;
+}
+
+export type Dynamo_AnyError = Error | Dynamo_Error;
+
 export class Dynamo_Error extends Dynamo_Metadata {
   readonly flag = 'DYNAMO-ERROR-OBJECT-v2';
 
@@ -18,6 +54,7 @@ export class Dynamo_Error extends Dynamo_Metadata {
   __userMessage?: string;
   /** contains all sub error messages, in reversed order */
   __userMessages?: string[] = [];
+  __userMessageTranslateCode?: string;
 
   ___handled?: boolean;
   ___status?: number;
@@ -35,40 +72,16 @@ export class Dynamo_Error extends Dynamo_Metadata {
   additionalContent?: any;
 
   constructor(
-    set?: {
-      _id?: string,
-
-      handled?: boolean,
-      status?: number,
-
-      errorCode?: string,
-      message?: string,
-      userMessage?: string,
-      addECToUserMsg?: boolean,
-
-      error?: Error | Dynamo_Error,
-      errors?: (Error | Dynamo_Error)[],
-
-      issuer?: string,
-      issuerSystem?: string,
-      issuerService?: string,
-
-      level?: Dynamo_ErrorLevel,
-  
-      levelUpThis?: boolean;
-      additionalContent?: any;
-      
-      modestLog?: boolean,
-      log?: boolean,
-
-      __created?: Date,
-      __createdBy?: string,
-      __lastModified?: Date,
-      __lastModifiedBy?: string,
-      __v?: number,
-    }
+    set?: Dynamo_ErrorSettings
   ) {
-    super(set, { issuer: set?.issuerService ?? (set?.error as Dynamo_Error)?.___issuerService ?? dynamo_error_default.issuerService });
+    super(
+      set, 
+      { 
+        issuer: set?.issuerService ?? 
+          (set?.error as Dynamo_Error)?.___issuerService ?? 
+            dynamo_error_default.issuerService 
+      }
+    );
     
     try {
       if (!set) {
@@ -78,32 +91,43 @@ 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;
+      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;
       
       this.level = set?.level ?? (set?.error as Dynamo_Error)?.level ?? Dynamo_ErrorLevel.error;
 
       this.levelUpThis = set?.levelUpThis;
-      this.additionalContent = set?.additionalContent;
+      this.additionalContent = set?.additionalContent ?? 
+        (set?.error as Dynamo_Error)?.additionalContent;
 
       /** set default error code */
       if (!set.errorCode) {
         set.errorCode = dynamo_error_default.errorCode;
       }
+
       /** set default error (self defined) */
       if (!set?.error) {
         set.error = new Error();
         const errorStack: string[] = set.error.stack.split('\n');
+
         errorStack.splice(1, 1);
         set.error.stack = errorStack.join('\n');
       }
 
       /** set errorCodes */
       const previousErrorCodes: string[] = [];
+
       if ((set?.error as Dynamo_Error)?._errorCodes) {
-        previousErrorCodes.push(...(set?.error as Dynamo_Error)?._errorCodes);
+        previousErrorCodes.push(...(set?.error as Dynamo_Error)._errorCodes);
       }
+
       if (!set.errorCode) {
         set.errorCode = dynamo_error_default.errorCode;
       }
@@ -112,31 +136,45 @@ export class Dynamo_Error extends Dynamo_Metadata {
 
       /** bring up non NTS and non default first error */
       const filteredErrorCodes: string[] = this._errorCodes.filter(
-        (code: string) => code && code !== dynamo_error_default.errorCode && !code.includes('NTS-')
+        (code: string): boolean => 
+          code && code !== dynamo_error_default.errorCode && !code.includes('NTS-')
       );
+
       this._errorCode = filteredErrorCodes[0] ?? this._errorCodes?.[0];
-      const highlightedErrorCodeIndex: number = this._errorCodes.findIndex(code => code === filteredErrorCodes?.[0]);
+      const highlightedErrorCodeIndex: number = this._errorCodes.findIndex(
+        (code: string): boolean => code === filteredErrorCodes?.[0]
+      );
 
       /** set message */
       if (!set.message) {
         /** simple - non-dynamo - error */
-        if (!(set?.error as Dynamo_Error)?.flag?.includes('DYNAMO') && (set?.error as Error)?.message) {
+        if (
+          !(set?.error as Dynamo_Error)?.flag?.includes('DYNAMO') && 
+          (set?.error as Error)?.message
+        ) {
           set.message = (set?.error as Error)?.message;
         } else if ((set.error as Error).stack) {
         /** error not defined - self defining */
           const posFull = (set.error as Error).stack.split('\n')?.[1]?.split('\\');
+
           set.message = dynamo_error_default.message + '; ' + posFull[posFull.length - 1];
         }
       }
       /** set messages */
       const previousMessages: string[] = [];
+      
       if ((set?.error as Dynamo_Error)?._messages) {
-        previousMessages.push(...(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 = [ ...previousMessages, set?.message, ].filter(Boolean);
-      if (-1 < highlightedErrorCodeIndex && this._messages[highlightedErrorCodeIndex] && this._messages[highlightedErrorCodeIndex] !== dynamo_error_default.message) {
+
+      if (
+        -1 < highlightedErrorCodeIndex && 
+        this._messages[highlightedErrorCodeIndex] && 
+        this._messages[highlightedErrorCodeIndex] !== dynamo_error_default.message
+      ) {
         this._message = this._messages[highlightedErrorCodeIndex];
       } else {
         this._message = this._messages?.[0];
@@ -144,42 +182,61 @@ export class Dynamo_Error extends Dynamo_Metadata {
 
       /** set userMessages */
       const previousUserMessages: string[] = [];
+
       if ((set?.error as Dynamo_Error)?.__userMessages) {
-        previousUserMessages.push(...(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.userMessage !== dynamo_error_default.userMessage && set.errorCode) {
-        set.userMessage += `\nErrorCode: ${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);
-      if (-1 < highlightedErrorCodeIndex && this.__userMessages[highlightedErrorCodeIndex] && this.__userMessages[highlightedErrorCodeIndex] !== dynamo_error_default.userMessage) {
+
+      if (
+        -1 < highlightedErrorCodeIndex && 
+        this.__userMessages[highlightedErrorCodeIndex] && 
+        this.__userMessages[highlightedErrorCodeIndex] !== dynamo_error_default.userMessage
+      ) {
         this.__userMessage = this.__userMessages[highlightedErrorCodeIndex];
       } else {
         this.__userMessage = this.__userMessages.filter(
-          (msg: string) => msg && msg !== dynamo_error_default.userMessage
+          (msg: string): boolean => msg && msg !== dynamo_error_default.userMessage
         )?.[0];
       }
 
+      /** set userMessageTranslateCode */
+      set.userMessageTranslateCode = 
+        set?.userMessageTranslateCode ?? 
+        (set?.error as Dynamo_Error)?.__userMessageTranslateCode;
+
       /** set errors */
       const previousErrors: (Error | Dynamo_Error)[] = [];
+
       if ((set?.error as Dynamo_Error)?.errors) {
-        previousErrors.push(...(set?.error as Dynamo_Error)?.errors);
+        previousErrors.push(...(set?.error as Dynamo_Error).errors);
       }
       this.errors = [ ...previousErrors, set?.error ].filter(Boolean);
+
       if (set?.errors) {
         if (0 < this.errors.length) {
-          this.errors.push(...set?.errors);
+          this.errors.push(...set.errors);
         } else {
           this.errors.push(
             new Error('there are multiple errors. check errors after this one'), 
-            ...set?.errors,
+            ...set.errors,
           );
         }
       }
       this.error = this.errors?.[0];
-      this.errors.map((error: Error | Dynamo_Error) => {
+      this.errors.map((error: Error | Dynamo_Error): any => {
         if ((error as Dynamo_Error)?.flag?.includes('DYNAMO')) {
           const subError = { ...error };
           
@@ -192,8 +249,9 @@ export class Dynamo_Error extends Dynamo_Metadata {
       });
       
       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);
       }
@@ -209,13 +267,14 @@ export class Dynamo_Error extends Dynamo_Metadata {
   }
 
   getErrorSimplified(): Dynamo_Error {
-    const error = { ...this };
+    const error: Dynamo_Error = { ...this };
 
     delete 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;
     }
@@ -224,16 +283,17 @@ export class Dynamo_Error extends Dynamo_Metadata {
   }
 
   getErrorsFlat(): Dynamo_Error {
-    const error = { ...this };
+    const error: Dynamo_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) => {
+    error.errors.map((err: Dynamo_Error): void => {
       const subError = { ...err };
 
       if (subError.errors) {
@@ -243,6 +303,7 @@ export class Dynamo_Error extends Dynamo_Metadata {
       if ((subError.error as Dynamo_Error)?.errors) {
         delete (subError.error as Dynamo_Error).errors;
       }
+
       if ((subError.error as Dynamo_Error)?.error) {
         delete (subError.error as Dynamo_Error).error;
       }
@@ -368,7 +429,7 @@ Unofficial codes
   497 HTTP Request Sent to HTTPS Port
   499 Client Closed Request
 
-  520 Web Server Returned an Unknown Error
+  520 Web Server Returned an any Error
   521 Web Server Is Down
   522 Connection Timed Out
   523 Origin Is Unreachable

package/src/_models/control-models/index.ts

@@ -6,6 +6,5 @@ export * from './data-property-params.control-model';
 export * from './error.control-model';
 export * from './poll.control-model';
 export * from './range-value.control-model';
-export * from '../interfaces/route-settings.interface';
 export * from './usage-action.control-model';
 export * from './usage-data.control-model';

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

@@ -13,7 +13,7 @@ export class Dynamo_Poll<T> {
   private pollDo: (...args) => Promise<T>;
   private pollWhile: (res: T) => boolean;
   private pollEnd: (res: T) => void;
-  private args?: unknown[];
+  private args?: any[];
   private pollDelay?: number;
   private pollPeriod?: number;
   private stopOnFail?: boolean;
@@ -24,7 +24,7 @@ export class Dynamo_Poll<T> {
       pollWhile: (res: T) => boolean,
       pollEnd: (res: T) => void,
       
-      args?: unknown[],
+      args?: any[],
       pollDelay?: number,
       pollPeriod?: number,
       stopOnFail?: boolean,
@@ -39,11 +39,16 @@ export class Dynamo_Poll<T> {
       this.pollDelay = set.pollDelay ? set.pollDelay : 0;
 
       if (set.pollPeriod === 0) {
-        console.error('DYNAMO ERROR: creating polls with 0ms period is not supported! (it will reset to 1000ms (1s))', new Error());
+        console.error(
+          'DYNAMO ERROR: creating polls with 0ms period is not supported! ' +
+          '(it will reset to 1000ms (1s))', new Error());
       }
       this.pollPeriod = set.pollPeriod ? set.pollPeriod : 1000;
+
       if (this.pollPeriod < 300) {
-        console.warn('DYNAMO WARNING: creating polls with less than 300ms period is not recommended!');
+        console.warn(
+          'DYNAMO WARNING: creating polls with less than 300ms period is not recommended!'
+        );
       }
       this.stopOnFail = set.stopOnFail;
       this.startPoll(this.args);
@@ -54,17 +59,18 @@ export class Dynamo_Poll<T> {
     }
   }
 
-  private startPoll(...args: unknown[]): void {
+  private startPoll(...args: any[]): void {
     try {
-      this.poll = timer(this.pollDelay, this.pollPeriod).subscribe(async () => {
-        await this.pollDo(...args).then((res: T) => {
+      this.poll = timer(this.pollDelay, this.pollPeriod).subscribe(async (): Promise<void> => {
+        await this.pollDo(...args).then((res: T): void => {
           if (!this.pollWhile(res)) {
             this.end(res);
           }
-        }).catch((error) => {
+        }).catch((error): void => {
           if (this.stopOnFail) {
             this.stop();
           }
+
           throw new Dynamo_Error({
             message: 'DYNAMO ERROR: \nDynamoPoll: pollDo was UNSUCCESSFUL',
           });
@@ -79,7 +85,7 @@ export class Dynamo_Poll<T> {
     }
   }
 
-  restartPoll(args?: unknown[]): void {
+  restartPoll(args?: any[]): void {
     try {
       if (args) {
         this.startPoll(args);

package/src/_models/control-models/range-value.control-model.ts

@@ -2,15 +2,130 @@
 
 export type D_RangeValue<T> = Dynamo_RangeValue<T>;
 export type D_RangeV<T> = Dynamo_RangeValue<T>;
-export class Dynamo_RangeValue<T> {
+export class Dynamo_RangeValue<T = number> {
+  readonly isRange: boolean = true;
+
   from: T;
   to: T;
 
   constructor(
     from: T,
-    to: T,
+    to?: T,
   ) {
     this.from = from;
-    this.to = to;
+    this.to = to ?? from;
+  }
+
+  newValues(value: Dynamo_RangeValue<T>): void {
+    this.from = value.from;
+    this.to = value.to;
+  }
+
+  addRange(range: Dynamo_RangeValue<number>): void {
+    (this as Dynamo_RangeValue<number>).from += range.from;
+    (this as Dynamo_RangeValue<number>).to += range.to;
+  }
+  
+  subtractRange(range: Dynamo_RangeValue<number>): void {
+    (this as Dynamo_RangeValue<number>).from -= range.from;
+    (this as Dynamo_RangeValue<number>).to -= range.to;
+  }
+
+  multiplyRange(range: Dynamo_RangeValue<number>): void {
+    (this as Dynamo_RangeValue<number>).from *= range.from;
+    (this as Dynamo_RangeValue<number>).to *= range.to;
+  }
+
+  divideRange(range: Dynamo_RangeValue<number>): void {
+    (this as Dynamo_RangeValue<number>).from /= range.from;
+    (this as Dynamo_RangeValue<number>).to /= range.to;
+  }
+
+  add(value: number): void {
+    (this as Dynamo_RangeValue<number>).from += value;
+    (this as Dynamo_RangeValue<number>).to += value;
+  }
+
+  subtract(value: number): void {
+    (this as Dynamo_RangeValue<number>).from -= value;
+    (this as Dynamo_RangeValue<number>).to -= value;
+  }
+
+  multiply(value: number): void {
+    (this as Dynamo_RangeValue<number>).from *= value;
+    (this as Dynamo_RangeValue<number>).to *= value;
+  }
+
+  divide(value: number): void {
+    (this as Dynamo_RangeValue<number>).from /= value;
+    (this as Dynamo_RangeValue<number>).to /= value;
+  }
+
+  clone(): Dynamo_RangeValue<T> {
+    return new Dynamo_RangeValue<T>(this.from, this.to);
+  }
+
+  applyTransform<K = T>(transform: (value: T) => K): Dynamo_RangeValue<K> {
+    return new Dynamo_RangeValue<K>(transform(this.from), transform(this.to));
+  }
+
+  toString = this.stringify;
+  stringify(spaces: boolean = true, auto: boolean = true): string {
+    if (auto && this.from === this.to) {
+      return `${this.from}`;
+    } else if (spaces) {
+      return `${this.from} - ${this.to}`;
+    } else {
+      return `${this.from}-${this.to}`;
+    }
   }
-}
+
+  static reType<T>(value: Dynamo_RangeValue<T>): Dynamo_RangeValue<T> {
+    return new Dynamo_RangeValue<T>(value.from, value.to);
+  }
+
+  static addRange(
+    a: Dynamo_RangeValue<number>, 
+    b: Dynamo_RangeValue<number>
+  ): Dynamo_RangeValue<number> {
+    return new Dynamo_RangeValue<number>(a.from + b.from, a.to + b.to);
+  }
+  
+  static subtractRange(
+    from: Dynamo_RangeValue<number>, 
+    value: Dynamo_RangeValue<number>
+  ): Dynamo_RangeValue<number> {
+    return new Dynamo_RangeValue<number>(from.from - value.from, from.to - value.to);
+  }
+
+  static multiplyRange(
+    from: Dynamo_RangeValue<number>, 
+    value: Dynamo_RangeValue<number>
+  ): Dynamo_RangeValue<number> {
+    return new Dynamo_RangeValue<number>(from.from * value.from, from.to * value.to);
+  }
+
+  static divideRange(
+    from: Dynamo_RangeValue<number>, 
+    value: Dynamo_RangeValue<number>
+  ): Dynamo_RangeValue<number> {
+    return new Dynamo_RangeValue<number>(from.from / value.from, from.to / value.to);
+  }
+
+  static add(a: Dynamo_RangeValue<number>, b: number): Dynamo_RangeValue<number> {
+    return new Dynamo_RangeValue<number>(a.from + b, a.to + b);
+  }
+
+  static subtract(a: Dynamo_RangeValue<number>, b: number): Dynamo_RangeValue<number> {
+    return new Dynamo_RangeValue<number>(a.from - b, a.to - b);
+  }
+
+  static multiply(a: Dynamo_RangeValue<number>, b: number): Dynamo_RangeValue<number> {
+    return new Dynamo_RangeValue<number>(a.from * b, a.to * b);
+  }
+
+  static divide(a: Dynamo_RangeValue<number>, b: number): Dynamo_RangeValue<number> {
+    return new Dynamo_RangeValue<number>(a.from / b, a.to / b);
+  }
+}
+

package/src/_models/control-models/usage-action.control-model.ts

@@ -1,5 +1,5 @@
 
-export type D_UsageAction = Dynamo_UsageAction;;
+export type D_UsageAction = Dynamo_UsageAction;
 export class Dynamo_UsageAction {
   action?: string;
   time?: Date;

package/src/_models/control-models/usage-data.control-model.ts

@@ -13,7 +13,7 @@ export class Dynamo_UsageData {
     set?: Dynamo_UsageData
   ) {
     if (set) {
-      Object.assign(this, set)
+      Object.assign(this, set);
     }
   }
 }

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

@@ -23,5 +23,5 @@ export const customDataModelParams = new Dynamo_DataParams({
   modelParams: [
     { key: 'data', type: 'string', required: true },
   ]
-})
+});
 

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

@@ -34,18 +34,23 @@ export class Dynamo_Metadata {
       if (!this._id && init.id) {
         this._id = init.id;
       }
+
       if (!this.__created) {
         this.__created = new Date();
       }
+
       if (!this.__createdBy) {
         this.__createdBy = init.issuer;
       }
+
       if (!this.__lastModified) {
         this.__lastModified = new Date();
       }
+
       if (!this.__lastModifiedBy) {
         this.__lastModifiedBy = init.issuer;
       }
+      
       if (!this.__v) {
         this.__v = 0;
       }

package/src/_models/data-models/usage-session.data-model.ts

@@ -49,4 +49,4 @@ export const usageSessionModelParams = new Dynamo_DataParams({
     { key: 'totalSessionTime', type: 'number' },
     { key: 'loggedInAs', type: 'string' },
   ]
-})
+});

package/src/_models/interfaces/paged.interace.ts

@@ -0,0 +1,11 @@
+
+
+export interface Dynamo_Paged<T> {
+  pageIndex: number;
+  pageSize: number;
+  total: number;
+  totalPageCount?: number;
+  items: T[];
+}
+
+

package/src/_utils/array.util.spec.ts

@@ -3,13 +3,13 @@
 import { Dynamo_Array } from './array.util';
 import { delay } from './utilities.util';
 
-describe('Dynamo_Array', () => {
+describe('Dynamo_Array', (): void => {
 
-  describe('asyncForEach', () => {
-    it('should call the function for each element in the list', async () => {
+  describe('asyncForEach', (): void => {
+    it('should call the function for each element in the list', async (): Promise<void> => {
       const list = [1, 2, 3];
       const result = [];
-      const func = async (e, i) => { 
+      const func = async (e, i): Promise<void> => { 
         await delay(30);
         result.push(e);
       };
@@ -20,12 +20,13 @@ describe('Dynamo_Array', () => {
     });
   });
 
-  describe('asyncMapArray', () => {
-    it('should call the function for each element in the list', async () => {
+  describe('asyncMapArray', (): void => {
+    it('should call the function for each element in the list', async (): Promise<void> => {
       const list = [1, 2, 3];
       
-      const func = async (e, i) => { 
+      const func = async (e, i): Promise<number> => { 
         await delay(30);
+
         return e * 2;
       };