@futdevpro/fsm-dynamo 1.10.15 → 1.10.17

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

@@ -1,4 +1,3 @@
-
 import { DyFM_Log } from '../../_collections/utils/log.util';
 import { DyFM_DataModel_Type } from '../../_enums/data-model-type.enum';
 import { DyFM_Metadata } from '../data-models/metadata.data-model';
@@ -7,9 +6,11 @@ import { DyFM_DataProperties, DyFM_DataProperty_Params } from './data-property-p
 export type DyFM_Data_S<T> = DyFM_DataModel_Settings<T>;
 export type DyFM_Data_Settings<T> = DyFM_DataModel_Settings<T>;
 export class DyFM_DataModel_Settings<T extends DyFM_Metadata> extends DyFM_Metadata {
+  /** this will be used as db table name, therefore it should be in snake_case,
+   * this also will be used in logs and errors
+   */
   dataName: string;
   modelType?: DyFM_DataModel_Type;
-  dbName?: string;
   addArchive?: boolean;
   properties: DyFM_DataProperties<T>;
 }
@@ -32,7 +33,7 @@ export class DyFM_DataModel_Params<T extends DyFM_Metadata> extends DyFM_DataMod
     if (!this.properties || typeof this.properties !== 'object') {
       DyFM_Log.error(
         'DyFM_DataModel_Params.constructor: ' +
-        'Properties are missing in ' + this.dataName + ' model.'
+        `Properties are missing in "${this.dataName}" model.`
       );
 
       this.properties = {} as DyFM_DataProperties<T>;
@@ -42,7 +43,7 @@ export class DyFM_DataModel_Params<T extends DyFM_Metadata> extends DyFM_DataMod
       if (!key) {
         DyFM_Log.error(
           'DyFM_DataModel_Params.constructor: ' +
-          'A property key is missing in ' + this.dataName + ' model.'
+          `A property key is missing in "${this.dataName}" model.`
         );
       }
       
@@ -57,7 +58,7 @@ export class DyFM_DataModel_Params<T extends DyFM_Metadata> extends DyFM_DataMod
       this.modelType = DyFM_DataModel_Type.data;
     }
 
-    if (!this.dbName && this?.modelType == DyFM_DataModel_Type.data) {
+    /* if (!this.dbName && this?.modelType == DyFM_DataModel_Type.data) {
       // upper case first letter
       this.dbName = this.dataName.charAt(0).toUpperCase() + this.dataName.slice(1);
       
@@ -72,6 +73,23 @@ export class DyFM_DataModel_Params<T extends DyFM_Metadata> extends DyFM_DataMod
                         this.dbName.slice(index + 1);
         }
       });
+    } */
+
+    // check for any Uppercase letters in dbName
+    if (RegExp(/[A-Z]/).exec(this.dataName)) {
+      DyFM_Log.warn(
+        'DyFM_DataModel_Params.constructor: ' +
+        `dbName should be in snake_case in "${this.dataName}" model.` +
+        'For future compatibility.'
+      );
+    }
+
+    if (this.dataName.includes('-')) {
+      DyFM_Log.warn(
+        'DyFM_DataModel_Params.constructor: ' +
+        `dataName should be in snake_case in "${this.dataName}" model.` +
+        'For future compatibility.'
+      );
     }
   }
 
@@ -85,7 +103,7 @@ export class DyFM_DataModel_Params<T extends DyFM_Metadata> extends DyFM_DataMod
         if (!key) {
           DyFM_Log.error(
             'DyFM_DataModel_Params.setKeysForSubObjectParams: ' +
-            'A subObjectParams key is missing in ' + this.dataName + ' model.'
+            `A subObjectParams key is missing in "${this.dataName}" model.`
           );
         }
 

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

@@ -1,4 +1,4 @@
-
+import { DyFM_Log } from '../../_collections/utils/log.util';
 import { DyFM_BasicProperty_Type } from '../../_enums/basic-property-type.enum';
 import { DyFM_DataProperty_Params, DyFM_DataProperty_Settings } from './data-property-params.control-model';
 
