@aetherframework/websocket 1.0.0 → 1.0.1

package/src/drivers/http-driver.js

@@ -1,576 +0,0 @@
-/**
- * @license MIT
- * Copyright (c) 2026-present AetherFramework Contributors.
- * SPDX-License-Identifier: MIT
- * @module @aetherframework/src/drivers/http-driver
- */
-
-
-import http from "http";
-import crypto from "crypto";
-import EventEmitter from "events";
-import FrameEncoder from "../utils/frame-encoder.js";  // For encoding WebSocket frames
-import FrameParser from "../core/FrameParser.js";     // For parsing WebSocket frames
-import HandshakeHandler from "../core/HandshakeHandler.js";
-
-class HTTPDriver extends EventEmitter {
-  /**
-   * Constructor for HTTPDriver
-   * @param {Object} config - Configuration object
-   * @param {number} config.port - Server port (default: 80)
-   * @param {string} config.host - Server host (default: "0.0.0.0")
-   * @param {number} config.maxPayload - Maximum payload size in bytes (default: 1MB)
-   * @param {number} config.pingInterval - Ping interval in milliseconds
-   * @param {number} config.socketTimeout - Socket timeout in milliseconds
-   * @param {boolean} config.compression - Enable WebSocket compression
-   */
-  constructor(config = {}) {
-    super();
-    this.config = {
-      port: 80,
-      host: "0.0.0.0",
-      maxPayload: config.maxPayload || 1024 * 1024,
-      ...config,
-    };
-
-    this.server = null;
-    this.connections = new Map(); // Map of connectionId -> connection object
-  }
-
-  /**
-   * Create an HTTP WebSocket server
-   * @param {Object} options - Server options
-   * @returns {Promise<Object>} Server instance with type, address, and close method
-   */
-  async createServer(options = {}) {
-    return new Promise((resolve, reject) => {
-      try {
-        // Create HTTP server
-        this.server = http.createServer((req, res) => {
-          // Handle regular HTTP requests
-          res.writeHead(200, { "Content-Type": "text/plain" });
-          res.end("WebSocket server is running");
-        });
-
-        // Handle WebSocket upgrade requests
-        this.server.on("upgrade", (req, socket, head) => {
-          this._handleUpgrade(req, socket, head);
-        });
-
-        const serverOptions = {
-          host: options.host || this.config.host,
-          port: options.port || this.config.port,
-          ...options,
-        };
-
-        // Start listening on specified port and host
-        this.server.listen(serverOptions, () => {
-          const address = this.server.address();
-
-          // Emit server:listening event with server details
-          this.emit("server:listening", {
-            host: address.address,
-            port: address.port,
-            family: address.family,
-          });
-
-          resolve({
-            type: "http",
-            address: address,
-            close: () => this.closeServer(),
-          });
-        });
-
-        // Handle server errors
-        this.server.on("error", (error) => {
-          this.emit("error", {
-            type: "server_error",
-            message: "HTTP server error",
-            error,
-          });
-          reject(error);
-        });
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-
-  /**
-   * Handle HTTP upgrade to WebSocket
-   * @param {http.IncomingMessage} req - HTTP request object
-   * @param {net.Socket} socket - Raw TCP socket
-   * @param {Buffer} head - First packet of the upgraded stream
-   * @private
-   */
-  _handleUpgrade(req, socket, head) {
-    // Validate WebSocket upgrade request
-    if (!this._isValidWebSocketUpgrade(req)) {
-      socket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
-      socket.destroy();
-      return;
-    }
-
-    // Perform WebSocket handshake
-    const key = req.headers["sec-websocket-key"];
-    const acceptKey = crypto
-      .createHash("sha1")
-      .update(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
-      .digest("base64");
-
-    const headers = [
-      "HTTP/1.1 101 Switching Protocols",
-      "Upgrade: websocket",
-      "Connection: Upgrade",
-      `Sec-WebSocket-Accept: ${acceptKey}`,
-    ];
-
-    // Add optional protocol header if requested
-    if (req.headers["sec-websocket-protocol"]) {
-      const protocol = req.headers["sec-websocket-protocol"];
-      headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
-    }
-
-    // Add optional extensions header if compression is enabled
-    if (this.config.compression && req.headers["sec-websocket-extensions"]) {
-      headers.push("Sec-WebSocket-Extensions: permessage-deflate");
-    }
-
-    const response = headers.join("\r\n") + "\r\n\r\n";
-    socket.write(response);
-
-    // Create connection object
-    const connectionId = crypto.randomUUID();
-    const connection = {
-      id: connectionId,
-      socket: socket,
-      req: req,
-      readyState: 1, // OPEN state
-      protocol: req.headers["sec-websocket-protocol"] || null,
-      extensions: req.headers["sec-websocket-extensions"] || null,
-      remoteAddress: req.socket.remoteAddress,
-      remotePort: req.socket.remotePort,
-      headers: req.headers,
-      url: req.url,
-    };
-
-    this.connections.set(connectionId, connection);
-
-    // Configure socket options
-    socket.setNoDelay(true);
-    socket.setKeepAlive(true, 10000);
-    socket.setTimeout(this.config.socketTimeout || 30000);
-
-    // Process any buffered data from the upgrade
-    if (head && head.length > 0) {
-      this._handleWebSocketData(socket, head);
-    }
-
-    // Set up socket event handlers
-    socket.on("data", (data) => {
-      this._handleWebSocketData(socket, data);
-    });
-
-    socket.on("close", () => {
-      this.emit("close", connection, 1006, "Connection closed");
-      this._removeConnection(connectionId);
-    });
-
-    socket.on("error", (error) => {
-      this.emit("error", {
-        type: "socket_error",
-        message: "HTTP socket error",
-        error,
-        connectionId,
-      });
-      this._removeConnection(connectionId);
-    });
-
-    socket.on("timeout", () => {
-      socket.end();
-      this._removeConnection(connectionId);
-    });
-
-    // Emit connection event
-    this.emit("connection", connection);
-
-    // Set up heartbeat/ping interval if configured
-    if (this.config.pingInterval) {
-      const pingInterval = setInterval(() => {
-        if (connection.readyState === 1) {
-          this._sendPing(socket);
-        } else {
-          clearInterval(pingInterval);
-        }
-      }, this.config.pingInterval);
-
-      connection.pingInterval = pingInterval;
-    }
-  }
-
-  /**
-   * Validate WebSocket upgrade request
-   * @param {http.IncomingMessage} req - HTTP request
-   * @returns {boolean} Whether request is a valid WebSocket upgrade
-   * @private
-   */
-  _isValidWebSocketUpgrade(req) {
-    const upgrade = req.headers.upgrade;
-    const connection = req.headers.connection;
-    const key = req.headers["sec-websocket-key"];
-    const version = req.headers["sec-websocket-version"];
-
-    return (
-      upgrade &&
-      upgrade.toLowerCase() === "websocket" &&
-      connection &&
-      connection.toLowerCase().includes("upgrade") &&
-      key &&
-      key.length === 24 &&
-      version === "13"
-    );
-  }
-
-  /**
-   * Handle WebSocket data frames
-   * @param {net.Socket} socket - Raw socket
-   * @param {Buffer} data - Data buffer containing WebSocket frames
-   * @private
-   */
-  _handleWebSocketData(socket, data) {
-    const connection = this.connections.get(socket);
-    const connectionId = connection?.id || 'unknown';
-    
-    try {
-      // Parse WebSocket frames from the data buffer
-      const result = FrameParser.parse(data, this.config.maxPayload);
-      
-      // Process all parsed frames
-      for (const frame of result.frames) {
-        this._processWebSocketFrame(socket, frame, connection);
-      }
-      
-    } catch (error) {
-      console.error(`Frame parsing error for connection ${connectionId}:`, error);
-      
-      this.emit("error", {
-        type: "frame_parse_error",
-        message: "Failed to parse WebSocket frame",
-        error,
-        connectionId,
-      });
-
-      // Send close frame and close connection on protocol error
-      this._sendCloseFrame(socket, 1002, "Protocol error");
-    }
-  }
-
-  /**
-   * Process a single WebSocket frame
-   * @param {net.Socket} socket - Raw socket
-   * @param {Object} frame - Parsed frame object
-   * @param {Object} connection - Connection object
-   * @private
-   */
-  _processWebSocketFrame(socket, frame, connection) {
-    if (!connection) return;
-    
-    switch (frame.opcode) {
-      case 0x1: // TEXT frame
-        this.emit(
-          "message",
-          connection,
-          frame.payload.toString("utf8"),
-          false,
-        );
-        break;
-      case 0x2: // BINARY frame
-        this.emit(
-          "message",
-          connection,
-          frame.payload,
-          true,
-        );
-        break;
-      case 0x8: // CLOSE frame
-        this._handleCloseFrame(socket, frame);
-        break;
-      case 0x9: // PING frame
-        this._handlePingFrame(socket, frame);
-        break;
-      case 0xa: // PONG frame
-        this._handlePongFrame(socket, frame);
-        break;
-      case 0x0: // CONTINUATION frame
-        this._handleContinuationFrame(socket, frame);
-        break;
-      default:
-        console.warn(`Unknown WebSocket opcode: 0x${frame.opcode.toString(16)}`);
-    }
-  }
-
-  /**
-   * Handle Close frame
-   * @param {net.Socket} socket - Raw socket
-   * @param {Object} frame - Parsed frame object
-   * @private
-   */
-  _handleCloseFrame(socket, frame) {
-    const connection = this.connections.get(socket);
-    if (!connection) return;
-
-    let code = 1000; // Default close code
-    let reason = "";
-
-    // Parse close code and reason from payload
-    if (frame.payload && frame.payload.length >= 2) {
-      code = frame.payload.readUInt16BE(0);
-      if (frame.payload.length > 2) {
-        reason = frame.payload.slice(2).toString("utf8");
-      }
-    }
-
-    // Send close frame response
-    this._sendCloseFrame(socket, code, reason);
-
-    // Update connection state
-    connection.readyState = 3; // CLOSED
-
-    // Emit close event
-    this.emit("close", connection, code, reason);
-
-    // Close socket
-    socket.end();
-
-    // Remove connection from active connections
-    this._removeConnection(connection.id);
-  }
-
-  /**
-   * Handle Ping frame
-   * @param {net.Socket} socket - Raw socket
-   * @param {Object} frame - Parsed frame object
-   * @private
-   */
-  _handlePingFrame(socket, frame) {
-    // Echo back the ping payload as pong (RFC 6455 requirement)
-    this._sendPong(socket, frame.payload);
-
-    // Emit ping event for monitoring
-    const connection = this.connections.get(socket);
-    if (connection) {
-      this.emit("ping", connection, frame.payload);
-    }
-  }
-
-  /**
-   * Handle Pong frame
-   * @param {net.Socket} socket - Raw socket
-   * @param {Object} frame - Parsed frame object
-   * @private
-   */
-  _handlePongFrame(socket, frame) {
-    // Emit pong event for monitoring
-    const connection = this.connections.get(socket);
-    if (connection) {
-      this.emit("pong", connection, frame.payload);
-    }
-  }
-
-  /**
-   * Handle Continuation frame (for fragmented messages)
-   * @param {net.Socket} socket - Raw socket
-   * @param {Object} frame - Parsed frame object
-   * @private
-   */
-  _handleContinuationFrame(socket, frame) {
-    const connection = this.connections.get(socket);
-    if (!connection) return;
-
-    // Store continuation frame data
-    if (!connection.fragmentedData) {
-      connection.fragmentedData = [];
-    }
-
-    connection.fragmentedData.push(frame.payload);
-
-    // If this is the final fragment, combine and emit
-    if (frame.fin) {
-      const completeData = Buffer.concat(connection.fragmentedData);
-      const isBinary = connection.fragmentedOpcode === 0x2;
-
-      this.emit(
-        "message",
-        connection,
-        isBinary ? completeData : completeData.toString("utf8"),
-        isBinary,
-      );
-
-      // Clean up fragmented data storage
-      delete connection.fragmentedData;
-      delete connection.fragmentedOpcode;
-    }
-  }
-
-  /**
-   * Send ping frame to client
-   * @param {net.Socket} socket - Raw socket
-   * @private
-   */
-  _sendPing(socket) {
-    const pingFrame = FrameEncoder.createPingFrame();
-    socket.write(pingFrame);
-  }
-
-  /**
-   * Send pong frame to client
-   * @param {net.Socket} socket - Raw socket
-   * @param {Buffer} payload - Ping payload to echo back
-   * @private
-   */
-  _sendPong(socket, payload) {
-    const pongFrame = FrameEncoder.createPongFrame(payload);
-    socket.write(pongFrame);
-  }
-
-  /**
-   * Send close frame to client
-   * @param {net.Socket} socket - Raw socket
-   * @param {number} code - Close status code
-   * @param {string} reason - Close reason
-   * @private
-   */
-  _sendCloseFrame(socket, code, reason) {
-    const closeFrame = FrameEncoder.createCloseFrame(code, reason);
-    socket.write(closeFrame);
-  }
-
-  /**
-   * Remove connection from active connections
-   * @param {string} connectionId - Connection ID
-   * @private
-   */
-  _removeConnection(connectionId) {
-    const connection = this.connections.get(connectionId);
-    if (connection) {
-      // Clear ping interval if exists
-      if (connection.pingInterval) {
-        clearInterval(connection.pingInterval);
-      }
-      this.connections.delete(connectionId);
-    }
-  }
-
-  /**
-   * Create a WebSocket client over HTTP
-   * @param {string} url - WebSocket URL (ws://)
-   * @param {Object} options - Client options
-   * @returns {Promise<Object>} Client connection object
-   */
-  async createClient(url, options = {}) {
-    const urlObj = new URL(url);
-    const host = urlObj.hostname;
-    const port = parseInt(urlObj.port) || 80;
-    const path = urlObj.pathname + urlObj.search;
-
-    return new Promise((resolve, reject) => {
-      const req = http.request({
-        hostname: host,
-        port: port,
-        path: path,
-        method: "GET",
-        headers: {
-          Upgrade: "websocket",
-          Connection: "Upgrade",
-          "Sec-WebSocket-Key": crypto.randomBytes(16).toString("base64"),
-          "Sec-WebSocket-Version": "13",
-          ...options.headers,
-        },
-      });
-
-      req.on("upgrade", (res, socket, head) => {
-        const connection = {
-          id: crypto.randomUUID(),
-          socket: socket,
-          readyState: 1,
-          send: (data) => this._sendData(socket, data),
-          close: (code, reason) => {
-            this._sendCloseFrame(socket, code, reason);
-            socket.end();
-          },
-        };
-
-        // Handle incoming data from server
-        socket.on("data", (data) => {
-          this._handleWebSocketData(socket, data);
-        });
-
-        // Process any buffered data from the upgrade
-        if (head && head.length > 0) {
-          this._handleWebSocketData(socket, head);
-        }
-
-        resolve(connection);
-      });
-
-      req.on("error", reject);
-      req.end();
-    });
-  }
-
-  /**
-   * Send data through socket as WebSocket frame
-   * @param {net.Socket} socket - Raw socket
-   * @param {string|Buffer} data - Data to send
-   * @private
-   */
-  _sendData(socket, data) {
-    const frame = FrameEncoder.encode(
-      0x1, // Text frame opcode
-      Buffer.isBuffer(data) ? data : Buffer.from(data, "utf8"),
-    );
-    socket.write(frame);
-  }
-
-  /**
-   * Close the HTTP server gracefully
-   * @returns {Promise<void>}
-   */
-  async closeServer() {
-    return new Promise((resolve) => {
-      if (this.server) {
-        // Close all active connections
-        this.connections.forEach((connection) => {
-          if (connection.readyState === 1) {
-            this._sendCloseFrame(connection.socket, 1001, "Server going away");
-            connection.socket.end();
-          }
-        });
-
-        // Close the server
-        this.server.close(() => {
-          this.connections.clear();
-          resolve();
-        });
-      } else {
-        resolve();
-      }
-    });
-  }
-
-  /**
-   * Get server statistics
-   * @returns {Object} Statistics object containing connection count, uptime, etc.
-   */
-  getStats() {
-    return {
-      connections: this.connections.size,
-      uptime: this.server ? Date.now() - this.server.startTime : 0,
-      host: this.config.host,
-      port: this.config.port,
-      driver: "http",
-    };
-  }
-}
-
-export default HTTPDriver;

package/src/drivers/index.js

@@ -1,29 +0,0 @@
-/**
- * @license MIT
- * Copyright (c) 2026-present AetherFramework Contributors.
- * SPDX-License-Identifier: MIT
- * @module @aetherframework/src/drivers/index
- */
-
-const drivers = {
-  tcp: () => import('./tcp-driver.js'),
-  tls: () => import('./tls-driver.js'),
-  http: () => import('./http-driver.js'),
-  memory: () => import('./memory-driver.js')
-};
-
-/**
- * Get driver class by name
- * @param {string} name - Driver name
- * @returns {Promise<Class>} Driver class
- */
-export async function getDriver(name) {
-  const loader = drivers[name];
-  if (!loader) {
-    throw new Error(`Unsupported driver: ${name}. Available: ${Object.keys(drivers).join(', ')}`);
-  }
-  const module = await loader();
-  return module.default;
-}
-
-export default { getDriver };