@futdevpro/fsm-dynamo 1.5.58 → 1.5.60

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;
+}
+

package/src/_models/interfaces/index.ts

@@ -1,5 +1,6 @@
 
 // INTERFACES
+export * from './error-defaults.interface';
 export * from './random-weight.interface';
 export * from './route-settings.interface';
 

package/src/_models/interfaces/location/country-iso.interface.ts

@@ -1,7 +1,7 @@
 
 
-import { Region } from '../../../_enums/region.enum';
-import { SubRegion } from '../../../_enums/sub-region.enum';
+import { Dynamo_Region } from '../../../_enums/region.enum';
+import { Dynamo_SubRegion } from '../../../_enums/sub-region.enum';
 import { CountryDivision } from './country-division.interface';
 
 export interface CountryISO {
@@ -10,9 +10,9 @@ export interface CountryISO {
   iso3: string;
   countryCode: string;
   fullIso: string;
-  region: Region;
+  region: Dynamo_Region;
   regionCode: string;
-  subRegion: SubRegion;
+  subRegion: Dynamo_SubRegion;
   subRegionCode: string;
   subdivisionRegion: string;
   subdivisionRegionCode: string;

package/src/_models/interfaces/location/division-region-data.interface.ts

@@ -1,8 +1,8 @@
-import { SubdivisionRegionType } from '../../../_enums/subdivision-region-type.enum';
+import { Dynamo_SubdivisionRegionType } from '../../../_enums/subdivision-region-type.enum';
 import { CountryISO } from './country-iso.interface';
 
 export interface SubdivisionRegionData extends CountryISO {  
-  type?: SubdivisionRegionType;
+  type?: Dynamo_SubdivisionRegionType;
 }
 
 

package/src/_modules/error-module.index.ts

@@ -1,5 +1,7 @@
 
 // ERROR MODULE
 export * from '../_models/control-models/error.control-model';
+export * from '../_constants/error-defaults.const';
+export * from '../_models/interfaces/error-defaults.interface';
 
 

package/src/_utils/array.util.ts

@@ -3,16 +3,16 @@
 export type D_Array = Dynamo_Array;
 export class Dynamo_Array {  
 
-  static async asyncForEach<T>(list: T[], func: (element: T, index?: number) => Promise<void>): Promise<void> {
+  static async asyncForEach<T>(list: T[], func: (element: T, index?: number, array?: T[]) => Promise<void>): Promise<void> {
     for (let i = 0; i < list.length; i++) {
-      await func(list[i], i);
+      await func(list[i], i, list);
     }
   }
   
-  static async asyncMapArray<T, R>(list: T[], mapFunc: (element: T, index?: number) => Promise<R>): Promise<R[]> {
+  static async asyncMapArray<T, R>(list: T[], mapFunc: (element: T, index?: number, array?: T[]) => Promise<R>): Promise<R[]> {
     const resultList: R[] = [];
     for (let i = 0; i < list.length; i++) {
-      resultList.push(await mapFunc(list[i], i));
+      resultList.push(await mapFunc(list[i], i, list));
     }
     return resultList;
   }

package/src/_utils/log.util.ts

@@ -1,5 +1,5 @@
 
-import { LogStyle } from '../_enums/log-style.enum';
+import { Dynamo_LogStyle } from '../_enums/log-style.enum';
 
 /* export class D_Log implements Dynamo_Log {}; */
 export type Dynamo_L = Dynamo_Log;
@@ -7,34 +7,47 @@ export type D_Log = Dynamo_Log;
 export type D_L = Dynamo_Log;
 
 export class Dynamo_Log {
-  static setStyle(styles: LogStyle[]): void {
+  static highlightedLog(message: string, ...optionalParams: any[]): void {
+    console.log('\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+    console.log(message, ...optionalParams);
+    console.log('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n');
+  }
+  
+  static testLog(message: string, ...optionalParams: any[]): void {
+    console.log('\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+    console.log('TEST');
+    console.log(message, ...optionalParams);
+    console.log('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n');
+  }
+
+  static setStyle(styles: Dynamo_LogStyle[]): void {
     let styleSets = '';
-    styles.forEach((style: LogStyle) => {
+    styles.forEach((style: Dynamo_LogStyle) => {
       styleSets += style;
     });
     console.log(styleSets);
   }
   static resetStyle(): void {
-    console.log(LogStyle.reset);
+    console.log(Dynamo_LogStyle.reset);
   }
 
-  static addStyle(input: string, styles: LogStyle[], dontReset?: boolean): string {
+  static addStyle(input: string, styles: Dynamo_LogStyle[], dontReset?: boolean): string {
     let result = '';
-    styles.forEach((style: LogStyle) => {
+    styles.forEach((style: Dynamo_LogStyle) => {
       result += style;
     });
     result += input;
     if (!dontReset) {
-      result += LogStyle.reset;
+      result += Dynamo_LogStyle.reset;
     }
     return result;
   }
 
   static success(message: string, ...optionalParams: any[]): void {
     if (0 < optionalParams.length) {
-      console.log(`${LogStyle.green}${LogStyle.bright}${message}`, ...optionalParams, LogStyle.reset);
+      console.log(`${Dynamo_LogStyle.green}${Dynamo_LogStyle.bright}${message}`, ...optionalParams, Dynamo_LogStyle.reset);
     } else {
-      console.log(`${LogStyle.green}${LogStyle.bright}${message}${LogStyle.reset}`);
+      console.log(`${Dynamo_LogStyle.green}${Dynamo_LogStyle.bright}${message}${Dynamo_LogStyle.reset}`);
     }
   }
   /** 
@@ -46,9 +59,9 @@ export class Dynamo_Log {
 
   static error(message: string, ...optionalParams: any[]): void {
     if (0 < optionalParams.length) {
-      console.error(`${LogStyle.red}${LogStyle.bright}${message}`, ...optionalParams, LogStyle.reset);
+      console.error(`${Dynamo_LogStyle.red}${Dynamo_LogStyle.bright}${message}`, ...optionalParams, Dynamo_LogStyle.reset);
     } else {
-      console.error(`${LogStyle.red}${LogStyle.bright}${message}${LogStyle.reset}`);
+      console.error(`${Dynamo_LogStyle.red}${Dynamo_LogStyle.bright}${message}${Dynamo_LogStyle.reset}`);
     }
   }
   /** 
@@ -60,9 +73,9 @@ export class Dynamo_Log {
 
   static warn(message: string, ...optionalParams: any[]): void {
     if (0 < optionalParams.length) {
-      console.warn(`${LogStyle.yellow}${LogStyle.bright}${message}`, ...optionalParams, LogStyle.reset);
+      console.warn(`${Dynamo_LogStyle.yellow}${Dynamo_LogStyle.bright}${message}`, ...optionalParams, Dynamo_LogStyle.reset);
     } else {
-      console.warn(`${LogStyle.yellow}${LogStyle.bright}${message}${LogStyle.reset}`);
+      console.warn(`${Dynamo_LogStyle.yellow}${Dynamo_LogStyle.bright}${message}${Dynamo_LogStyle.reset}`);
     }
   }
   /** 
@@ -80,15 +93,15 @@ export class Dynamo_Log {
 
   static highlighted(message: string, ...optionalParams: any[]): void {
     if (0 < optionalParams.length) {
-      console.log(`${LogStyle.white}${LogStyle.bright}${message}`, ...optionalParams, LogStyle.reset);
+      console.log(`${Dynamo_LogStyle.white}${Dynamo_LogStyle.bright}${message}`, ...optionalParams, Dynamo_LogStyle.reset);
     } else {
-      console.log(`${LogStyle.white}${LogStyle.bright}${message}${LogStyle.reset}`);
+      console.log(`${Dynamo_LogStyle.white}${Dynamo_LogStyle.bright}${message}${Dynamo_LogStyle.reset}`);
     }
   }
 
   static removeLogStyles(message: string): string {
-    for (let styleKey of Object(LogStyle)) {
-      message = message.replace(new RegExp(LogStyle[styleKey], 'g'), '');
+    for (let styleKey of Object(Dynamo_LogStyle)) {
+      message = message.replace(new RegExp(Dynamo_LogStyle[styleKey], 'g'), '');
     }
     return message;
   }

package/src/_utils/regions.util.ts

@@ -4,7 +4,7 @@ import * as ISOs from '../_constants/location/country-codes-ISO-3166.json';
 import * as PhoneCodes from '../_constants/location/country-phone-codes.json';
 import * as Divisions from '../_constants/location/country-divisions-ISO-3166-all-list.json';
 
-import { Region } from '../_enums/region.enum';
+import { Dynamo_Region } from '../_enums/region.enum';
 import { Dynamo_Error } from '../_models';
 import { CountryPhoneCode } from '../_models/interfaces/location/country-phone-code.interface';
 import { CountryISO } from '../_models/interfaces/location/country-iso.interface';
@@ -48,8 +48,8 @@ export class Dynamo_Regions {
     }
   }
 
-  static isoToRegion(iso2: string): Region {
-    const region: Region = this.ISOs.find(iso => iso.iso2 == iso2).region;
+  static isoToRegion(iso2: string): Dynamo_Region {
+    const region: Dynamo_Region = this.ISOs.find(iso => iso.iso2 == iso2).region;
     if (!region) {
       throw new Dynamo_Error({ 
         message: `Cannot find ISO-3166 code for this: ${iso2}`