@futdevpro/fsm-dynamo 1.5.50 → 1.5.55

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

@@ -0,0 +1,38 @@
+
+
+import { Dynamo_Array } from './array.util';
+import { delay } from './utilities.util';
+
+describe('Dynamo_Array', () => {
+
+  describe('asyncForEach', () => {
+    it('should call the function for each element in the list', async () => {
+      const list = [1, 2, 3];
+      const result = [];
+      const func = async (e, i) => { 
+        await delay(30);
+        result.push(e);
+      };
+
+      await Dynamo_Array.asyncForEach(list, func);
+
+      expect(result).toEqual(list);
+    });
+  });
+
+  describe('asyncMapArray', () => {
+    it('should call the function for each element in the list', async () => {
+      const list = [1, 2, 3];
+      
+      const func = async (e, i) => { 
+        await delay(30);
+        return e * 2;
+      };
+
+      const result = await Dynamo_Array.asyncMapArray(list, func);
+
+      expect(result).toEqual([2, 4, 6]);
+    });
+  });
+
+});

package/src/_utils/array.util.ts

@@ -0,0 +1,19 @@
+
+
+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> {
+    for (let i = 0; i < list.length; i++) {
+      await func(list[i], i);
+    }
+  }
+  
+  static async asyncMapArray<T, R>(list: T[], mapFunc: (element: T, index: number) => Promise<R>): Promise<R[]> {
+    const resultList: R[] = [];
+    for (let i = 0; i < list.length; i++) {
+      resultList.push(await mapFunc(list[i], i));
+    }
+    return resultList;
+  }
+}

package/src/_utils/index.ts

@@ -0,0 +1,15 @@
+
+// TOOLS
+export * from './array.util';
+export * from './location.util';
+export * from './log.util';
+export * from './random.util';
+export * from './regions.util';
+export * from './round-list.util';
+export * from './shared.static-service';
+export * from './time.util';
+export * from './trigonometry.util';
+export * from './utilities.util';
+export * from './vector.util';
+
+

package/src/{_collections/_tools/dynamo-location.ts → _utils/location.util.ts}

@@ -1,8 +1,9 @@
 
-import { Dynamo_Error } from '../../_models/control-models/dynamo-error';
-import { LocationCoordinates } from '../../_models/control-models/location-coordinates';
-import { Dynamo_Trigonometry } from './dynamo-trigonometry';
+import { Dynamo_Error } from '../_models/control-models/error.control-model';
+import { Dynamo_Trigonometry } from './trigonometry.util';
+import { LocationCoordinates } from '../_models/interfaces/location/location-coordinates.interface';
 
