@futdevpro/fsm-dynamo 1.8.4 → 1.9.1

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

@@ -1,14 +1,14 @@
 
-import { Dynamo_DataModel_Params } from '../control-models/data-model-params.control-model';
-import { Dynamo_Metadata } from './metadata.data-model';
+import { DynamoFM_DataModel_Params } from '../control-models/data-model-params.control-model';
+import { DynamoFM_Metadata } from './metadata.data-model';
 
-export type D_CustomData = Dynamo_CustomData;
-export type D_CustomD = Dynamo_CustomData;
-export class Dynamo_CustomData<T = any> extends Dynamo_Metadata {
+export type DFM_CustomData = DynamoFM_CustomData;
+export type DFM_CustomD = DynamoFM_CustomData;
+export class DynamoFM_CustomData<T = any> extends DynamoFM_Metadata {
   data?: T;
 
   constructor(
-    set?: Dynamo_CustomData<T>
+    set?: DynamoFM_CustomData<T>
   ) {
     super(set);
 
@@ -18,10 +18,11 @@ export class Dynamo_CustomData<T = any> extends Dynamo_Metadata {
   }
 }
 
-export const Dynamo_customDataModel_params = new Dynamo_DataModel_Params({
-  dataName: 'customData',
-  properties: [
-    { key: 'data', type: 'string', required: true },
-  ]
-});
+export const DynamoFM_customDataModel_params: DynamoFM_DataModel_Params = 
+  new DynamoFM_DataModel_Params({
+    dataName: 'customData',
+    properties: [
+      { key: 'data', type: 'string', required: true },
+    ]
+  });
 

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

@@ -1,7 +1,7 @@
 
-export type D_Metadata = Dynamo_Metadata;
-export type D_MetaD = Dynamo_Metadata;
-export class Dynamo_Metadata {
+export type DFM_Metadata = DynamoFM_Metadata;
+export type DFM_MetaD = DynamoFM_Metadata;
+export class DynamoFM_Metadata {
   _id?: string;
 
   __created?: Date;
@@ -11,7 +11,7 @@ export class Dynamo_Metadata {
   __v?: number;
 
   constructor(
-    set?: Dynamo_Metadata,
+    set?: DynamoFM_Metadata,
     init?: { 
       id?: string,
       issuer: string,
@@ -57,7 +57,7 @@ export class Dynamo_Metadata {
     }
   }
   
-  static updateMetadata?<T extends Dynamo_Metadata>(data: T, issuer: string, id?: string): T {
+  static updateMetadata?<T extends DynamoFM_Metadata>(data: T, issuer: string, id?: string): T {
     if (!data) {
       return data;
     }

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

@@ -1,24 +1,24 @@
 
-import { Dynamo_Metadata } from './metadata.data-model';
-import { Dynamo_UsageData } from '../control-models/usage-data.control-model';
-import { Dynamo_DataModel_Params } from '../control-models/data-model-params.control-model';
-import { Dynamo_GeoIpLocation } from '../interfaces/location/geo-ip-location.interface';
+import { DynamoFM_Metadata } from './metadata.data-model';
+import { DynamoFM_UsageData } from '../control-models/usage-data.control-model';
+import { DynamoFM_DataModel_Params } from '../control-models/data-model-params.control-model';
+import { DynamoFM_GeoIpLocation } from '../interfaces/location/geo-ip-location.interface';
 
-export type D_UsageSession = Dynamo_UsageSession;
-export class Dynamo_UsageSession extends Dynamo_Metadata {
+export type DFM_UsageSession = DynamoFM_UsageSession;
+export class DynamoFM_UsageSession extends DynamoFM_Metadata {
   date?: string;
   sessionStart?: Date;
   sessionEnd?: Date;
   address?: string;
   issuer?: string;
-  locationData?: Dynamo_GeoIpLocation;
+  locationData?: DynamoFM_GeoIpLocation;
 
-  usageData?: Dynamo_UsageData[] = [];
+  usageData?: DynamoFM_UsageData[] = [];
   totalSessionTime?: number;
   loggedInAs?: string;
 
   constructor(
-    set?: Dynamo_UsageSession
+    set?: DynamoFM_UsageSession
   ) {
     super(set);
 
@@ -32,21 +32,22 @@ export class Dynamo_UsageSession extends Dynamo_Metadata {
   }
 }
 
-export const Dynamo_usageSessionModel_params = new Dynamo_DataModel_Params({
-  dataName: 'usageSession',
-  properties: [
-    { 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' },
-  ]
-});
+export const DynamoFM_usageSessionModel_params: DynamoFM_DataModel_Params = 
+  new DynamoFM_DataModel_Params({
+    dataName: 'usageSession',
+    properties: [
+      { 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' },
+    ]
+  });

package/src/_models/interfaces/error-defaults.interface.ts

@@ -1,6 +1,6 @@
 
 
-export interface Dynamo_Error_Defaults {
+export interface DynamoFM_Error_Defaults {
   errorCode: string;
   message: string;
   userMessage: string;

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

@@ -1,6 +1,6 @@
 
 
-export interface Dynamo_CountryDivision {
+export interface DynamoFM_CountryDivision {
   iso: string;
   code: string;
   name: string;

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

@@ -1,21 +1,21 @@
 
 
-import { Dynamo_Region } from '../../../_enums/region.enum';
-import { Dynamo_SubRegion } from '../../../_enums/sub-region.enum';
-import { Dynamo_CountryDivision } from './country-division.interface';
+import { DynamoFM_Region } from '../../../_enums/region.enum';
+import { DynamoFM_SubRegion } from '../../../_enums/sub-region.enum';
+import { DynamoFM_CountryDivision } from './country-division.interface';
 
-export interface Dynamo_CountryISO {
+export interface DynamoFM_CountryISO {
   name: string;
   iso2: string;
   iso3: string;
   countryCode: string;
   fullIso: string;
-  region: Dynamo_Region;
+  region: DynamoFM_Region;
   regionCode: string;
-  subRegion: Dynamo_SubRegion;
+  subRegion: DynamoFM_SubRegion;
   subRegionCode: string;
   subdivisionRegion: string;
   subdivisionRegionCode: string;
   phoneCode?: string;
-  divisions?: Dynamo_CountryDivision[];
+  divisions?: DynamoFM_CountryDivision[];
 }

package/src/_models/interfaces/location/country-phone-code.interface.ts

@@ -1,5 +1,5 @@
 
-export interface Dynamo_CountryPhoneCode {
+export interface DynamoFM_CountryPhoneCode {
   iso: string;
   country: string;
   code: string;

package/src/_models/interfaces/location/division-collection.interface.ts

@@ -1,5 +1,5 @@
 
-export interface Dynamo_DivisionCollection {
+export interface DynamoFM_Division_Collection {
   [iso2: string]: {
     name: string;
     divisions: {

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

@@ -1,8 +1,8 @@
-import { Dynamo_SubdivisionRegionType } from '../../../_enums/subdivision-region-type.enum';
-import { Dynamo_CountryISO } from './country-iso.interface';
+import { DynamoFM_SubdivisionRegionType } from '../../../_enums/subdivision-region-type.enum';
+import { DynamoFM_CountryISO } from './country-iso.interface';
 
-export interface Dynamo_SubdivisionRegionData extends Dynamo_CountryISO {  
-  type?: Dynamo_SubdivisionRegionType;
+export interface DynamoFM_SubdivisionRegionData extends DynamoFM_CountryISO {  
+  type?: DynamoFM_SubdivisionRegionType;
 }
 
 

package/src/_models/interfaces/location/geo-ip-location.interface.ts

@@ -1,5 +1,5 @@
 
-export interface Dynamo_GeoIpLocation {
+export interface DynamoFM_GeoIpLocation {
   /** [ <low bound of IP block>, <high bound of IP block> ] */
   range: [number, number];
   /** 2 letter ISO-3166-1 country code https://www.iban.com/country-codes */

package/src/_models/interfaces/location/location-coordinates.interface.ts

@@ -1,5 +1,5 @@
 
-export interface Dynamo_LocationCoordinates {
+export interface DynamoFM_LocationCoordinates {
   longitude: number;
   latitude: number;
 }

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

@@ -1,6 +1,6 @@
 
 
-export interface Dynamo_Paged<T> {
+export interface DynamoFM_Paged<T> {
   pageIndex: number;
   pageSize: number;
   total: number;

package/src/_models/interfaces/random-weight.interface.ts

@@ -1,6 +1,6 @@
 
 
-export interface Dynamo_RandomWeight<T> {
+export interface DynamoFM_RandomWeight<T> {
   chance: number;
   result: T;
 }

package/src/_models/interfaces/route-settings.interface.ts

@@ -1,10 +1,10 @@
 
-export type D_RouteSettings = Dynamo_Route_Settings;
-export type D_RouteS = Dynamo_Route_Settings;
-export interface Dynamo_Route_Settings {
+export type DFM_RouteSettings<T> = DynamoFM_Route_Settings<T>;
+export type DFM_RouteS<T> = DynamoFM_Route_Settings<T>;
+export interface DynamoFM_Route_Settings<T> {
   mainRoute: string;
 
   endPoints: {
-    [endpoint: string]: string
+    [key in T as string]: string
   };
 }

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

@@ -1,20 +1,20 @@
 
 
-import { Dynamo_Array } from './array.util';
-import { Dynamo_delay } from './utilities.util';
+import { DynamoFM_Array } from './array.util';
+import { DynamoFM_delay } from './utilities.util';
 
-describe('Dynamo_Array', (): void => {
+describe('DynamoFM_Array', (): void => {
 
   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): Promise<void> => { 
-        await Dynamo_delay(30);
+        await DynamoFM_delay(30);
         result.push(e);
       };
 
-      await Dynamo_Array.asyncForEach(list, func);
+      await DynamoFM_Array.asyncForEach(list, func);
 
       expect(result).toEqual(list);
     });
@@ -25,12 +25,12 @@ describe('Dynamo_Array', (): void => {
       const list = [1, 2, 3];
       
       const func = async (e, i): Promise<number> => { 
-        await Dynamo_delay(30);
+        await DynamoFM_delay(30);
 
         return e * 2;
       };
 
-      const result = await Dynamo_Array.asyncMap(list, func);
+      const result = await DynamoFM_Array.asyncMap(list, func);
 
       expect(result).toEqual([2, 4, 6]);
     });

package/src/_utils/array.util.ts

@@ -1,8 +1,8 @@
-import { Dynamo_Paged } from '../_models/interfaces/paged.interace';
+import { DynamoFM_Paged } from '../_models/interfaces/paged.interace';
 
 
-export type D_Array = Dynamo_Array;
-export class Dynamo_Array {  
+export type DFM_Array = DynamoFM_Array;
+export class DynamoFM_Array {  
 
   static async asyncForEach<T>(
     list: T[], 
@@ -71,7 +71,7 @@ export class Dynamo_Array {
     return array.slice(pageIndex * pageSize, (pageIndex + 1) * pageSize);
   }
 
-  static paged<T>(array: T[], pageIndex: number, pageSize: number): Dynamo_Paged<T> {
+  static paged<T>(array: T[], pageIndex: number, pageSize: number): DynamoFM_Paged<T> {
     return {
       pageIndex,
       pageSize,

package/src/_utils/box-bounds.util.ts

@@ -1,36 +1,36 @@
 
 
-import { Dynamo_Vector2 } from './vector2.util';
+import { DynamoFM_Vector2 } from './vector2.util';
 
-export class Dynamo_BoxBounds {
-  private _pos: Dynamo_Vector2;
-  set pos(value: Dynamo_Vector2) {
+export class DynamoFM_BoxBounds {
+  private _pos: DynamoFM_Vector2;
+  set pos(value: DynamoFM_Vector2) {
     this._pos = value;
 
     this.calcCenter();
   }
-  get pos(): Dynamo_Vector2 { 
+  get pos(): DynamoFM_Vector2 { 
     return this._pos;
   }
 
-  private _size: Dynamo_Vector2;
-  set size(value: Dynamo_Vector2) {
+  private _size: DynamoFM_Vector2;
+  set size(value: DynamoFM_Vector2) {
     this._size = value;
     
     this.calcCenter();
   }
-  get size(): Dynamo_Vector2 { 
+  get size(): DynamoFM_Vector2 { 
     return this._size;
   }
 
-  private _center: Dynamo_Vector2;
-  get center(): Dynamo_Vector2 {
+  private _center: DynamoFM_Vector2;
+  get center(): DynamoFM_Vector2 {
     return this._center;
   }
 
   constructor(
-    position: Dynamo_Vector2 = new Dynamo_Vector2(), 
-    size: Dynamo_Vector2 = new Dynamo_Vector2()
+    position: DynamoFM_Vector2 = new DynamoFM_Vector2(), 
+    size: DynamoFM_Vector2 = new DynamoFM_Vector2()
   ) {
     this._pos = position;
     this._size = size;
@@ -42,7 +42,7 @@ export class Dynamo_BoxBounds {
     return true; 
   }
 
-  newValues?(position: Dynamo_Vector2, size: Dynamo_Vector2): void {
+  newValues?(position: DynamoFM_Vector2, size: DynamoFM_Vector2): void {
     if (position === undefined) {
       throw new Error('new position is undefined!');
     }
@@ -57,20 +57,20 @@ export class Dynamo_BoxBounds {
     this.calcCenter();
   }
 
-  static bounds(box: Dynamo_BoxBounds, position: Dynamo_Vector2): boolean {
+  static bounds(box: DynamoFM_BoxBounds, position: DynamoFM_Vector2): boolean {
     return  box.pos.x <= position.x && position.x <= box.pos.x + box.size.x && 
             box.pos.y <= position.y && position.y <= box.pos.y + box.size.y;
   }
-  bounds?(position: Dynamo_Vector2): boolean {
-    return Dynamo_BoxBounds.bounds(this, position);
+  bounds?(position: DynamoFM_Vector2): boolean {
+    return DynamoFM_BoxBounds.bounds(this, position);
   }
 
   private calcCenter?(): void {
-    this._center = Dynamo_Vector2.plus(this.pos, Dynamo_Vector2.divide(this.size, 2));
+    this._center = DynamoFM_Vector2.plus(this.pos, DynamoFM_Vector2.divide(this.size, 2));
   }
 
-  clone?(): Dynamo_BoxBounds {
-    return new Dynamo_BoxBounds(this.pos.clone(), this.size.clone());
+  clone?(): DynamoFM_BoxBounds {
+    return new DynamoFM_BoxBounds(this.pos.clone(), this.size.clone());
   }
 }
 

package/src/_utils/index.ts

@@ -5,7 +5,6 @@ export * from './box-bounds.util';
 export * from './location.util';
 export * from './log.util';
 export * from './math.util';
-export * from './metadata.util';
 export * from './random.util';
 export * from './regex.util';
 export * from './regions.util';

package/src/_utils/location.util.ts

@@ -1,21 +1,21 @@
 
-import { Dynamo_Error } from '../_models/control-models/error.control-model';
-import { Dynamo_Trigonometry } from './trigonometry.util';
-import { Dynamo_LocationCoordinates } from '../_models/interfaces/location/location-coordinates.interface';
+import { DynamoFM_Error } from '../_models/control-models/error.control-model';
+import { DynamoFM_Trigonometry } from './trigonometry.util';
+import { DynamoFM_LocationCoordinates } from '../_models/interfaces/location/location-coordinates.interface';
 
-export type D_Location = Dynamo_Location;
-export class Dynamo_Location {
+export type DFM_Location = DynamoFM_Location;
+export class DynamoFM_Location {
   
   static getDistanceInKilometres(
-    from: Dynamo_LocationCoordinates,
-    to: Dynamo_LocationCoordinates
+    from: DynamoFM_LocationCoordinates,
+    to: DynamoFM_LocationCoordinates
   ): number {
 
     const R = 6371; // kilometres
-    const φ1 = Dynamo_Trigonometry.angleToRadians(from.latitude);
-    const φ2 = Dynamo_Trigonometry.angleToRadians(to.latitude);
-    const Δφ = Dynamo_Trigonometry.angleToRadians(to.latitude - from.latitude);
-    const Δλ = Dynamo_Trigonometry.angleToRadians(to.longitude - from.longitude);
+    const φ1 = DynamoFM_Trigonometry.angleToRadians(from.latitude);
+    const φ2 = DynamoFM_Trigonometry.angleToRadians(to.latitude);
+    const Δφ = DynamoFM_Trigonometry.angleToRadians(to.latitude - from.latitude);
+    const Δλ = DynamoFM_Trigonometry.angleToRadians(to.longitude - from.longitude);
 
     const a = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) +
               Math.cos(φ1) * Math.cos(φ2) *
@@ -34,9 +34,9 @@ export class Dynamo_Location {
       return distanceInKm / 110.574;
     } else {
       if (latitude) {
-        return distanceInKm / (Math.cos(Dynamo_Trigonometry.angleToRadians(latitude)) * 111.320);
+        return distanceInKm / (Math.cos(DynamoFM_Trigonometry.angleToRadians(latitude)) * 111.320);
       } else {
-        throw new Dynamo_Error({ 
+        throw new DynamoFM_Error({ 
           status: 417, 
           errorCode: 'FSM-DSS-505',
           addECToUserMsg: true,