@futdevpro/fsm-dynamo 1.9.28 → 1.9.30

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

@@ -0,0 +1,151 @@
+
+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_SocketEvent_Key } from '../_enums/sck-event-key.enum';
+
+export type DyFM_SocketEventPreprocessTask<T = any, R = any> = 
+  (content?: T, issuer?: string) => Promise<R>;
+export type DyFM_SocketEventTask<T> = (content?: T, issuer?: string) => Promise<void>;
+
+/**
+ * socket handling and clarification is under development
+ */
+export class DyFM_SocketEvent<T>{
+  socketName?: string;
+  eventKey: DyFM_SocketEvent_Key | string;
+  serviceName?: string;
+  
+  preProcesses?: DyFM_SocketEventPreprocessTask<any, any>[];
+  tasks?: DyFM_SocketEventTask<T>[];
+
+  logEvent?: boolean;
+  logEventContent?: boolean;
+
+  constructor(
+    set: {
+      /**
+       * naming the socket will help to follow eveFM on service,
+       * if not set, the eventKey will be used
+       */
+      name?: string,
+      /**
+       * define socket event type such as; 
+       * connection, connect, disconnect, message, error, or anything else
+       */
+      eventKey: DyFM_SocketEvent_Key | string,
+      /**
+       * serviceName is the name of the service that will be used for logging
+       */
+      serviceName?: string,
+      /**
+       * preProcesses are the functions the service needs to run before the actual function,
+       * these can be used for authentications, or translating data
+       * 
+       * the last function in the array should return the content in the type(T) of the socket<T>
+       */
+      preProcesses?: DyFM_SocketEventPreprocessTask<any, any>[],
+      /**
+       * tasks are the functions the service needs to run
+       */
+      tasks?: DyFM_SocketEventTask<T>[],
+      /**
+       * logEvent will create a log for the event triggered
+       */
+      logEvent?: boolean,
+      /**
+       * logEventContent will create a log for the event triggered with the content
+       */
+      logEventContent?: boolean,
+    }
+  ) {
+    try {
+      this.socketName = set.name ?? set.eventKey;
+      this.eventKey = set.eventKey;
+      this.serviceName = set.serviceName ?? 'UnknownSocketService';
+
+      this.preProcesses = set.preProcesses ?? [];
+      this.tasks = set.tasks ?? [];
+
+      if (set.logEvent !== undefined) {
+        this.logEvent = set.logEvent;
+      } else if (this.eventKey === DyFM_SocketEvent_Key.subscribe) {
+        this.logEvent = false;
+      } else if (
+        ([ 
+          DyFM_SocketEvent_Key.connection, 
+          DyFM_SocketEvent_Key.connect,
+          DyFM_SocketEvent_Key.disconnect,
+        ] as string[]).includes(this.eventKey)
+      ) {
+        this.logEvent = DyFM_global_settings.log_settings.socket_allEvents || 
+          DyFM_global_settings.log_settings.socket_mainEvents;
+      } else {
+        this.logEvent = DyFM_global_settings.log_settings.socket_allEvents;
+      }
+      this.logEventContent = set.logEventContent ??
+        DyFM_global_settings.log_settings.socket_eventContent;
+    } catch (error) {
+      DyFM_Log.error(
+        `\nSocket Event params setup failed (${this.serviceName}): ${set.eventKey}`, 
+        error
+      );
+
+      throw error;
+    }
+  }
+
+  /**
+   * 
+   * @returns 
+   */
+  private async getPreLog(content: T): Promise<void> {
+    try {
+      if (this.logEventContent && this.eventKey !== DyFM_SocketEvent_Key.connection) {
+        DyFM_Log.log(
+          `--->   incoming socket(${this.serviceName}) event: ${this.eventKey};
+          \ncontent:`, content
+        );
+      } else {
+        DyFM_Log.log(`--->   incoming socket(${this.serviceName}) event: ${this.eventKey}...`);
+      }
+    } catch (error) {
+      DyFM_Log.error(`PreLog failed... (socket:  ${this.serviceName})`, error);
+    }
+  }
+
+  /**
+   * 
+   * @returns 
+   */
+  async executeEventTasks(content?: T, issuer?: string): Promise<void> {
+    try {        
+      if (this.logEvent || this.logEventContent) {
+        await this.getPreLog(content);
+      }
+
+      await DyFM_Array.asyncForEach(
+        this.preProcesses, 
+        async (preProcess: DyFM_SocketEventPreprocessTask<any, any>) => {
+          content = await preProcess(content);
+        }
+      );
+
+      await DyFM_Array.asyncForEach(this.tasks, async (task: DyFM_SocketEventTask<T>) => {
+        await task(content, issuer);
+      });
+    } catch (error) {
+      DyFM_Log.error(
+        `Socket Event tasks failed to execute on ${this.serviceName}.... (${this.eventKey})`, 
+        error, 
+        'content:', 
+        content
+      );
+    }
+  }
+}
+
+
+
+

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

