@aetherframework/websocket 1.0.1 → 1.0.3

package/src/drivers/http-driver.js

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

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