@comake/skl-js-engine/src/JsExecutor/transport/base/BaseTransport.ts

Standard Knowledge Language Javascript Engine

import { EventEmitter } from 'node:events';
import { Logger } from '../../../logger';
import type { MessageHandler, Transport, TransportConfig, TransportEvents } from '../Transport';
import { TransportStatus } from '../Transport';

/**
 * Base transport class providing common functionality for all transport implementations
 */
export abstract class BaseTransport extends EventEmitter implements Transport {
  protected internalStatus: TransportStatus = TransportStatus.disconnected;
  protected messageHandler?: MessageHandler;
  protected name?: string;
  public readonly logger = Logger.getInstance();

  public constructor() {
    super();
  }

  /**
   * Set a name for this transport (used in logging)
   */
  public setName(name: string): void {
    this.name = name;
    this.logger.setMetadata({ name, transport: this.constructor.name });
  }

  /**
   * Get current transport status
   */
  public get status(): TransportStatus {
    return this.internalStatus;
  }

  /**
   * Register a message handler for incoming messages
   */
  public onMessage<T>(handler: MessageHandler<T>): void {
    this.messageHandler = handler;
  }

  /**
   * Register an event listener
   */
  public on<TKey extends keyof TransportEvents>(event: TKey, handler: TransportEvents[TKey]): this {
    return super.on(event, handler);
  }

  /**
   * Remove an event listener
   */
  public off<TKey extends keyof TransportEvents>(event: TKey, handler: TransportEvents[TKey]): this {
    return super.off(event, handler);
  }

  /**
   * Set transport status and emit event
   */
  protected setStatus(status: TransportStatus): void {
    if (this.internalStatus !== status) {
      const previousStatus = this.internalStatus;
      this.internalStatus = status;
      this.logger.log(`Transport status changed: ${previousStatus} -> ${status}`);
      this.emit('statusChange', status);
    }
  }

  /**
   * Handle errors and emit error events
   */
  public handleError(error: Error, context?: string): void {
    const errorMessage = context ? `${context}: ${error.message}` : error.message;
    this.logger.error(errorMessage, error);
    this.emit('error', error);
  }

  /**
   * Abstract methods to be implemented by concrete transport classes
   */
  public abstract initialize(config?: TransportConfig): Promise<void>;
  public abstract send<TRequest, TResponse>(message: TRequest): Promise<TResponse>;
  public abstract close(): Promise<void>;
  public abstract isReady(): boolean;
}