@futdevpro/fsm-dynamo 1.20.9 → 1.20.12

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

@@ -1,99 +0,0 @@
-
-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();
-  }); */
-});

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

@@ -1,353 +0,0 @@
-
-import * as SocketIOClient from 'socket.io-client';
-import { BehaviorSubject } from 'rxjs';
-
-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_Async } from '../../../_collections/utils/async.util';
-import { DyFM_Error } from '../../../_models/control-models/error.control-model';
-
-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';
-
-/**
- * Base implementation for socket.io clients used by Dynamo.
- * Handles connection logic, subscriptions and default events.
- */
-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 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; 
-  }
-  readonly connected$ = this._connected_BS.asObservable();
-
-  private readonly _subscribed_BS: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
-  get subscribed(): boolean { 
-    return this._subscribed_BS.value; 
-  }
-  readonly subscribed$ = this._subscribed_BS.asObservable();
-
-  protected debugLog: boolean = DyFM_global_settings.log_settings.setup;
-  protected logFn: boolean = DyFM_global_settings.log_settings.functions;
-
-  private readonly defaultEvents: DyFM_SocketEvent<any>[] = [
-    new DyFM_SocketEvent<any>({
-      eventKey: DyFM_SocketEvent_Key.outgoingNewConnection,
-      tasks: [
-        async (): Promise<void> => {
-          this._connected_BS.next(true);
-
-          if (this.subscribed) {
-            this._subscribed_BS.next(false);
-          }
-          DyFM_Log.success(`<   >  socket-client(${this.params.name}) connected!`);
-        },
-      ],
-    }),
-
-    new DyFM_SocketEvent<any>({
-      eventKey: DyFM_SocketEvent_Key.disconnect,
-      tasks: [
-        async (): Promise<void> => {
-          this._connected_BS.next(false);
-
-          if (this.subscribed) {
-            this._subscribed_BS.next(false);
-          }
-          DyFM_Log.warn(`<x  >  socket-client(${this.params.name}) disconnected!`);
-
-          if (this._params.reconnect) {
-            await DyFM_Async.delay(this._params.reconnectDelay);
-            this.connectSocket();
-          }
-        },
-      ],
-    }),
-
-    new DyFM_SocketEvent<any>({
-      eventKey: DyFM_SocketEvent_Key.subscriptionSuccessful,
-      tasks: [
-        async (): Promise<void> => {
-          DyFM_Log.success(`<=-->  socket-client(${this.params.name}) subscription successful!`);
-          this._subscribed_BS.next(true);
-        },
-      ],
-    }),
-
-    new DyFM_SocketEvent<any>({
-      eventKey: DyFM_SocketEvent_Key.unsubscribeSuccessful,
-      tasks: [
-        async (): Promise<void> => {
-          DyFM_Log.success(`<x-->  socket-client(${this.params.name}) unsubscribe successful!`);
-          this._subscribed_BS.next(false);
-        },
-      ],
-    }),
-
-    new DyFM_SocketEvent<any>({
-      eventKey: DyFM_SocketEvent_Key.error,
-      tasks: [
-        async (content: any): Promise<void> => {
-          DyFM_Error.logSimple(`=-->   socket-client(${this.params.name}) ERROR`, content);
-        },
-      ],
-    }),
-  ];
-
-  protected constructor() {
-    this.asyncConstructor().catch((error: any): void => {
-      DyFM_Error.logSimple(
-        `socket-client "${this.params?.name}" Service setup failed! ` +
-        `(DyFM_SocketClientService constructor catch)` +
-        `\n    ERROR:`, error
-      );
-    });
-  }
-
-  subscriptionInProgress: boolean = false;
-  async subscribe(): Promise<void> {
-    try {
-      if (this.subscribed) {
-        DyFM_Log.warn(`socket-client(${this.params.name}) already subscribed!`);
-        
-        return;
-      }
-
-      if (this.subscriptionInProgress) {
-        DyFM_Log.warn(`socket-client(${this.params.name}) subscription in progress!`);
-        
-        return;
-      }
-
-      this.subscriptionInProgress = true;
-
-      const subscriptionContent: T_SubscriptionContent = await this.getSubscriptionContent();
-
-      await this.emitEvent(DyFM_SocketEvent_Key.subscribe, subscriptionContent);
-
-      this.subscriptionInProgress = false;
-    } catch (error) {
-      DyFM_Log.error(`socket-client(${this.params.name}) Service Subscribe failed!`, error);
-
-      this.subscriptionInProgress = false;
-
-      throw error;
-    }
-  }
-
-  async unsubscribe(): Promise<void> {
-    try {
-      await this.emitEvent(DyFM_SocketEvent_Key.unsubscribe, null);
-    } catch (error) {
-      DyFM_Log.error(`socket-client(${this.params.name}) Service Unsubscribe failed!`, 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;
-    }
-  }
-
-  private async asyncConstructor(): Promise<void> {
-    try {
-      this._params = this.getParams();
-      this.incomingEvents = this.getIncomingEvents() ?? [];
-      const socketAddress = this.params.port ? `${this.params.address}:${this.params.port}` : this.params.address;
-      this.socket = SocketIOClient.io(
-        socketAddress,
-        {
-          /* 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>): void => {
-        defaultEvent.serviceName = this.params.name;
-        const eventDeclared = this.incomingEvents.find(
-          (event: DyFM_SocketEvent<any>): boolean => 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>): Promise<void> => {
-          event.serviceName = this.params.name;
-          this.socket.on(event.eventKey, async (content: any): Promise<void> => { 
-            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;
-    }
-  }
-  
-  protected 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 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_Async.delay(this._params.reconnectDelay);
-      
-      if (!this.connected) {
-        this.tryingToReconnect = false;
-        await this.connectSocket();
-      }
-    } catch (error) {
-      DyFM_Log.error(
-        `socket-client(${this.params.name}) Service Try Reconnect failed, ` +
-        `ERROR:`, error
-      );
-      this.tryingToReconnect = false;
-
-      throw error;
-    }
-  }
-
-  /**
-   * Manuális újracsatlakozás: disconnect majd connectSocket.
-   * A tryingToReconnect flag törlődik, hogy az azonnali connectSocket ne ütközzön az automata retry-vel.
-   */
-  reconnect(): void {
-    this.tryingToReconnect = false;
-    if (this.socket) {
-      this.socket.disconnect();
-    }
-    this.connectSocket();
-  }
-
-  /**
-   * 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>[];
-
-  /**
-   * You must setup subscription content for the service in this function
-   */
-  abstract getSubscriptionContent(): Promise<T_SubscriptionContent>;
-}
-
-

package/src/_modules/socket/index.ts

@@ -1,14 +0,0 @@
-
-
-
-// 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/_modules/state-machine/_models/state-machine-config.interface.ts

@@ -1,19 +0,0 @@
-import { DyFM_StateMachineEvent } from './state-machine-event.interface';
-import { DyFM_StateTransition } from './state-transition.interface';
-
-/**
- * Config-objektum a `DyFM_StateMachine` konstruktorhoz.
- *
- * - `initial`: induloallapot
- * - `transitions`: a megengedett atmenetek listaja (transitionMap)
- * - `persist`: opcionalis aszinkron callback minden sikeres atmenet utan
- *   (NEM a state-valtas elott — a state mar uj-erteku amikor a `persist`
- *   fut, igy a callback-be erkezo event tartalmazza a `to`-t es a `stateVersion`-t).
- *   Throw-ja kivaltja a `'persist-failed'` reason-t es a state automatikusan
- *   visszaall a from-ra (atomicity).
- */
-export interface DyFM_StateMachineConfig<TState extends string, TContext = unknown> {
-  initial: TState;
-  transitions: DyFM_StateTransition<TState, TContext>[];
-  persist?: (event: DyFM_StateMachineEvent<TState, TContext>) => Promise<void>;
-}

package/src/_modules/state-machine/_models/state-machine-event.interface.ts

@@ -1,25 +0,0 @@
-/**
- * Egy sikeres atmenet utan kibocsatott esemeny.
- *
- * A `DyFM_StateMachine.events$` Observable-en at szubszkribalhato. Az opcionalis
- * `persist` callback is ezt az objektumot kapja meg, igy a konzumens (pl.
- * Mongoose ControlModel) eldontheti milyen mezoket frissit.
- *
- * `stateVersion` minden sikeres atmenet utan inkrementalodik (0 -> 1 -> 2 -> ...).
- * Optimistic-concurrency token-kent hasznalhato a `persist` callback-ben
- * (`$inc: { stateVersion: 1 }` + `findOneAndUpdate({ stateVersion: prevVersion })`
- * mintara) hogy a race conditions detektalhatoak legyenek tobb-folyamatos
- * deploy-okban.
- */
-export interface DyFM_StateMachineEvent<TState extends string, TContext = unknown> {
-  /** Az atmenet elotti state. */
-  from: TState;
-  /** Az atmenet utani state. */
-  to: TState;
-  /** A frissitett state-version szam (>= 1). */
-  stateVersion: number;
-  /** Az opcionalis context, ahogy a `transition()`-be erkezett. */
-  context?: TContext;
-  /** Az atmenet idobelyege (ms epoch). */
-  timestamp: number;
-}