@aetherframework/websocket 1.0.0 → 1.0.1

package/src/core/WebSocketFactory.js

@@ -1,293 +0,0 @@
-/**
- * @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;