@aetherframework/websocket 1.0.1 → 1.0.3

package/src/core/WebSocketFactory.js

@@ -0,0 +1,293 @@
+/**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/src/core/WebSocketFactory
+ */
+
+import EventEmitter from 'events';
+import ConnectionManager from './ConnectionManager.js';
+import FrameParser from './FrameParser.js';
+import ProtocolHandler from './ProtocolHandler.js';
+import ConfigLoader from '../utils/config-loader.js';
+
+class WebSocketFactory extends EventEmitter {
+  /**
+   * Create a new WebSocketFactory instance
+   * @param {Object} options - Configuration options
+   */
+  constructor(options = {}) {
+    super();
+    
+    // Load configuration from environment and options
+    this.config = ConfigLoader.load({
+      // Default configuration
+      driver: 'tcp',
+      port: 8080,
+      host: '0.0.0.0',
+      maxPayload: 1024 * 1024, // 1MB
+      pingInterval: 30000, // 30 seconds
+      pingTimeout: 10000, // 10 seconds
+      compression: false,
+      tls: false,
+      tlsOptions: {},
+      // Merge with user options
+      ...options
+    });
+    
+    this.connectionManager = new ConnectionManager();
+    this.frameParser = new FrameParser(this.config);
+    this.protocolHandler = new ProtocolHandler(this.config);
+    this.driver = null;
+    this.server = null;
+    this.middleware = [];
+    
+    // Initialize driver
+    this._initializeDriver();
+  }
+  
+  /**
+   * Initialize the selected transport driver
+   * @private
+   */
+  async _initializeDriver() {
+    try {
+      const driverName = this.config.driver || 'tcp';
+      const driverModule = await import(`../drivers/${driverName}-driver.js`);
+      this.driver = new driverModule.default(this.config);
+      
+      // Set up driver event forwarding
+      this._setupDriverEvents();
+      
+      this.emit('driver:initialized', { driver: driverName });
+    } catch (error) {
+      this.emit('error', {
+        type: 'driver_initialization',
+        message: `Failed to initialize driver: ${error.message}`,
+        error
+      });
+      throw error;
+    }
+  }
+  
+  /**
+   * Set up event forwarding from driver to factory
+   * @private
+   */
+  _setupDriverEvents() {
+    if (!this.driver) return;
+    
+    // Forward all driver events to factory
+    const eventsToForward = [
+      'server:listening',
+      'server:closed',
+      'server:error',
+      'connection',
+      'message',
+      'close',
+      'error',
+      'ping',
+      'pong'
+    ];
+    
+    eventsToForward.forEach(event => {
+      this.driver.on(event, (...args) => {
+        this.emit(event, ...args);
+      });
+    });
+  }
+  
+  /**
+   * Create a WebSocket server
+   * @param {Object} options - Server-specific options
+   * @returns {Promise<Object>} Server instance
+   */
+  async createServer(options = {}) {
+    if (!this.driver) {
+      await this._initializeDriver();
+    }
+    
+    const serverOptions = {
+      ...this.config,
+      ...options
+    };
+    
+    try {
+      this.server = await this.driver.createServer(serverOptions);
+      
+      // CRITICAL FIX: Ensure server:listening event is emitted
+      // Get server address information
+      let addressInfo;
+      if (this.server.address && typeof this.server.address === 'function') {
+        addressInfo = this.server.address();
+      } else if (this.server.address) {
+        addressInfo = this.server.address;
+      } else {
+        addressInfo = {
+          address: serverOptions.host || '0.0.0.0',
+          port: serverOptions.port || 8080,
+          family: 'IPv4'
+        };
+      }
+      
+      // Emit server:listening event with address information
+      // Use setTimeout to ensure event listeners are registered
+      setTimeout(() => {
+        this.emit('server:listening', {
+          host: addressInfo.address,
+          port: addressInfo.port,
+          family: addressInfo.family || 'IPv4'
+        });
+      }, 0);
+      
+      this.emit('server:created', this.server);
+      return this.server;
+    } catch (error) {
+      this.emit('error', {
+        type: 'server_creation',
+        message: `Failed to create server: ${error.message}`,
+        error
+      });
+      throw error;
+    }
+  }
+  
+  /**
+   * Create a WebSocket client connection
+   * @param {string} url - WebSocket URL (ws:// or wss://)
+   * @param {Object} options - Client options
+   * @returns {Promise<Object>} Client connection
+   */
+  async createClient(url, options = {}) {
+    if (!this.driver) {
+      await this._initializeDriver();
+    }
+    
+    const clientOptions = {
+      ...this.config,
+      ...options
+    };
+    
+    try {
+      const client = await this.driver.createClient(url, clientOptions);
+      this.emit('client:created', client);
+      return client;
+    } catch (error) {
+      this.emit('error', {
+        type: 'client_creation',
+        message: `Failed to create client: ${error.message}`,
+        error
+      });
+      throw error;
+    }
+  }
+  
+  /**
+   * Add middleware to the WebSocket pipeline
+   * @param {Function} middleware - Middleware function
+   */
+  use(middleware) {
+    this.middleware.push(middleware);
+  }
+  
+  /**
+   * Broadcast message to all connected clients
+   * @param {string|Buffer} message - Message to broadcast
+   * @param {Function} filter - Optional filter function
+   */
+  broadcast(message, filter = null) {
+    const connections = this.connectionManager.getAll();
+    
+    connections.forEach(connection => {
+      if (!filter || filter(connection)) {
+        try {
+          connection.send(message);
+        } catch (error) {
+          this.emit('error', {
+            type: 'broadcast',
+            message: `Failed to broadcast to connection ${connection.id}`,
+            error,
+            connection
+          });
+        }
+      }
+    });
+  }
+  
+  /**
+   * Send message to specific connection
+   * @param {string} connectionId - Connection ID
+   * @param {string|Buffer} message - Message to send
+   * @returns {boolean} Success status
+   */
+  sendTo(connectionId, message) {
+    const connection = this.connectionManager.get(connectionId);
+    if (connection && connection.readyState === 1) { // OPEN
+      return connection.send(message);
+    }
+    return false;
+  }
+  
+  /**
+   * Get connection by ID
+   * @param {string} connectionId - Connection ID
+   * @returns {Object|null} Connection object or null
+   */
+  getConnection(connectionId) {
+    return this.connectionManager.get(connectionId);
+  }
+  
+  /**
+   * Get all connections
+   * @returns {Array} Array of connection objects
+   */
+  getConnections() {
+    return this.connectionManager.getAll();
+  }
+  
+  /**
+   * Get connection statistics
+   * @returns {Object} Statistics object
+   */
+  getStats() {
+    const connections = this.connectionManager.getAll();
+    
+    return {
+      totalConnections: connections.length,
+      activeConnections: connections.filter(c => c.readyState === 1).length,
+      driver: this.config.driver,
+      uptime: this.server ? Date.now() - this.server.startTime : 0,
+      memoryUsage: process.memoryUsage(),
+      config: {
+        maxPayload: this.config.maxPayload,
+        pingInterval: this.config.pingInterval,
+        pingTimeout: this.config.pingTimeout,
+        compression: this.config.compression
+      }
+    };
+  }
+  
+  /**
+   * Close the WebSocket server
+   * @returns {Promise<void>}
+   */
+  async close() {
+    if (this.server) {
+      await this.driver.closeServer(this.server);
+      this.emit('server:closed');
+    }
+    
+    // Close all connections
+    const connections = this.connectionManager.getAll();
+    connections.forEach(connection => {
+      if (connection.readyState === 1) {
+        connection.close(1000, 'Server shutting down');
+      }
+    });
+    
+    this.connectionManager.clear();
+    this.emit('closed');
+  }
+}
+
+export default WebSocketFactory;