@@ -12,7 +12,6 @@ describe('DyFM_DataProperty_Params', () => {
       readonly: false,
       required: true,
       index: false,
-      isDependencyHook: false,
       dependencyDataName: 'dependencyName',
       minlength: 5,
       maxlength: 10,
@@ -29,7 +28,6 @@ describe('DyFM_DataProperty_Params', () => {
     expect(instance.readonly).toBe(false);
     expect(instance.required).toBe(true);
     expect(instance.index).toBe(false);
-    expect(instance.isDependencyHook).toBe(false);
     expect(instance.dependencyDataName).toBe('dependencyName');
     expect(instance.minlength).toBe(5);
     expect(instance.maxlength).toBe(10);
@@ -38,7 +36,7 @@ describe('DyFM_DataProperty_Params', () => {
   });
 
   it('should log error if type is missing', () => {
-    const consoleErrorSpy = spyOn(console, 'error');
+    const consoleErrorSpy = spyOn(DyFM_Log, 'error');
     const settings: DyFM_DataProperty_Settings<string> = {
       key: 'testKey',
       type: undefined as any, // Simulating missing type
@@ -52,26 +50,8 @@ describe('DyFM_DataProperty_Params', () => {
     );
   });
 
-  it('should log error if isDependencyHook is true but dependencyDataName is missing', () => {
-    const consoleErrorSpy = spyOn(console, 'error');
-    const settings: DyFM_DataProperty_Settings<string> = {
-      key: 'testKey',
-      type: DyFM_BasicProperty_Type.string,
-      isDependencyHook: true,
-      dependencyDataName: undefined
-    };
-
-    new DyFM_DataProperty_Params(settings);
-
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      'DYNAMO ERROR: ',
-      '\n dependencyName missing for dependencyHook from ' +
-      'DynamoBEDataPropertyParams'
-    );
-  });
-
   it('should log error if settings are not provided', () => {
-    const consoleErrorSpy = spyOn(console, 'error');
+    const consoleErrorSpy = spyOn(DyFM_Log, 'error');
 
     new DyFM_DataProperty_Params(undefined as any);
 

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

@@ -1,3 +1,4 @@
+import { DyFM_Log } from '../../_collections/utils/log.util';
 import { DyFM_BasicProperty_Type } from '../../_enums/basic-property-type.enum';
 
 export type DyFM_DataProperties<T> = {
@@ -16,14 +17,14 @@ export class DyFM_DataProperty_Settings<T>{
   required?: boolean;
   index?: boolean;
 
-  isDependencyHook?: boolean;
+  /* isDependencyHook?: boolean; */
   /**
    * This will be used to prehook dependency db service to data service by 
    * dataName from dependency data's DyNTS_DataPropertyParams
    * Use the dependency data's DyNTS_DataPropertyParams.
    * 
    * @example
-   * dependencyName: accountModelParams.dataName
+   * accountId: { dependencyName: accountModelParams.dataName }
    */
   dependencyDataName?: string;
   archiveable?: boolean;
@@ -58,25 +59,33 @@ export class DyFM_DataProperty_Params<T> extends DyFM_DataProperty_Settings<T> {
     
     if (set) {
       if (!set.type) {
-        console.error(
-          `DYNAMO ERROR: `,
-          `\n type is missing from DynamoBEDataPropertyParams`, 
+        DyFM_Log.error(
+          'DYNAMO ERROR: ',
+          '\n type is missing from DynamoBEDataPropertyParams'
         );
       }
 
-      if (set.isDependencyHook && !set.dependencyDataName) {
-        console.error(
-          `DYNAMO ERROR: `,
-          `\n dependencyName missing for dependencyHook from ` +
-            `DynamoBEDataPropertyParams`// (${set.key})`, 
-        );
+      if (set.dependencyDataName) {
+        if (set.required === false) {
+          DyFM_Log.warn(
+            'DYNAMO WARNING: ',
+            '\n required is not recommended to be false if dependency is set'
+          );
+        } else if (set.required === undefined) {
+          DyFM_Log.warn(
+            'DYNAMO WARNING: ',
+            '\n required is recommended to be set if dependency is set. ' +
+            `It will be set to true by while you are not setting it.`
+          );
+          set.required = true;
+        }
       }
       
       Object.assign(this, set);
     } else {
-      console.error(
+      DyFM_Log.error(
         'DYNAMO ERROR: ',
-        '\nMISSING DynamoBEDataPropertyParams constructor input', 
+        '\nMISSING DynamoBEDataPropertyParams constructor input'
       );
     }
   }

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

@@ -437,7 +437,12 @@ export class DyFM_Error extends DyFM_Metadata {
     return error;
   }
 
-  logSimple(title: string, logAdditionalContent?: boolean): void {
+  logSimple(title: string, logAdditionalContent?: boolean, forceLog?: boolean): void {
+    if (this.___logged && !forceLog) {
+      DyFM_Log.warn(`logSimple: already logged (${this._errorCode})`);
+      return;
+    }
+
     if (logAdditionalContent && this.additionalContent) {
       DyFM_Log.H_error(
         title,

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

@@ -1,5 +1,7 @@
 import { Subscription, timer } from 'rxjs';
 import { DyFM_Error } from './error.control-model';
+import { second } from '../../_collections/constants/times.const';
+import { DyFM_wait } from '../../_collections/utils/utilities.util';
 
 
 /**
@@ -8,50 +10,57 @@ import { DyFM_Error } from './error.control-model';
  * waiting a specific result
  */
 export class DyFM_Poll<T> {
+  name: string;
+
   poll: Subscription;
   running: boolean;
 
-  private readonly pollDo: (...args) => Promise<T>;
-  private readonly pollWhile: (res: T) => boolean;
-  private readonly pollEnd: (res: T) => void;
-  private readonly args?: any[];
-  private readonly pollDelay?: number;
-  private readonly pollPeriod?: number;
-  private readonly stopOnFail?: boolean;
+  /**
+   * The function that will be called to poll the endpoint,
+   * it will be called every pollPeriod
+   */
+  readonly pollDo: (...args) => Promise<T>;
+  /**
+   * The function that will be called to check if the poll should continue,
+   * if this returns false, the poll will end
+   */
+  readonly pollWhile: (res: T) => boolean;
+  /**
+   * The function that will be called to end the poll
+   */
+  readonly pollEnd?: (res: T) => void;
+  /**
+   * The function that will be called to handle the error
+   */
+  readonly pollDoError?: (error: any) => void;
+  readonly args?: any[];
+  readonly pollDelay: number = 0;
+  readonly pollPeriod: number = 3 * second;
+  readonly stopOnFail: boolean = false;
+  readonly delayFirst: boolean = false;
 
   constructor(
-    set: {
-      pollDo: (...args) => Promise<T>,
-      pollWhile: (res: T) => boolean,
-      pollEnd: (res: T) => void,
-      
-      args?: any[],
-      pollDelay?: number,
-      pollPeriod?: number,
-      stopOnFail?: boolean,
-    }
+    set: Partial<DyFM_Poll<T>> 
   ) {
     try {
-      this.pollDo = set.pollDo;
-      this.pollWhile = set.pollWhile;
-      this.pollEnd = set.pollEnd;
-
-      this.args = set.args;
-      this.pollDelay = set.pollDelay ? set.pollDelay : 0;
+      Object.assign(this, set);
 
       if (set.pollPeriod === 0) {
         console.error(
           'DYNAMO ERROR: creating polls with 0ms period is not supported! ' +
           '(it will reset to 1000ms (1s))',
         );
+        this.pollPeriod = 1 * second;
       }
-      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!'
         );
       }
+
+      this.name = set.name ?? 'Unnamed DyFM_Poll';
+
       this.stopOnFail = set.stopOnFail;
       this.startPoll(this.args);
     } catch (error) {
@@ -61,8 +70,11 @@ export class DyFM_Poll<T> {
     }
   }
 
-  private startPoll(...args: any[]): void {
+  private async startPoll(...args: any[]): Promise<void> {
     try {
+      if (this.delayFirst) {
+        await DyFM_wait(this.pollDelay);
+      }
       this.poll = timer(this.pollDelay, this.pollPeriod).subscribe(async (): Promise<void> => {
         await this.pollDo(...args).then((res: T): void => {
           if (!this.pollWhile(res)) {
@@ -73,9 +85,15 @@ export class DyFM_Poll<T> {
             this.stop();
           }
 
-          throw new DyFM_Error({
-            message: 'DYNAMO ERROR: \nDynamoPoll: pollDo was UNSUCCESSFUL',
-          });
+          if (this.pollDoError) {
+            this.pollDoError(error);
+          } else {
+            throw new DyFM_Error({
+              message: `DYNAMO ERROR: ` +
+                `\nDynamoPoll: "${this.name}" pollDo was UNSUCCESSFUL`,
+              error: error,
+            });
+          }
         });
       });
       this.running = true;
@@ -109,7 +127,7 @@ export class DyFM_Poll<T> {
 
   end(result: T): void {
     this.poll.unsubscribe();
-    this.pollEnd(result);
+    this.pollEnd?.(result);
     this.running = false;
   }
 }

package/src/_modules/socket/_models/sck-client-params.control-model.spec.ts

@@ -30,7 +30,7 @@ describe('DyFM_SocketClient_Params', () => {
 
     const instance = new DyFM_SocketClient_Params(params);
 
-    expect(instance.reconnectDelay).toBe(second * 10);
+    expect(instance.reconnectDelay).toBe(second * 30);
     expect(instance.reconnect).toBe(true);
   });
 

package/src/_modules/socket/_models/sck-client-params.control-model.ts

@@ -1,13 +1,15 @@
 
 import * as SocketIOClient from 'socket.io-client';
+
 import { second } from '../../../_collections/constants/times.const';
+import { DyFM_Log } from '../../../_collections/utils/log.util';
 
 export class DyFM_SocketClient_Params {
   name?: string;
   service?: string;
   address?: string;
   port?: number;
-  reconnectDelay?: number = second * 10;
+  reconnectDelay?: number = second * 30;
   reconnect?: boolean = true;
   socketOptions?: Partial<SocketIOClient.ManagerOptions & SocketIOClient.SocketOptions>;
 
@@ -18,7 +20,16 @@ export class DyFM_SocketClient_Params {
 
     this.reconnect = !!this.reconnectDelay;
 
-    if (this.socketOptions?.autoConnect || this.socketOptions?.reconnection) {
+    if (
+      this.socketOptions?.autoConnect || 
+      this.socketOptions?.reconnection ||
+      this.socketOptions?.reconnectionDelay
+    ) {
+      DyFM_Log.warn(
+        'autoConnect or reconnection is set to true in socketOptions, so reconnect is set to false',
+        '\nThis means that the reconnection will use the socket.io reconnection logic, ',
+        'not the Dynamo implementations.'
+      );
       this.reconnect = false;
     }
   }

package/src/_modules/socket/_models/sck-socket-event.control-model.ts

@@ -2,6 +2,7 @@
 import { DyFM_global_settings } from '../../../_collections/constants/global-settings.const';
 import { DyFM_Array } from '../../../_collections/utils/array.util';
 import { DyFM_Log } from '../../../_collections/utils/log.util';
+import { DyFM_getStackLocation } from '../../../_collections/utils/stack.util';
 
 import { DyFM_SocketEvent_Key } from '../_enums/sck-event-key.enum';
 
@@ -23,6 +24,8 @@ export class DyFM_SocketEvent<T>{
   logEvent?: boolean;
   logEventContent?: boolean;
 
+  readonly stackLocation?: string;
+
   constructor(
     set: {
       /**
@@ -68,6 +71,8 @@ export class DyFM_SocketEvent<T>{
       this.preProcesses = set.preProcesses ?? [];
       this.tasks = set.tasks ?? [];
 
+      this.stackLocation = DyFM_getStackLocation();
+
       if (set.logEvent !== undefined) {
         this.logEvent = set.logEvent;
       } else if (this.eventKey === DyFM_SocketEvent_Key.subscribe) {

package/src/_modules/socket/_services/sck-client.service-base.ts

@@ -1,5 +1,6 @@
 
 import * as SocketIOClient from 'socket.io-client';
+import { BehaviorSubject } from 'rxjs';
 
 import {
   DyFM_global_settings
@@ -9,7 +10,6 @@ import { DyFM_Log } from '../../../_collections/utils/log.util';
 import { DyFM_delay } from '../../../_collections/utils/utilities.util';
 import { DyFM_Error } from '../../../_models/control-models/error.control-model';
 
-import { BehaviorSubject } from 'rxjs';
 import { DyFM_SocketEvent_Key } from '../_enums/sck-event-key.enum';
 import { DyFM_SocketClient_Params } from '../_models/sck-client-params.control-model';
 import { DyFM_SocketEvent } from '../_models/sck-socket-event.control-model';
@@ -17,19 +17,27 @@ import { DyFM_SocketEvent } from '../_models/sck-socket-event.control-model';
 export abstract class DyFM_SocketClient_ServiceBase<T_SubscriptionContent = any> {
 
   private _params: DyFM_SocketClient_Params;
-  protected get params(): DyFM_SocketClient_Params { return this._params; }
-  get name(): string { return this.params.name; }
+  protected get params(): DyFM_SocketClient_Params { 
+    return this._params; 
+  }
+  get name(): string { 
+    return this.params.name; 
+  }
 
   protected socket: SocketIOClient.Socket;
   
   protected incomingEvents: DyFM_SocketEvent<any>[];
   
   protected _connected_BS: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
-  get connected(): boolean { return this._connected_BS.value; }
+  get connected(): boolean { 
+    return this._connected_BS.value; 
+  }
   readonly connected$ = this._connected_BS.asObservable();
 
   private readonly _subscribed_BS: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
-  get subscribed(): boolean { return this._subscribed_BS.value; }
+  get subscribed(): boolean { 
+    return this._subscribed_BS.value; 
+  }
   readonly subscribed$ = this._subscribed_BS.asObservable();
 
   protected debugLog: boolean = DyFM_global_settings.log_settings.setup;
@@ -285,12 +293,27 @@ export abstract class DyFM_SocketClient_ServiceBase<T_SubscriptionContent = any>
     }
   }
 
+  private tryingToReconnect: boolean = false;
   private async tryReconnectIfNeeded(): Promise<void> {
     try {
+      console.log('tryReconnectIfNeeded', this._params.reconnectDelay);
+      if (this.tryingToReconnect) {
+        DyFM_Log.warn(`socket-client(${this.params.name}) already trying to reconnect!`);
+        return;
+      }
+
+      if (!this.params.reconnect) {
+        DyFM_Log.warn(`socket-client(${this.params.name}) Dynamo reconnection is disabled!`);
+        return;
+      }
+
+      this.tryingToReconnect = true;
+
       if (this.logFn) console.log(`\nFn:. tryReconnectIfNeeded`);
       await DyFM_delay(this._params.reconnectDelay);
       
       if (!this.connected) {
+        this.tryingToReconnect = false;
         await this.connectSocket();
       }
     } catch (error) {
@@ -298,6 +321,7 @@ export abstract class DyFM_SocketClient_ServiceBase<T_SubscriptionContent = any>
         `socket-client(${this.params.name}) Service Try Reconnect failed, ` +
         `ERROR:`, error
       );
+      this.tryingToReconnect = false;
 
       throw error;
     }

package/src/_modules/test/_collections/tst-module-settings.const.ts

@@ -1,4 +1,3 @@
-
 import {
   DyFM_EndpointTypesContainer,
   DyFM_ServiceEndpointTypesSettings
@@ -6,19 +5,20 @@ import {
 import { DyFM_Route_Settings } from '../../../_models/interfaces/route-settings.interface';
 
 export enum DyFM_TestRoute {
-  testGet = 'testGet',
-  testPost = 'testPost',
-  testDelete = 'testDelete',
-  getServerStatus = 'getServerStatus',
+  testGet = 'test-get',
+  testPost = 'test-post',
+  testPut = 'test-put',
+  testPatch = 'test-patch',
+  testDelete = 'test-delete',
+  getServerStatus = 'get-server-status',
 }
 
 export const DyFM_testModule_settings: DyFM_Route_Settings<DyFM_TestRoute> = {
   mainRoute: '/test',
   endPoints: {
-    [DyFM_TestRoute.testGet]: '/test-get',
-    [DyFM_TestRoute.testPost]: '/test-post',
-    [DyFM_TestRoute.testDelete]: '/test-delete',
-    [DyFM_TestRoute.getServerStatus]: '/server-status',
+    ...Object.fromEntries(
+      Object.values(DyFM_TestRoute).map((route) => [route, `/${route}`])
+    ),
   },
 };
 
@@ -27,6 +27,10 @@ export const DyFM_fullTestRoute = {
     DyFM_testModule_settings.endPoints[DyFM_TestRoute.testGet],
   [DyFM_TestRoute.testPost]: DyFM_testModule_settings.mainRoute +
     DyFM_testModule_settings.endPoints[DyFM_TestRoute.testPost],
+  [DyFM_TestRoute.testPut]: DyFM_testModule_settings.mainRoute +
+    DyFM_testModule_settings.endPoints[DyFM_TestRoute.testPut],
+  [DyFM_TestRoute.testPatch]: DyFM_testModule_settings.mainRoute +
+    DyFM_testModule_settings.endPoints[DyFM_TestRoute.testPatch],
   [DyFM_TestRoute.testDelete]: DyFM_testModule_settings.mainRoute +
     DyFM_testModule_settings.endPoints[DyFM_TestRoute.testDelete],
   [DyFM_TestRoute.getServerStatus]: DyFM_testModule_settings.mainRoute +
@@ -36,6 +40,8 @@ export const DyFM_fullTestRoute = {
 export interface DyFM_Test_EndpointTypeSettings extends DyFM_ServiceEndpointTypesSettings {
   [DyFM_TestRoute.testGet]: DyFM_EndpointTypesContainer<DyFM_Test_Result>;
   [DyFM_TestRoute.testPost]: DyFM_EndpointTypesContainer<DyFM_Test_Result, any, any>;
+  [DyFM_TestRoute.testPut]: DyFM_EndpointTypesContainer<DyFM_Test_Result, any, any>;
+  [DyFM_TestRoute.testPatch]: DyFM_EndpointTypesContainer<DyFM_Test_Result, any, any>;
   [DyFM_TestRoute.testDelete]: DyFM_EndpointTypesContainer<DyFM_Test_Result>;
   [DyFM_TestRoute.getServerStatus]: DyFM_EndpointTypesContainer<{
     status: 'ready',

package/src/index.ts

@@ -11,6 +11,8 @@ export * from './_collections/utils/array.util';
 export * from './_collections/utils/log.util';
 export * from './_collections/utils/round-list.util';
 export * from './_collections/utils/shared.util';
+export * from './_collections/utils/stack.util';
+export * from './_collections/utils/string.util';
 export * from './_collections/utils/time.util';
 export * from './_collections/utils/type-cloning-facility.util';
 export * from './_collections/utils/utilities.util';