@aetherframework/websocket 1.0.0 → 1.0.1

package/src/drivers/memory-driver.js

@@ -1,422 +0,0 @@
-/**
- * @license MIT
- * Copyright (c) 2026-present AetherFramework Contributors.
- * SPDX-License-Identifier: MIT
- * @module @aetherframework/src/drivers/memory-driver
- */
-
-import EventEmitter from 'events';
-import crypto from 'crypto';
-
-class MemoryDriver extends EventEmitter {
-  constructor(config = {}) {
-    super();
-    this.config = {
-      maxPayload: config.maxPayload || 1024 * 1024,
-      latency: config.latency || 0, // Simulated network latency in ms
-      dropRate: config.dropRate || 0, // Simulated packet drop rate (0-1)
-      ...config
-    };
-    
-    this.connections = new Map();
-    this.messageQueue = new Map();
-    this.isServer = false;
-    this.serverInstance = null;
-  }
-  
-  /**
-   * Create an in-memory WebSocket server
-   * @param {Object} options - Server options
-   * @returns {Promise<Object>} Server instance
-   */
-  async createServer(options = {}) {
-    this.isServer = true;
-    this.serverInstance = {
-      type: 'memory',
-      address: { address: 'memory', port: 0, family: 'memory' },
-      connections: new Map(),
-      broadcast: (message) => this._broadcast(message),
-      close: () => this.closeServer(),
-      getStats: () => this.getStats()
-    };
-    
-    // Simulate server listening
-    setTimeout(() => {
-      this.emit('server:listening', {
-        host: options.host || 'memory',
-        port: options.port || 0,
-        family: 'memory'
-      });
-    }, 0);
-    
-    return this.serverInstance;
-  }
-  
-  /**
-   * Create an in-memory WebSocket client
-   * @param {string} url - WebSocket URL (ignored for memory driver)
-   * @param {Object} options - Client options
-   * @returns {Promise<Object>} Client connection
-   */
-  async createClient(url, options = {}) {
-    const connectionId = crypto.randomUUID();
-    
-    // Create mock connection
-    const connection = {
-      id: connectionId,
-      readyState: 1, // OPEN
-      protocol: options.protocol || null,
-      remoteAddress: 'memory',
-      remotePort: 0,
-      url: url,
-      options: options,
-      send: (data) => this._sendToServer(connectionId, data),
-      sendBinary: (data) => this._sendBinaryToServer(connectionId, data),
-      sendJSON: (obj) => this._sendToServer(connectionId, JSON.stringify(obj)),
-      close: (code, reason) => this._closeConnection(connectionId, code, reason),
-      terminate: () => this._terminateConnection(connectionId),
-      ping: () => this._sendPing(connectionId),
-      getStats: () => this._getConnectionStats(connectionId)
-    };
-    
-    this.connections.set(connectionId, connection);
-    
-    // Simulate connection handshake
-    setTimeout(() => {
-      if (Math.random() > this.config.dropRate) {
-        this.emit('connection', connection);
-        
-        // Simulate server accepting connection
-        if (this.isServer) {
-          this.serverInstance.connections.set(connectionId, connection);
-          
-          // Send welcome message
-          setTimeout(() => {
-            this._deliverMessage(connectionId, {
-              type: 'welcome',
-              message: 'Connected to memory WebSocket server',
-              connectionId: connectionId,
-              timestamp: Date.now()
-            });
-          }, this.config.latency);
-        }
-      } else {
-        // Simulate connection failure
-        this.emit('error', {
-          type: 'connection_failed',
-          message: 'Simulated connection failure',
-          connectionId
-        });
-      }
-    }, this.config.latency);
-    
-    return connection;
-  }
-  
-  /**
-   * Send message to server (from client)
-   * @param {string} connectionId - Connection ID
-   * @param {string|Buffer} data - Data to send
-   * @private
-   */
-  _sendToServer(connectionId, data) {
-    const connection = this.connections.get(connectionId);
-    if (!connection || connection.readyState !== 1) {
-      return false;
-    }
-    
-    // Simulate network latency
-    setTimeout(() => {
-      if (Math.random() > this.config.dropRate) {
-        // Deliver to server
-        this.emit('message', connection, data, false);
-        
-        // Update connection stats
-        connection.stats = connection.stats || {
-          messagesSent: 0,
-          messagesReceived: 0,
-          bytesSent: 0,
-          bytesReceived: 0
-        };
-        connection.stats.messagesSent++;
-        connection.stats.bytesSent += Buffer.byteLength(data);
-      } else {
-        // Simulate packet loss
-        this.emit('error', {
-          type: 'packet_loss',
-          message: 'Simulated packet loss',
-          connectionId
-        });
-      }
-    }, this.config.latency);
-    
-    return true;
-  }
-  
-  /**
-   * Send binary data to server
-   * @param {string} connectionId - Connection ID
-   * @param {Buffer} data - Binary data
-   * @private
-   */
-  _sendBinaryToServer(connectionId, data) {
-    const connection = this.connections.get(connectionId);
-    if (!connection || connection.readyState !== 1) {
-      return false;
-    }
-    
-    setTimeout(() => {
-      if (Math.random() > this.config.dropRate) {
-        this.emit('message', connection, data, true);
-        
-        connection.stats = connection.stats || {
-          messagesSent: 0,
-          messagesReceived: 0,
-          bytesSent: 0,
-          bytesReceived: 0
-        };
-        connection.stats.messagesSent++;
-        connection.stats.bytesSent += data.length;
-      }
-    }, this.config.latency);
-    
-    return true;
-  }
-  
-  /**
-   * Send ping frame
-   * @param {string} connectionId - Connection ID
-   * @private
-   */
-  _sendPing(connectionId) {
-    const connection = this.connections.get(connectionId);
-    if (!connection || connection.readyState !== 1) {
-      return false;
-    }
-    
-    setTimeout(() => {
-      if (Math.random() > this.config.dropRate) {
-        // Simulate pong response
-        setTimeout(() => {
-          this.emit('pong', connection);
-        }, this.config.latency / 2);
-      }
-    }, this.config.latency);
-    
-    return true;
-  }
-  
-  /**
-   * Deliver message to connection (from server to client)
-   * @param {string} connectionId - Connection ID
-   * @param {any} message - Message to deliver
-   * @private
-   */
-  _deliverMessage(connectionId, message) {
-    const connection = this.connections.get(connectionId);
-    if (!connection || connection.readyState !== 1) {
-      return;
-    }
-    
-    // Queue message for delivery
-    if (!this.messageQueue.has(connectionId)) {
-      this.messageQueue.set(connectionId, []);
-    }
-    
-    this.messageQueue.get(connectionId).push({
-      message,
-      timestamp: Date.now()
-    });
-    
-    // Process queue with simulated latency
-    setTimeout(() => {
-      const queue = this.messageQueue.get(connectionId);
-      if (queue && queue.length > 0) {
-        const item = queue.shift();
-        if (Math.random() > this.config.dropRate) {
-          // Emit message event on connection
-          connection.emit('message', item.message);
-          
-          // Update stats
-          connection.stats = connection.stats || {
-            messagesSent: 0,
-            messagesReceived: 0,
-            bytesSent: 0,
-            bytesReceived: 0
-          };
-          connection.stats.messagesReceived++;
-          connection.stats.bytesReceived += Buffer.byteLength(
-            typeof item.message === 'string' ? item.message : JSON.stringify(item.message)
-          );
-        }
-      }
-    }, this.config.latency);
-  }
-  
-  /**
-   * Close connection
-   * @param {string} connectionId - Connection ID
-   * @param {number} code - Close code
-   * @param {string} reason - Close reason
-   * @private
-   */
-  _closeConnection(connectionId, code = 1000, reason = '') {
-    const connection = this.connections.get(connectionId);
-    if (!connection) return;
-    
-    connection.readyState = 3; // CLOSED
-    
-    setTimeout(() => {
-      this.emit('close', connection, code, reason);
-      
-      if (this.isServer) {
-        this.serverInstance.connections.delete(connectionId);
-      }
-      
-      this.connections.delete(connectionId);
-      this.messageQueue.delete(connectionId);
-    }, this.config.latency);
-    
-    return true;
-  }
-  
-  /**
-   * Terminate connection (force close)
-   * @param {string} connectionId - Connection ID
-   * @private
-   */
-  _terminateConnection(connectionId) {
-    const connection = this.connections.get(connectionId);
-    if (!connection) return;
-    
-    connection.readyState = 3; // CLOSED
-    
-    this.emit('close', connection, 1006, 'Connection terminated');
-    
-    if (this.isServer) {
-      this.serverInstance.connections.delete(connectionId);
-    }
-    
-    this.connections.delete(connectionId);
-    this.messageQueue.delete(connectionId);
-    
-    return true;
-  }
-  
-  /**
-   * Broadcast message to all connections
-   * @param {any} message - Message to broadcast
-   * @private
-   */
-  _broadcast(message) {
-    if (!this.isServer) return;
-    
-    this.serverInstance.connections.forEach((connection, connectionId) => {
-      this._deliverMessage(connectionId, message);
-    });
-  }
-  
-  /**
-   * Send message to specific connection
-   * @param {string} connectionId - Connection ID
-   * @param {any} message - Message to send
-   */
-  sendTo(connectionId, message) {
-    if (!this.isServer) return false;
-    
-    const connection = this.serverInstance.connections.get(connectionId);
-    if (!connection) return false;
-    
-    this._deliverMessage(connectionId, message);
-    return true;
-  }
-  
-  /**
-   * Get connection statistics
-   * @param {string} connectionId - Connection ID
-   * @returns {Object} Connection statistics
-   * @private
-   */
-  _getConnectionStats(connectionId) {
-    const connection = this.connections.get(connectionId);
-    if (!connection) return null;
-    
-    return {
-      ...(connection.stats || {}),
-      readyState: connection.readyState,
-      protocol: connection.protocol,
-      remoteAddress: connection.remoteAddress,
-      remotePort: connection.remotePort,
-      uptime: Date.now() - (connection.createdAt || Date.now())
-    };
-  }
-  
-  /**
-   * Close the memory server
-   * @returns {Promise<void>}
-   */
-  async closeServer() {
-    return new Promise((resolve) => {
-      // Close all connections
-      this.connections.forEach((connection, connectionId) => {
-        this._closeConnection(connectionId, 1001, 'Server shutting down');
-      });
-      
-      // Clear all data
-      this.connections.clear();
-      this.messageQueue.clear();
-      this.serverInstance = null;
-      this.isServer = false;
-      
-      setTimeout(() => {
-        this.emit('server:closed');
-        resolve();
-      }, this.config.latency);
-    });
-  }
-  
-  /**
-   * Get server statistics
-   * @returns {Object} Statistics object
-   */
-  getStats() {
-    return {
-      connections: this.connections.size,
-      isServer: this.isServer,
-      config: {
-        latency: this.config.latency,
-        dropRate: this.config.dropRate,
-        maxPayload: this.config.maxPayload
-      },
-      memoryUsage: process.memoryUsage(),
-      timestamp: Date.now()
-    };
-  }
-  
-  /**
-   * Simulate network conditions
-   * @param {Object} conditions - Network conditions to simulate
-   */
-  simulateNetwork(conditions = {}) {
-    this.config = {
-      ...this.config,
-      ...conditions
-    };
-    
-    this.emit('network:changed', this.config);
-  }
-  
-  /**
-   * Reset all connections and state
-   */
-  reset() {
-    this.connections.clear();
-    this.messageQueue.clear();
-    this.serverInstance = null;
-    this.isServer = false;
-    
-    this.emit('reset');
-  }
-}
-
-export default MemoryDriver;