+export type D_Location = Dynamo_Location;
 export class Dynamo_Location {
   
   static getDistanceInKilometres(

package/src/{_collections/_tools/dynamo-log.ts → _utils/log.util.ts}

@@ -1,5 +1,10 @@
 
-import { LogStyle } from '../../_enums/log-style.enum';
+import { LogStyle } from '../_enums/log-style.enum';
+
+/* export class D_Log implements Dynamo_Log {}; */
+export type Dynamo_L = Dynamo_Log;
+export type D_Log = Dynamo_Log;
+export type D_L = Dynamo_Log;
 
 export class Dynamo_Log {
   static setStyle(styles: LogStyle[]): void {
@@ -73,6 +78,14 @@ export class Dynamo_Log {
     this.warn(message, ...optionalParams);
   }
 
+  static highlighted(message: string, ...optionalParams: any[]): void {
+    if (0 < optionalParams.length) {
+      console.log(`${LogStyle.white}${LogStyle.bright}${message}`, ...optionalParams, LogStyle.reset);
+    } else {
+      console.log(`${LogStyle.white}${LogStyle.bright}${message}${LogStyle.reset}`);
+    }
+  }
+
   static removeLogStyles(message: string): string {
     for (let styleKey of Object(LogStyle)) {
       message = message.replace(new RegExp(LogStyle[styleKey], 'g'), '');
@@ -84,11 +97,17 @@ export class Dynamo_Log {
     console.log = () => {};
   }
 
+  static silenceNonErrorLogs(): void {
+    console.log = () => {};
+    console.info = () => {};
+    console.warn = () => {};
+  }
+  
   static silenceConsole(): void {
     console.log = () => {};
+    console.info = () => {};
     console.warn = () => {};
     console.error = () => {};
   }
 }
-export class D_Log implements Dynamo_Log {};
 

package/src/{_collections/_tools/dynamo-random.ts → _utils/random.util.ts}

@@ -1,6 +1,7 @@
 
-import { RandomWeight } from '../../_models/control-models/random-weight';
+import { RandomWeight } from '../_models/interfaces/random-weight.interface';
 
+export type D_Random = Dynamo_Random;
 export class Dynamo_Random {
   static getRandomWeightedInt(min: number, max: number, weights: RandomWeight<number>[]): number {
     weights = weights.sort((a, b) => b.chance - a.chance);

package/src/{_collections/_tools/dynamo-regions.ts → _utils/regions.util.ts}

@@ -1,14 +1,18 @@
 
-import * as ISOs from '../_constants/country-codes-ISO-3166.json';
-import * as PhoneCodes from '../_constants/country-phone-codes.json';
-import * as Divisions from '../_constants/country-divisions-ISO-3166-all-list.json';
-import { Region } from '../../_enums/region.enum';
-import { Dynamo_Error } from '../../_models';
-import { CountryPhoneCode } from '../../_models/control-models/country-phone-code';
-import { JSONListify } from './utilities';
-import { CountryISO } from '../../_models/control-models/country-iso';
-import { CountryDivision } from '../../_models/control-models/country-division';
+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_Error } from '../_models';
+import { CountryPhoneCode } from '../_models/interfaces/location/country-phone-code.interface';
+import { CountryISO } from '../_models/interfaces/location/country-iso.interface';
+import { CountryDivision } from '../_models/interfaces/location/country-division.interface';
+
+import { JSONListify } from './utilities.util';
+
+export type D_Regions = Dynamo_Regions;
 export class Dynamo_Regions {
   /* static divisions: DivisionCollection = Dynamo_Regions.getSubdivisionCollection(); */
   static divisions: CountryDivision[] = Dynamo_Regions.getAllDivisions();
@@ -65,4 +69,5 @@ export class Dynamo_Regions {
       return phoneCode;
     }
   }
-}
+}
+

package/src/{_collections/_tools/dynamo-round-list.ts → _utils/round-list.util.ts}

@@ -1,5 +1,6 @@
 
 
+export type D_RoundList = Dynamo_RoundList;
 export class Dynamo_RoundList {  
   static getOutboundedIndex(listLength: number, outboundIndex: number): number {
     if (!(0 < listLength)) {

package/src/{_collections/_tools/dynamo-shared.service.ts → _utils/shared.static-service.ts}

@@ -1,6 +1,7 @@
 
-import { clone } from './utilities';
+import { clone } from './utilities.util';
 
+export type D_Shared = Dynamo_Shared;
 export class Dynamo_Shared {
 
   /**

package/src/{_collections/_tools/dynamo-time.ts → _utils/time.util.ts}

@@ -1,6 +1,8 @@
 
-import { day, hour, month, week, year } from '../../_constants/times';
+import { day, hour, month, week, year } from '../_constants/times.const';
 
+export type D_Time = Dynamo_Time;
+export type D_T = Dynamo_Time;
 export class Dynamo_Time {
 
   static getAge(birthDate: Date | number | string) {

package/src/{_collections/_tools/dynamo-trigonometry.ts → _utils/trigonometry.util.ts}

@@ -1,4 +1,7 @@
 
+export type D_Trigonometry = Dynamo_Trigonometry;
+export type D_Trig = Dynamo_Trigonometry;
+export type D_Δ = Dynamo_Trigonometry;
 export class Dynamo_Trigonometry {
   
   /**
@@ -60,4 +63,4 @@ export class Dynamo_Trigonometry {
   static radiansToAngle(radians: number): number {
     return radians / Math.PI * 180;
   }
-}
+}

package/src/{_collections/_tools/utilities.ts → _utils/utilities.util.ts}

@@ -9,8 +9,26 @@ export function clone<T>(object: T): T {
   }
 }
 
+export function surfaceClone<T>(object: T): T {
+  try {
+    const result = {};
+    Object.keys(object).forEach((key: string) => {
+      result[key] = object[key];
+    });
+    return result as T;
+  } catch (error) {
+    console.error('clone() failed. This might be happening becouse the object you trying to clone, containes object hooks for its own objects, therefore its creating an object loop. See further information in the detailed error:');
+    throw error;
+  }
+}
+
 export function sameObjects<T>(objA: T, objB: T): boolean {
-  return JSON.stringify(objA) === JSON.stringify(objB);
+  try {
+    return JSON.stringify(objA) === JSON.stringify(objB);
+  } catch (error) {
+    console.error('sameObjects() failed. This might be happening becouse the object you trying to check, containes object hooks for its own objects, therefore its creating an object loop. See further information in the detailed error:');
+    throw error;
+  }
 }
 
 /**

package/src/{_collections/_tools/vector.ts → _utils/vector.util.ts}

@@ -1,5 +1,5 @@
 
-import { Dynamo_Trigonometry } from './dynamo-trigonometry';
+import { Dynamo_Trigonometry } from './trigonometry.util';
 
 export class Vector2 {
   private _x: number;

package/src/index.ts

@@ -1,6 +1,6 @@
 
 // COLLECTIONS
-export * from './_collections';
+export * from './_utils';
 
 // CONSTANTS
 export * from './_constants';

package/src/_collections/index.ts

@@ -1,14 +0,0 @@
-
-// TOOLS
-export * from './_tools/dynamo-location';
-export * from './_tools/dynamo-log';
-export * from './_tools/dynamo-random';
-export * from './_tools/dynamo-regions';
-export * from './_tools/dynamo-round-list';
-export * from './_tools/dynamo-shared.service';
-export * from './_tools/dynamo-time';
-export * from './_tools/dynamo-trigonometry';
-export * from './_tools/utilities';
-export * from './_tools/vector';
-
-

package/src/_models/control-models/dynamo-daily-usage-data.ts

@@ -1,35 +0,0 @@
-
-import { Dynamo_UsageSession } from "../data-models/dynamo-usage-session";
-
-export class Dynamo_DailyUsageData {
-  date?: string;
-  totalVisitTime?: number = 0;
-  averageVisitTime?: number = 0;
-  visitorsHun?: number = 0;
-  visitorsElse?: number = 0;
-
-  visitations?: Dynamo_UsageSession[] = [];
-
-  constructor(
-    set?: {
-      date?: string,
-      totalVisitTime?: number,
-      averageVisitTime?: number,
-      visitorsHun?: number,
-      visitorsElse?: number,
-
-      visitations?: Dynamo_UsageSession[],
-    }
-  ) {
-    if (set) {
-      Object.assign(this, set)
-      /* this.date = set.date;
-      this.totalVisitTime = set.totalVisitTime ? set.totalVisitTime : 0;
-      this.averageVisitTime = set.averageVisitTime ? set.averageVisitTime : 0;
-      this.visitorsHun = set.visitorsHun ? set.visitorsHun : 0;
-      this.visitorsElse = set.visitorsElse ? set.visitorsElse : 0;
-
-      this.visitations = set.visitations ? set.visitations : []; */
-    }
-  }
-}

package/src/_models/control-models/dynamo-data-params.ts

@@ -1,32 +0,0 @@
-
-import { DataModelType } from '../../_enums';
-import { Dynamo_DataPropertyParams } from './dynamo-data-property-params';
-
-export class Dynamo_DataParams {
-  dataName: string;
-  modelType?: DataModelType;
-  dbName: string;
-  modelParams: Dynamo_DataPropertyParams[] = [];
-
-  /** format info */
-  logicalBreakpoints?: number[] = []; 
-
-  constructor(
-    set: {
-      dataName: string,
-      modelType?: DataModelType,
-      modelParams?: Dynamo_DataPropertyParams[],
-      logicalBreakpoints?: number[],
-    }
-  ) {
-    this.dataName = set.dataName;
-    if (set?.modelType && set?.modelType != DataModelType.dataModel) {
-      this.modelType = set.modelType
-    } else {
-      this.modelType = DataModelType.dataModel;
-      this.dbName = set.dataName.charAt(0).toUpperCase() + set.dataName.slice(1);
-    }
-    this.modelParams = set.modelParams ?? [];
-    this.logicalBreakpoints = set.logicalBreakpoints ?? [];
-  }
-}

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

@@ -1,106 +0,0 @@
-import { BasicPropertyType } from '../../_enums/basic-property-type.enum';
-
-/**
- * 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_DataPropertyParams {
-  key?: string;
-  type?: BasicPropertyType | string;
-
-  unique?: boolean;
-  required?: boolean;
-  index?: boolean;
-
-  isDependencyHook?: boolean;
-  /**
-   * This will be used to prehook dependency db service to data service by dataName from dependency data's DynamoNTS_DataPropertyParams
-   * Use the dependency data's DynamoNTS_DataPropertyParams.
-   * 
-   * @example
-   * dependencyName: accountModelParams.dataName
-   */
-  dependencyDataName?: string;
-
-  minlength?: number;
-  maxlength?: number;
-
-  subObjectParams?: Dynamo_DataPropertyParams[] = [];
-
-  additionalValidators?: ((data: any) => void)[];
-
-  constructor(
-    set: {
-      key: string,
-      type: BasicPropertyType | string,
-
-      unique?: boolean,
-      required?: boolean,
-      index?: boolean,
-
-      isDependencyHook?: boolean,
-      /**
-       * This will be used to prehook dependency db service to data service by dataName from dependency data's DynamoNTS_DataPropertyParams
-       * Use the dependency data's DynamoNTS_DataPropertyParams.
-       * 
-       * @example
-       * dependencyName: accountModelParams.dataName
-       */
-      dependencyDataName?: string,
-
-      minlength?: number,
-      maxlength?: number,
-
-      subObjectParams?: Dynamo_DataPropertyParams[],
-
-      additionalValidators?: ((data: any) => void)[],
-    }
-  ) {
-    if (set) {
-      if (!set.key || !set.type) {
-        console.log(`DYNAMO ERROR: \n key or type is missing from DynamoBEDataPropertyParams`, '\n\n', new Error());
-      }
-      this.key = set.key;
-      this.type = set.type;
-
-      this.subObjectParams = set.subObjectParams ?? [];
-
-      this.isDependencyHook = set.isDependencyHook;
-      this.dependencyDataName = set.dependencyDataName;
-      if (set.isDependencyHook && !set.dependencyDataName) {
-        console.log(`DYNAMO ERROR: \n dependencyName missing for dependencyHook from DynamoBEDataPropertyParams (${set.key})`, '\n\n', new Error());
-      }
-
-      this.unique = set.unique;
-      this.required = set.required;
-      this.index = set.index;
-      this.minlength = set.minlength;
-      this.maxlength = set.maxlength;
-      this.additionalValidators = set.additionalValidators;
-    } else {
-      console.log('DYNAMO ERROR: \nMISSING DynamoBEDataPropertyParams constructor input', '\n\n', new Error());
-    }
-  }
-
-  // tslint:disable-next-line: ban-types
-  getBEType?(): String | Number | Boolean | Object | Function | Array<any> | Date {
-    switch (this.type) {
-      case BasicPropertyType.string:
-        return String;
-      case BasicPropertyType.number:
-        return Number;
-      case BasicPropertyType.boolean:
-        return Boolean;
-      case BasicPropertyType.date:
-        return Date;
-      case BasicPropertyType.object:
-      default:
-        if (this.type?.includes('[]')) {
-          return Array;
-        } else if (this.type?.includes('=>') || this.type?.includes('function')) {
-          return Function;
-        } else {
-          return Object;
-        }
-    }
-  }
-}

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

@@ -1,19 +0,0 @@
-
-export class Dynamo_UsageAction {
-  action?: string;
-  time?: Date;
-
-  constructor(
-    set?: {
-      action?: string,
-      time?: Date,
-    }
-  ) {
-    if (set) {
-      Object.assign(this, set)
-      /* this.action = set.action;
-      this.time = set.time; */
-    }
-  }
-}
-

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

@@ -1,27 +0,0 @@
-
-import { Dynamo_UsageAction } from './dynamo-usage-action';
-
-export class Dynamo_UsageData {
-  page?: string;
-  opened?: Date;
-  timeSpentOnPage?: number;
-  actions?: Dynamo_UsageAction[] = [];
-
-  constructor(
-    set?: {
-      page?: string,
-      opened?: Date;
-      timeSpentOnPage?: number,
-      actions?: Dynamo_UsageAction[],
-    }
-  ) {
-    if (set) {
-      Object.assign(this, set)
-      /* this.page = set.page;
-      this.opened = set.opened;
-      this.timeSpentOnPage = set.timeSpentOnPage;
-      this.actions = set.actions ? set.actions : []; */
-    }
-  }
-}
-

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

@@ -1,42 +0,0 @@
-
-import { Dynamo_DataParams } from '../control-models/dynamo-data-params';
-import { Dynamo_Metadata } from './dynamo-metadata';
-
-export class Dynamo_CustomData extends Dynamo_Metadata {
-  data?: string;
-
-  constructor(
-    set?: {
-      _id?: string,
-
-      data?: string,
-      
-      __v?: number,
-      __created?: Date,
-      __createdBy?: string,
-      __lastModified?: Date,
-      __lastModifiedBy?: string,
-    }
-  ) {
-    super(set/* {
-      _id: set?._id,
-      __v: set?.__v,
-      __created: set?.__created,
-      __createdBy: set?.__createdBy,
-      __lastModified: set?.__lastModified,
-      __lastModifiedBy: set?.__lastModifiedBy,
-    } */)
-    if (set) {
-      Object.assign(this, set);
-      /* this.data = set.data; */
-    }
-  }
-}
-
-export const customDataModelParams = new Dynamo_DataParams({
-  dataName: 'customData',
-  modelParams: [
-    { key: 'data', type: 'string', required: true },
-  ]
-})
-

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

@@ -1,37 +0,0 @@
-
-
-export class Dynamo_Metadata {
-  _id?: string;
-
-  __created?: Date;
-  __createdBy?: string;
-  __lastModified?: Date;
-  __lastModifiedBy?: string;
-  __v?: number;
-
-  constructor(
-    set?: {
-      _id?: string,
-
-      __created?: Date,
-      __createdBy?: string,
-      __lastModified?: Date,
-      __lastModifiedBy?: string,
-      __v?: number;
-    } | Dynamo_Metadata
-  ){
-    if (set) {
-      if (!set._id && set._id !== undefined) { 
-        delete set._id;
-      }
-
-      Object.assign(this, set);
-
-      /* this.__created = set.__created;
-      this.__createdBy = set.__createdBy;
-      this.__lastModified = set.__lastModified;
-      this.__lastModifiedBy = set.__lastModifiedBy;
-      this.__v = set.__v; */
-    }
-  }
-}

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

@@ -1,77 +0,0 @@
-
-import { GeoIpLocation } from '../control-models/geo-ip-location';
-import { Dynamo_Metadata } from './dynamo-metadata';
-import { Dynamo_UsageData } from '../control-models/dynamo-usage-data';
-import { Dynamo_DataParams } from '../control-models/dynamo-data-params';
-
-export class Dynamo_UsageSession extends Dynamo_Metadata {
-  date?: string;
-  sessionStart?: Date;
-  sessionEnd?: Date;
-  address?: string;
-  issuer?: string;
-  locationData?: GeoIpLocation;
-
-  usageData?: Dynamo_UsageData[] = [];
-  totalSessionTime?: number;
-  loggedInAs?: string;
-
-  constructor(
-    set?: {
-      _id?: string,
-
-      date?: string;
-      sessionStart?: Date,
-      sessionEnd?: Date,
-      address?: string,
-      issuer?: string,
-      locationData?: GeoIpLocation,
-
-      usageData?: Dynamo_UsageData[],
-      totalSessionTime?: number,
-      loggedInAs?: string,
-
-      __created?: Date,
-      __createdBy?: string,
-      __lastModified?: Date,
-      __lastModifiedBy?: string,
-      __v?: number
-    } | Dynamo_UsageSession
-  ) {
-    super(set);
-    if (set) {
-      if (!set.date && set.sessionStart) {
-        set.date = set.sessionStart.toISOString().substring(0, 10);
-      }
-      Object.assign(this, set);
-      /* this.sessionStart = set.sessionStart;
-      this.sessionEnd = set.sessionEnd;
-      this.address = set.address;
-      this.issuer = set.issuer;
-      this.locationData = set.locationData;
-
-      this.usageData = set.usageData ? set.usageData : [];
-      this.totalSessionTime = set.totalSessionTime;
-      this.loggedInAs = set.loggedInAs; */
-    }
-  }
-}
-
-export const usageSessionModelParams = new Dynamo_DataParams({
-  dataName: 'usageSession',
-  modelParams: [
-    { key: 'date', type: 'string',
-      required: true, index: true
-    },
-    { key: 'sessionStart', type: 'Date',
-      required: true, index: true
-    },
-    { key: 'sessionEnd', type: 'Date' },
-    { key: 'address', type: 'string' },
-    { key: 'issuer', type: 'string' },
-    { key: 'locationData', type: 'IpApiLocation' },
-    { key: 'usageData', type: 'UsageData[]' },
-    { key: 'totalSessionTime', type: 'number' },
-    { key: 'loggedInAs', type: 'string' },
-  ]
-})