@@ -0,0 +1,251 @@
+
+import * as SocketIOClient from 'socket.io-client';
+
+import { 
+  DyFM_global_settings 
+} from '../../../_collections/constants/global-settings.const';
+import { DyFM_Error } from '../../../_models/control-models/error.control-model';
+import { DyFM_Log } from '../../../_collections/utils/log.util';
+import { DyFM_Array } from '../../../_collections/utils/array.util';
+import { DyFM_delay } from '../../../_collections/utils/utilities.util';
+
+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';
+
+export abstract class DyFM_SocketClient_ServiceBase {
+
+  private _params: DyFM_SocketClient_Params;
+  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: boolean = false;
+  get connected(): boolean { return this._connected; }
+
+  protected debugLog: boolean = DyFM_global_settings.log_settings.setup;
+  protected logFn: boolean = DyFM_global_settings.log_settings.functions;
+
+  private defaultEvents: DyFM_SocketEvent<any>[] = [
+    new DyFM_SocketEvent<any>({
+      eventKey: DyFM_SocketEvent_Key.connect,
+      tasks: [
+        async () => {
+          this._connected = true;
+          DyFM_Log.success(`<   >  socket-client(${this.params.name}) connected!`);
+        },
+      ],
+    }),
+
+    new DyFM_SocketEvent<any>({
+      eventKey: DyFM_SocketEvent_Key.disconnect,
+      tasks: [
+        async () => {
+          this._connected = false;
+          DyFM_Log.warn(`<x  >  socket-client(${this.params.name}) disconnected!`);
+
+          if (this._params.reconnect) {
+            await DyFM_delay(this._params.reconnectDelay);
+            this.connectSocket();
+          }
+        },
+      ],
+    }),
+
+    new DyFM_SocketEvent<any>({
+      eventKey: DyFM_SocketEvent_Key.subscriptionSuccessful,
+      tasks: [
+        async () => {
+          DyFM_Log.success(`<=-->  socket-client(${this.params.name}) subscription successful!`);
+        },
+      ],
+    }),
+
+    new DyFM_SocketEvent<any>({
+      eventKey: DyFM_SocketEvent_Key.error,
+      tasks: [
+        async (content: any) => {
+          DyFM_Log.error(`=-->   socket-client(${this.params.name}) ERROR!:`, content);
+        },
+      ],
+    }),
+  ];
+
+  protected constructor() {
+    this.asyncConstructor().catch((error: any) => {
+      if (
+        DyFM_global_settings.log_settings.highDetailedLogs ||
+        !(error instanceof DyFM_Error)
+      ) {
+        DyFM_Log.H_error(
+          `socket-client "${this.params?.name}" Service setup failed! ` +
+          `(DyFM_SocketClientService constructor catch)`,
+          `\n    ERROR:`, error
+        );
+      } else {
+        error.logSimple(
+          `socket-client "${this.params?.name}" Service setup failed! ` +
+          `(DyFM_SocketClientService constructor catch)`
+        );
+      }
+    });
+  }
+
+  private async asyncConstructor(): Promise<void> {
+    try {
+      this._params = this.getParams();
+      this.incomingEvents = this.getIncomingEvents() ?? [];
+      this.socket = SocketIOClient.io(
+        `${this.params.address}:${this.params.port}`,
+        {
+          reconnection: this.params.reconnect,
+          reconnectionDelay: this.params.reconnectDelay,
+          ...this.params.socketOptions,
+        }
+      );
+      
+      await this.setupDefaultEvents();
+
+      await this.setupSocketEvents();
+
+      DyFM_Log.success(`\nsocket-client(${this.params?.name}) Service setup finished`);
+      
+      await this.connectSocket();
+    } catch (error) {
+      DyFM_Log.error(`socket-client(${this.params?.name}) Service setup failed!`, error);
+
+      throw new DyFM_Error({
+        errorCode: 'FM-SCS-001',
+        error: error,        
+      });
+    }
+  }
+
+  private async setupDefaultEvents(): Promise<void> {
+    try {
+      if (this.logFn) console.log('\nFn:. setupDefaultEvents');
+
+      this.defaultEvents.forEach((defaultEvent: DyFM_SocketEvent<any>) => {
+        defaultEvent.serviceName = this.params.name;
+        const eventDeclared = this.incomingEvents.find(
+          (event: DyFM_SocketEvent<any>) => event.eventKey === defaultEvent.eventKey
+        );
+
+        if (!eventDeclared) {
+          this.incomingEvents.push(defaultEvent);
+        } else {
+          eventDeclared.tasks.unshift(...defaultEvent.tasks);
+        }
+      });
+    } catch (error) {
+      DyFM_Log.error(
+        `socket-client(${this.params.name}) Service Setup Default Events failed, ` +
+        `ERROR:`, error
+      );
+
+      throw error;
+    }
+  }
+
+  private async setupSocketEvents(): Promise<void> {
+    try {
+      if (this.debugLog) console.log(`Setup socket-client(${this.params.name}) Events...`);
+
+      await DyFM_Array.asyncForEach(
+        this.incomingEvents, 
+        async (event: DyFM_SocketEvent<any>) => {
+          event.serviceName = this.params.name;
+          this.socket.on(event.eventKey, async (content: any) => { 
+            try {
+              await event.executeEventTasks(content, this.params.service);
+            } catch (error) {
+              DyFM_Log.error(`socket-client(${this.params.name}) Event failed, ERROR:`, error);
+              await this.emitEvent(DyFM_SocketEvent_Key.error, error);
+            }
+          });
+        }
+      );
+    } catch (error) {
+      DyFM_Log.error(
+        `socket-client(${this.params.name}) Service Setup Socket Events failed, ` +
+        `ERROR:`, error
+      );
+
+      throw error;
+    }
+  }
+  
+  private async connectSocket(): Promise<void> {
+    try {
+      DyFM_Log.info(
+        `< .. > socket-client(${this.params.name}) ` +
+        `connecting to ${this.params.address}:${this.params.port} ...`
+      );
+
+      this.socket.connect();
+
+      if (this.params.reconnect) {
+        await this.tryReconnectIfNeeded();
+      }
+    } catch (error) {
+      DyFM_Log.error(
+        `socket-client(${this.params.name}) Service Connect Socket failed, ` +
+        `ERROR:`, error
+      );
+
+      throw error;
+    }
+  }
+
+  private async tryReconnectIfNeeded(): Promise<void> {
+    try {
+      if (this.logFn) console.log(`\nFn:. tryReconnectIfNeeded`);
+      await DyFM_delay(this._params.reconnectDelay);
+      
+      if (!this._connected) {
+        await this.connectSocket();
+      }
+    } catch (error) {
+      DyFM_Log.error(
+        `socket-client(${this.params.name}) Service Try Reconnect failed, ` +
+        `ERROR:`, error
+      );
+
+      throw error;
+    }
+  }
+
+  /**
+   * Emit event to the socket
+   * @param eventType event name
+   * @param content event content
+   */
+  protected async emitEvent(eventType: string, content: any): Promise<void> {
+    try {
+      DyFM_Log.log(`<=--   outgoing socket-client(${this.params.name}) event: ${eventType}`);
+      this.socket.emit(eventType, content);
+    } catch (error) {
+      DyFM_Log.error(
+        `socket-client(${this.params.name}) ` +
+        `Service Emit Event failed: ${this.params?.name} (${this.params?.port})`, error
+      );
+
+      throw error;
+    }
+  }
+  
+  /**
+   * You must setup params for the service in this function
+   */
+  abstract getParams(): DyFM_SocketClient_Params;
+
+  /**
+   * You must setup events and required services in this function
+   */
+  abstract getIncomingEvents(): DyFM_SocketEvent<any>[];
+}
+
+

package/src/_modules/socket/index.ts

@@ -1,6 +1,14 @@
 
 
+
+// ENUMS
+export * from './_enums/sck-event-key.enum';
+
+
 // MODELS
 export * from './_models/sck-client-params.control-model';
+export * from './_models/sck-socket-event.control-model';
 
 
+// SERVICES
+export * from './_services/sck-client.service-base';

package/src/index.ts

@@ -2,6 +2,7 @@
 // COLLECTIONS
 // collections/CONSTANTS
 export * from './_collections/constants/error-defaults.const';
+export * from './_collections/constants/global-settings.const';
 export * from './_collections/constants/times.const';
 
 // collections/UTILS
@@ -57,3 +58,7 @@ export * from './_models/interfaces/random-weight.interface';
 export * from './_models/interfaces/route-settings.interface';
 export * from './_models/interfaces/vector2.interface';
 
+// models/interfaces/ENVIRONMENT
+export * from './_models/interfaces/environment/global-settings.interface';
+export * from './_models/interfaces/environment/global-log-settings.interface';
+