@futdevpro/fsm-dynamo 1.16.37 → 1.16.39

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

@@ -1,172 +1,185 @@
-
-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_getConstructionStackLocation } from '../../../_collections/utils/stack.util';
-import { DyFM_Error } from '../../../_models/control-models/error.control-model';
-
-import { DyFM_SocketEvent_Key } from '../_enums/sck-event-key.enum';
-
+
+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_getConstructionStackLocation } from '../../../_collections/utils/stack.util';
+import { DyFM_Error } from '../../../_models/control-models/error.control-model';
+
+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>;
-
-/**
- * Describes a socket.io event with pre-processing and task handling.
- *
- * Use this model to define how incoming socket events should be processed
- * and what actions should be executed once the data is prepared.
- *
- * @example
- * ```ts
- * const event = new DyFM_SocketEvent<string>({
- *   eventKey: DyFM_SocketEvent_Key.subscribe,
- *   tasks: [async msg => console.log(msg)]
- * });
- * ```
- */
-export class DyFM_SocketEvent<T>{
-  name?: string;
-  eventKey: DyFM_SocketEvent_Key | string;
-  serviceName?: string;
-  
-  preProcesses?: DyFM_SocketEventPreprocessTask<any, any>[];
-  tasks?: DyFM_SocketEventTask<T>[];
-
-  logEvent?: boolean;
-  logEventContent?: boolean;
-
-  readonly stackLocation?: string;
-
-  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.name = set.name ?? set.eventKey;
-      this.eventKey = set.eventKey;
-      this.serviceName = set.serviceName ?? 'UnknownSocketService';
-
-      this.preProcesses = set.preProcesses ?? [];
-      this.tasks = set.tasks ?? [];
-
-      this.stackLocation = DyFM_getConstructionStackLocation();
-
-      if (set.logEvent !== undefined) {
-        this.logEvent = set.logEvent;
-      } else if (this.eventKey === DyFM_SocketEvent_Key.subscribe) {
-        this.logEvent = false;
-      } else if (
-        ([ 
-          DyFM_SocketEvent_Key.incomingNewConnection, 
-          DyFM_SocketEvent_Key.outgoingNewConnection,
-          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.incomingNewConnection) {
-        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);
-      }
-
+/** Executes an event task with optional server-owned transport context. */
+export type DyFM_SocketEventTask<T> = (
+  content?: T,
+  issuer?: string,
+  transportContext?: unknown,
+) => Promise<void>;
+
+/**
+ * Describes a socket.io event with pre-processing and task handling.
+ *
+ * Use this model to define how incoming socket events should be processed
+ * and what actions should be executed once the data is prepared.
+ *
+ * @example
+ * ```ts
+ * const event = new DyFM_SocketEvent<string>({
+ *   eventKey: DyFM_SocketEvent_Key.subscribe,
+ *   tasks: [async msg => console.log(msg)]
+ * });
+ * ```
+ */
+export class DyFM_SocketEvent<T>{
+  name?: string;
+  eventKey: DyFM_SocketEvent_Key | string;
+  serviceName?: string;
+  
+  preProcesses?: DyFM_SocketEventPreprocessTask<any, any>[];
+  tasks?: DyFM_SocketEventTask<T>[];
+
+  logEvent?: boolean;
+  logEventContent?: boolean;
+
+  readonly stackLocation?: string;
+
+  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.name = set.name ?? set.eventKey;
+      this.eventKey = set.eventKey;
+      this.serviceName = set.serviceName ?? 'UnknownSocketService';
+
+      this.preProcesses = set.preProcesses ?? [];
+      this.tasks = set.tasks ?? [];
+
+      this.stackLocation = DyFM_getConstructionStackLocation();
+
+      if (set.logEvent !== undefined) {
+        this.logEvent = set.logEvent;
+      } else if (this.eventKey === DyFM_SocketEvent_Key.subscribe) {
+        this.logEvent = false;
+      } else if (
+        ([ 
+          DyFM_SocketEvent_Key.incomingNewConnection, 
+          DyFM_SocketEvent_Key.outgoingNewConnection,
+          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.incomingNewConnection) {
+        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);
+    }
+  }
+
+  /** Executes the ordered preprocessors and tasks for one received event. */
+  async executeEventTasks(
+    content?: T,
+    issuer?: string,
+    transportContext?: unknown,
+  ): 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.preProcesses, 
-        async (preProcess: DyFM_SocketEventPreprocessTask<any, any>) => {
-          content = await preProcess(content);
-        }
+        this.tasks,
+        async (task: DyFM_SocketEventTask<T>): Promise<void> => {
+          if (transportContext === undefined) {
+            await task(content, issuer);
+          } else {
+            await task(content, issuer, transportContext);
+          }
+        },
       );
-
-      await DyFM_Array.asyncForEach(this.tasks, async (task: DyFM_SocketEventTask<T>) => {
-        await task(content, issuer);
-      });
-    } catch (error) {
-      if (error instanceof DyFM_Error) {
-        error.logShort('Socket Event tasks failed to execute');
-      } else {
-        DyFM_Log.error(
-          `Socket Event tasks failed to execute on ${this.serviceName}.... (${this.eventKey})`, 
-          error, 
-          'content:', 
-          content
-        );
-      }
-    }
-  }
-}
-
-
-
-
+    } catch (error) {
+      if (error instanceof DyFM_Error) {
+        error.logShort('Socket Event tasks failed to execute');
+      } else {
+        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.spec.ts

@@ -1,99 +1,99 @@
-
-import { DyFM_Log } from '../../../_collections/utils/log.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';
-import { DyFM_SocketClient_ServiceBase } from './sck-client.service-base';
-
-class TestSocketClientService extends DyFM_SocketClient_ServiceBase {
-  getParams(): DyFM_SocketClient_Params {
-    return {
-      name: 'testService',
-      address: 'http://localhost',
-      port: 3000,
-      reconnect: true,
-      reconnectDelay: 1000,
-      socketOptions: {},
-    };
-  }
-
-  getIncomingEvents(): DyFM_SocketEvent<any>[] {
-    return [];
-  }
-
-  async getSubscriptionContent(): Promise<any> {
-    return {};
-  }
-}
-
-xdescribe('| DyFM_SocketClient_ServiceBase', () => {
-  let service: TestSocketClientService;
-
-  /* beforeEach(() => {
-    TestBed.configureTestingModule({});
-    service = new TestSocketClientService();
-  }); */
-
-  it('| should initialize with default values', () => {
-    expect(service.connected).toBeFalse();
-    expect(service.subscribed).toBeFalse();
-    expect(service.subscriptionInProgress).toBeFalse();
-  });
-
-  it('| should connect and disconnect socket', async () => {
-    spyOn(DyFM_Log, 'success');
-    spyOn(DyFM_Log, 'warn');
-
-    await service['setupDefaultEvents']();
-    await service['setupSocketEvents']();
-
-    service['socket'].emit(DyFM_SocketEvent_Key.outgoingNewConnection);
-    expect(service.connected).toBeTrue();
-    expect(DyFM_Log.success).toHaveBeenCalledWith('<   >  socket-client(testService) connected!');
-
-    service['socket'].emit(DyFM_SocketEvent_Key.disconnect);
-    expect(service.connected).toBeFalse();
-    expect(DyFM_Log.warn).toHaveBeenCalledWith('<x  >  socket-client(testService) disconnected!');
-  });
-
-  it('| should handle subscription and unsubscription', async () => {
-    spyOn(DyFM_Log, 'success');
-    spyOn(DyFM_Log, 'warn');
-
-    await service.subscribe();
-    expect(service.subscriptionInProgress).toBeFalse();
-    expect(DyFM_Log.success).toHaveBeenCalledWith('<=-->  socket-client(testService) subscription successful!');
-
-    await service.unsubscribe();
-    expect(DyFM_Log.success).toHaveBeenCalledWith('<x-->  socket-client(testService) unsubscribe successful!');
-  });
-
-  it('| should handle errors during subscription', async () => {
-    spyOn(DyFM_Log, 'error');
-    spyOn(service, 'getSubscriptionContent').and.throwError('Subscription error');
-
-    try {
-      await service.subscribe();
-    } catch (error) {
-      expect(DyFM_Log.error).toHaveBeenCalledWith('socket-client(testService) Service Subscribe failed!', jasmine.any(Error));
-    }
-  });
-
-  it('| should emit events correctly', async () => {
-    spyOn(DyFM_Log, 'log');
-    spyOn(service['socket'], 'emit');
-
-    await service['emitEvent'](DyFM_SocketEvent_Key.subscribe, { data: 'test' });
-    expect(DyFM_Log.log).toHaveBeenCalledWith('<=--   outgoing socket-client(testService) event: subscribe');
-    expect(service['socket'].emit).toHaveBeenCalledWith(DyFM_SocketEvent_Key.subscribe, { data: 'test' });
-  });
-
-  /* it('| should reconnect if needed', async () => {
-    spyOn(service, 'connectSocket');
-    spyOn(DyFM_Async.delay, 'delay').and.returnValue(Promise.resolve());
-
-    service['connected'] = false;
-    await service['tryReconnectIfNeeded']();
-    expect(service.connectSocket).toHaveBeenCalled();
-  }); */
-});
+
+import { DyFM_Log } from '../../../_collections/utils/log.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';
+import { DyFM_SocketClient_ServiceBase } from './sck-client.service-base';
+
+class TestSocketClientService extends DyFM_SocketClient_ServiceBase {
+  getParams(): DyFM_SocketClient_Params {
+    return {
+      name: 'testService',
+      address: 'http://localhost',
+      port: 3000,
+      reconnect: true,
+      reconnectDelay: 1000,
+      socketOptions: {},
+    };
+  }
+
+  getIncomingEvents(): DyFM_SocketEvent<any>[] {
+    return [];
+  }
+
+  async getSubscriptionContent(): Promise<any> {
+    return {};
+  }
+}
+
+xdescribe('| DyFM_SocketClient_ServiceBase', () => {
+  let service: TestSocketClientService;
+
+  /* beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = new TestSocketClientService();
+  }); */
+
+  it('| should initialize with default values', () => {
+    expect(service.connected).toBeFalse();
+    expect(service.subscribed).toBeFalse();
+    expect(service.subscriptionInProgress).toBeFalse();
+  });
+
+  it('| should connect and disconnect socket', async () => {
+    spyOn(DyFM_Log, 'success');
+    spyOn(DyFM_Log, 'warn');
+
+    await service['setupDefaultEvents']();
+    await service['setupSocketEvents']();
+
+    service['socket'].emit(DyFM_SocketEvent_Key.outgoingNewConnection);
+    expect(service.connected).toBeTrue();
+    expect(DyFM_Log.success).toHaveBeenCalledWith('<   >  socket-client(testService) connected!');
+
+    service['socket'].emit(DyFM_SocketEvent_Key.disconnect);
+    expect(service.connected).toBeFalse();
+    expect(DyFM_Log.warn).toHaveBeenCalledWith('<x  >  socket-client(testService) disconnected!');
+  });
+
+  it('| should handle subscription and unsubscription', async () => {
+    spyOn(DyFM_Log, 'success');
+    spyOn(DyFM_Log, 'warn');
+
+    await service.subscribe();
+    expect(service.subscriptionInProgress).toBeFalse();
+    expect(DyFM_Log.success).toHaveBeenCalledWith('<=-->  socket-client(testService) subscription successful!');
+
+    await service.unsubscribe();
+    expect(DyFM_Log.success).toHaveBeenCalledWith('<x-->  socket-client(testService) unsubscribe successful!');
+  });
+
+  it('| should handle errors during subscription', async () => {
+    spyOn(DyFM_Log, 'error');
+    spyOn(service, 'getSubscriptionContent').and.throwError('Subscription error');
+
+    try {
+      await service.subscribe();
+    } catch (error) {
+      expect(DyFM_Log.error).toHaveBeenCalledWith('socket-client(testService) Service Subscribe failed!', jasmine.any(Error));
+    }
+  });
+
+  it('| should emit events correctly', async () => {
+    spyOn(DyFM_Log, 'log');
+    spyOn(service['socket'], 'emit');
+
+    await service['emitEvent'](DyFM_SocketEvent_Key.subscribe, { data: 'test' });
+    expect(DyFM_Log.log).toHaveBeenCalledWith('<=--   outgoing socket-client(testService) event: subscribe');
+    expect(service['socket'].emit).toHaveBeenCalledWith(DyFM_SocketEvent_Key.subscribe, { data: 'test' });
+  });
+
+  /* it('| should reconnect if needed', async () => {
+    spyOn(service, 'connectSocket');
+    spyOn(DyFM_Async.delay, 'delay').and.returnValue(Promise.resolve());
+
+    service['connected'] = false;
+    await service['tryReconnectIfNeeded']();
+    expect(service.connectSocket).toHaveBeenCalled();
+  }); */
+});