@futdevpro/fsm-dynamo 1.10.14 → 1.10.16

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/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/_models/types/db-/304/221filter.type.ts

@@ -8,12 +8,12 @@ import { DyFM_RangeValue } from '../control-models/range-value.control-model';
  * 
  * it should be the value, a range or an array of the searching values
  */
-export type DyFM_DBĐFilter<T_RootProperty> = {
-  [K in keyof T_RootProperty]?: T_RootProperty[K] | 
-                                T_RootProperty[K][] | 
-                                DyFM_RangeValue<T_RootProperty[K]> | 
-                                DyFM_SpecialSearch<T_RootProperty[K]> |
-                                DyFM_SpecialNestSearch<any>;
+export type DyFM_DBĐFilter<T> = {
+  [K in keyof T]?:  T[K] | 
+                    T[K][] | 
+                    DyFM_RangeValue<T[K]> | 
+                    DyFM_SpecialSearch<T[K]> |
+                    DyFM_SpecialNestSearch;
 };
 
 export interface DyFM_SpecialSearch<T> {
@@ -25,21 +25,22 @@ export interface DyFM_SpecialSearch<T> {
 /**
  * searches for a nested properties in the object
  */
-export interface DyFM_SpecialNestSearch<T_NestedProperty> {
+export interface DyFM_SpecialNestSearch {
   isSpecialNestSearch: true;
   nestedPropertySearches: DyFM_NestPropertySearch<any>[];
 }
+
 /**
  * can search for nested properties in arrays as well with the following syntax used in key:
  * nestKeys: [ 'arrayProperty', '*', 'nestedPropertySearch' ]
  */
-export interface DyFM_NestPropertySearch<T_NestedProperty> {
+export interface DyFM_NestPropertySearch<T> {
   nestKeys: string[];
-  propertyType: DyFM_BasicProperty_Type;
-  search: T_NestedProperty | 
-          T_NestedProperty[] | 
-          DyFM_RangeValue<T_NestedProperty> |
-          DyFM_SpecialSearch<T_NestedProperty>;
+  valueType: DyFM_BasicProperty_Type;
+  search: T | 
+          T[] | 
+          DyFM_RangeValue<T> |
+          DyFM_SpecialSearch<T>;
 }
 
 export enum DyFM_SpecialSearch_Type {
@@ -55,12 +56,6 @@ export enum DyFM_SpecialSearch_Type {
    * searches each word in the string, returns true if ALL words are found in the SAME order
    * */
   stringListSearchOrdered = 'stringListSearchOrdered',
-  /**
-   * searches for a nested property in the object
-   * can search for nested properties in arrays as well with the following syntax used in key:
-   * nestKeys: [ 'arrayProperty', '*', 'nestedPropertySearch' ]
-   */
-  /* nestedPropertySearch = 'nestedPropertySearch', */
 }
 
 

package/src/_models/types/db-/304/221sort.type.ts

@@ -1,3 +1,4 @@
+import { DyFM_BasicProperty_Type } from '../../_enums/basic-property-type.enum';
 
 
 
@@ -14,6 +15,7 @@ export interface DyFM_DBĐNestedPropertySort {
    * (can be an array that is used for sorting by nested properties)
    */
   nestKeys: string[];
+  valueType: DyFM_BasicProperty_Type;
   order: 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending';
 }
 

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';