@rpgjs/vite 5.0.0-alpha.9 → 5.0.0-beta.2

package/src/server-plugin.ts

@@ -1,221 +1,14 @@
-import { RpgServerEngine } from "@rpgjs/server";
+import { createRpgServerTransport, logNetworkSimulationStatus } from "@rpgjs/server/node";
+import type { RpgTransportServerConstructor, RpgWebSocketServer } from "@rpgjs/server/node";
 import type { ViteDevServer } from "vite";
-import { IncomingMessage } from "http";
-import { Duplex } from "stream";
 
-// Types for WebSocket without importing ws directly
-interface WSConnection {
-  readyState: number;
-  send(data: string): void;
-  close(): void;
-  on(event: string, callback: (...args: any[]) => void): void;
-}
-
-interface WSServer {
-  handleUpgrade(
-    request: IncomingMessage,
-    socket: Duplex,
-    head: Buffer,
-    callback: (ws: WSConnection) => void
-  ): void;
-  close(): void;
-}
-
-/**
- * PartyConnection class compatible with PartyKit's Party.Connection interface
- *
- * This class implements the Connection interface expected by RPG-JS server,
- * providing WebSocket communication capabilities and connection state management.
- *
- * @example
- * ```typescript
- * const connection = new PartyConnection(websocket, 'player123');
- * connection.send('Hello player!');
- * connection.setState({ username: 'Alice' });
- * ```
- */
-class PartyConnection {
-  public id: string;
-  public uri: string;
-  private _state: any = {};
-
-  constructor(private ws: WSConnection, id?: string, uri?: string) {
-    this.id = id || this.generateId();
-    this.uri = uri || "";
-  }
-
-  /**
-   * Generates a unique identifier for the connection
-   *
-   * @returns {string} Unique identifier based on timestamp and random number
-   */
-  private generateId(): string {
-    return `conn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  /**
-   * Sends data to the client via WebSocket
-   *
-   * @param {any} data - Data to send (automatically serialized to JSON if not string)
-   */
-  send(data: any): void {
-    if (this.ws.readyState === 1) {
-      // WebSocket.OPEN
-      const message = typeof data === "string" ? data : JSON.stringify(data);
-      this.ws.send(message);
-    }
-  }
-
-  /**
-   * Closes the WebSocket connection
-   */
-  close(): void {
-    if (this.ws.readyState === 1) {
-      // WebSocket.OPEN
-      this.ws.close();
-    }
-  }
-
-  /**
-   * Sets state data for this connection
-   *
-   * @param {any} value - State data to store (max 2KB as per PartyKit spec)
-   */
-  setState(value: any): void {
-    this._state = value;
-  }
-
-  /**
-   * Gets the current state of this connection
-   *
-   * @returns {any} Current connection state
-   */
-  get state(): any {
-    return this._state;
-  }
-}
-
-/**
- * Room class compatible with PartyKit's Party.Room interface
- *
- * This class manages multiple WebSocket connections and provides broadcasting
- * capabilities, storage, and connection management as expected by RPG-JS server.
- *
- * @example
- * ```typescript
- * const room = new Room('lobby-1');
- * room.broadcast('Game started!');
- * const playerCount = [...room.getConnections()].length;
- * ```
- */
-class Room {
-  public id: string;
-  public internalID: string;
-  public env: Record<string, any> = {};
-  public context: any = {};
-  private connections: Map<string, PartyConnection> = new Map();
-  private storageData: Map<string, any> = new Map();
-
-  constructor(id: string) {
-    this.id = id;
-    this.internalID = `internal_${id}_${Date.now()}`;
-  }
-
-  /**
-   * Broadcasts a message to all connected clients
-   *
-   * @param {any} message - Message to broadcast
-   * @param {string[]} except - Array of connection IDs to exclude from broadcast
-   */
-  broadcast(message: any, except: string[] = []): void {
-    const data =
-      typeof message === "string" ? message : JSON.stringify(message);
-
-    for (const [connectionId, connection] of this.connections) {
-      if (!except.includes(connectionId)) {
-        connection.send(data);
-      }
-    }
-  }
-
-  /**
-   * Gets a connection by its ID
-   *
-   * @param {string} id - Connection ID
-   * @returns {PartyConnection | undefined} The connection or undefined if not found
-   */
-  getConnection(id: string): PartyConnection | undefined {
-    return this.connections.get(id);
-  }
-
-  /**
-   * Gets all currently connected clients
-   *
-   * @param {string} tag - Optional tag to filter connections (not implemented yet)
-   * @returns {IterableIterator<PartyConnection>} Iterator of all connections
-   */
-  getConnections(tag?: string): IterableIterator<PartyConnection> {
-    // TODO: Implement tag filtering if needed
-    return this.connections.values();
-  }
-
-  /**
-   * Adds a connection to this room
-   *
-   * @param {PartyConnection} connection - Connection to add
-   */
-  addConnection(connection: PartyConnection): void {
-    this.connections.set(connection.id, connection);
-  }
-
-  /**
-   * Removes a connection from this room
-   *
-   * @param {string} connectionId - ID of connection to remove
-   */
-  removeConnection(connectionId: string): void {
-    this.connections.delete(connectionId);
-  }
-
-  /**
-   * Simple key-value storage for the room
-   */
-  get storage() {
-    return {
-      put: async (key: string, value: any) => {
-        this.storageData.set(key, value);
-      },
-      get: async <T = any>(key: string): Promise<T | undefined> => {
-        return this.storageData.get(key) as T;
-      },
-      delete: async (key: string) => {
-        this.storageData.delete(key);
-      },
-      list: async () => {
-        return Array.from(this.storageData.keys());
-      },
-    };
-  }
-}
-
-/**
- * Utility function to safely import WebSocketServer
- *
- * This function checks if we are in a Node.js environment
- * before trying to import the ws module, thus avoiding
- * browser compatibility errors.
- *
- * @returns {Promise<any>} The WebSocketServer class or null if not available
- */
 async function importWebSocketServer(): Promise<any> {
-  // Check if we are in a Node.js environment
   if (typeof process === "undefined" || !process.versions?.node) {
     console.warn("Not in Node.js environment, WebSocket server not available");
     return null;
   }
 
   try {
-    // Use createRequire to import ws in an ES module context
     const { createRequire } = await import("module");
     const require = createRequire(import.meta.url);
     const ws = require("ws");
@@ -226,46 +19,14 @@ async function importWebSocketServer(): Promise<any> {
   }
 }
 
-/**
- * Creates a Vite plugin for integrating RPG-JS server functionality
- *
- * This plugin configures the development server to automatically start
- * an RPG-JS server instance when Vite's dev server starts. It handles
- * the instantiation and initialization of the server module, and sets up
- * HTTP request and WebSocket connection forwarding to the RPG-JS server.
- *
- * The plugin intercepts:
- * - HTTP requests to `/parties/*` paths and forwards them to the RPG-JS server
- * - WebSocket upgrade requests and establishes connections with the RPG-JS server
- *
- * @param {new () => RpgServerEngine} serverModule - A class constructor that extends RpgServerEngine
- * @returns {Object} Vite plugin configuration object
- *
- * @example
- * ```typescript
- * // In vite.config.ts
- * import { serverPlugin } from '@rpgjs/vite';
- * import startServer from './src/server';
- *
- * export default defineConfig({
- *   plugins: [
- *     serverPlugin(startServer)
- *   ]
- * });
- * ```
- */
-export function serverPlugin(
-  serverModule: new (room: Room) => RpgServerEngine
-) {
-  let wsServer: WSServer | null = null;
-  let rooms: Map<string, Room> = new Map();
-  let servers: Map<string, RpgServerEngine> = new Map();
+export function serverPlugin(serverModule: RpgTransportServerConstructor) {
+  let wsServer: RpgWebSocketServer | null = null;
+  const transport = createRpgServerTransport(serverModule);
 
   return {
     name: "server-plugin",
 
     async configureServer(server: ViteDevServer) {
-      // Dynamic import of WebSocketServer to avoid compatibility issues
       try {
         const WebSocketServerClass = await importWebSocketServer();
         if (WebSocketServerClass) {
@@ -281,203 +42,22 @@ export function serverPlugin(
         wsServer = null;
       }
 
-      console.log('RPG-JS server plugin initialized');
+      console.log("RPG-JS server plugin initialized");
+      logNetworkSimulationStatus();
 
-      // HTTP request interception for /parties/* routes
       server.middlewares.use("/parties", async (req, res, next) => {
-        try {
-          // For now, pass to the next middleware
-          // The RPG-JS server handles its own routes via @signe/room
-          console.log(`RPG-JS HTTP request: ${req.method} ${req.url}`);
-
-          // Create a basic response for test routes
-          if (req.url?.includes("/test")) {
-            res.statusCode = 200;
-            res.setHeader("Content-Type", "application/json");
-            res.end(
-              JSON.stringify({
-                message: "RPG-JS server is running",
-                timestamp: new Date().toISOString(),
-              })
-            );
-            return;
-          }
-
-          next();
-        } catch (error) {
-          console.error("Error handling RPG-JS request:", error);
-          res.statusCode = 500;
-          res.end(JSON.stringify({ error: "Internal server error" }));
-        }
+        await transport.handleNodeRequest(req, res, next, {
+          mountedPath: "/parties",
+        });
       });
-      // WebSocket upgrade handling (if available)
-      if (wsServer) {
-        server.httpServer?.on(
-          "upgrade",
-          (request: IncomingMessage, socket: Duplex, head: Buffer) => {
-            const url = new URL(request.url!, `http://${request.headers.host}`);
-
-            // Check if it's a WebSocket connection for RPG-JS
-            if (url.pathname.startsWith("/parties/")) {
-              console.log(`WebSocket upgrade request: ${url.pathname}`);
 
-              wsServer!.handleUpgrade(
-                request,
-                socket,
-                head,
-                async (ws: WSConnection) => {
-                  try {
-                    // Extract room name from URL: /parties/main/lobby-1 -> lobby-1
-                    const pathParts = url.pathname.split("/");
-                    const roomName = pathParts[pathParts.length - 1]; // Get the last part (lobby-1)
-
-                    // Extract query parameters (like _pk)
-                    const queryParams = Object.fromEntries(
-                      url.searchParams.entries()
-                    );
-                    console.log(
-                      `Room: ${roomName}, Query params:`,
-                      queryParams
-                    );
-
-                    // Get or create the room
-                    let room = rooms.get(roomName);
-                    if (!room) {
-                      room = new Room(roomName);
-                      rooms.set(roomName, room);
-                      console.log(`Created new room: ${roomName}`);
-                    }
-
-                    // Get or create the server for this room
-                    let rpgServer = servers.get(roomName);
-                    if (!rpgServer) {
-                      rpgServer = new serverModule(room);
-                      servers.set(roomName, rpgServer);
-                      console.log(`Created new server instance for room: ${roomName}`);
-                      
-                      // Call onStart on the new server instance
-                      if (typeof rpgServer.onStart === "function") {
-                        try {
-                          await rpgServer.onStart();
-                          console.log(`Server started for room: ${roomName}`);
-                        } catch (error) {
-                          console.error(`Error starting server for room ${roomName}:`, error);
-                        }
-                      }
-                    }
-
-                    // Create a connection instance
-                    const connection = new PartyConnection(
-                      ws,
-                      undefined,
-                      request.url
-                    );
-
-                    // Add connection to the room
-                    room.addConnection(connection);
-
-                    console.log(
-                      `WebSocket connection established: ${connection.id} in room: ${roomName}`
-                    );
-
-                    // Set up WebSocket event handlers
-                    ws.on("message", async (data: Buffer) => {
-                      try {
-                        const message = data.toString();
-                        // Call onMessage on the RPG-JS server
-                        if (typeof rpgServer.onMessage === "function") {
-                          await rpgServer.onMessage(message, connection as any);
-                        }
-                      } catch (error) {
-                        console.error(
-                          "Error processing WebSocket message:",
-                          error
-                        );
-                      }
-                    });
-
-                    ws.on("close", async () => {
-                      console.log(
-                        `WebSocket connection closed: ${connection.id} from room: ${roomName}`
-                      );
-                      // Remove connection from room
-                      room.removeConnection(connection.id);
-                      // Call onClose on the RPG-JS server
-                      if (typeof rpgServer.onClose === "function") {
-                        await rpgServer.onClose(connection as any);
-                      }
-                    });
-
-                    ws.on("error", async (error: Error) => {
-                      console.error("WebSocket error:", error);
-                      // Remove connection from room
-                      room.removeConnection(connection.id);
-                      // Call onClose on the RPG-JS server
-                      if (typeof rpgServer.onClose === "function") {
-                        await rpgServer.onClose(connection as any);
-                      }
-                    });
-
-                    // Call onConnect on the RPG-JS server if the method exists
-                    if (typeof rpgServer.onConnect === "function") {
-                      // Create a compatible connection context with Headers-like interface
-                      const headers = new Map();
-                      if (request.headers) {
-                        Object.entries(request.headers).forEach(
-                          ([key, value]) => {
-                            headers.set(
-                              key.toLowerCase(),
-                              Array.isArray(value) ? value[0] : value
-                            );
-                          }
-                        );
-                      }
-
-                      const connectionContext = {
-                        request: {
-                          headers: {
-                            has: (name: string) =>
-                              headers.has(name.toLowerCase()),
-                            get: (name: string) =>
-                              headers.get(name.toLowerCase()),
-                            entries: () => headers.entries(),
-                            keys: () => headers.keys(),
-                            values: () => headers.values(),
-                          },
-                          url: request.url,
-                          method: request.method,
-                        },
-                        url: url,
-                      };
-                      await rpgServer.onConnect(
-                        connection as any,
-                        connectionContext as any
-                      );
-                    }
-
-                    // Send connection confirmation
-                    connection.send({
-                      type: "connected",
-                      id: connection.id,
-                      message: "Connected to RPG-JS server",
-                    });
-                  } catch (error) {
-                    console.error(
-                      "Error establishing WebSocket connection:",
-                      error
-                    );
-                    ws.close();
-                  }
-                }
-              );
-            }
-          }
-        );
+      if (wsServer) {
+        server.httpServer?.on("upgrade", (request, socket, head) => {
+          void transport.handleUpgrade(wsServer!, request, socket, head);
+        });
       }
 
-      console.log(
-        "RPG-JS server plugin configured with HTTP and WebSocket forwarding"
-      );
+      console.log("RPG-JS server plugin configured with HTTP and WebSocket forwarding !");
     },
 
     buildStart() {
@@ -485,7 +65,6 @@ export function serverPlugin(
     },
 
     buildEnd() {
-      // Cleanup when server stops
       if (wsServer) {
         wsServer.close();
       }

package/tests/latency-simulation.spec.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+// Mock the PartyConnection class for testing
+class MockPartyConnection {
+  public static latencyEnabled: boolean = false;
+  public static latencyMinMs: number = 50;
+  public static latencyMaxMs: number = 200;
+  public static latencyFilter: string = '';
+
+  public id: string;
+  private ws: any;
+
+  constructor(ws: any, id?: string) {
+    this.ws = ws;
+    this.id = id || 'test-connection';
+  }
+
+  async send(data: any): Promise<void> {
+    if (this.ws.readyState === 1) {
+      const message = typeof data === "string" ? data : JSON.stringify(data);
+      
+      // Check if latency simulation is enabled
+      if (MockPartyConnection.latencyEnabled && MockPartyConnection.latencyMaxMs > 0) {
+        // Apply filter if specified
+        if (MockPartyConnection.latencyFilter && !message.includes(MockPartyConnection.latencyFilter)) {
+          this.ws.send(message);
+          return;
+        }
+        
+        // Calculate random latency between min and max
+        const latencyMs = Math.random() * (MockPartyConnection.latencyMaxMs - MockPartyConnection.latencyMinMs) + MockPartyConnection.latencyMinMs;
+        
+        // Delay the message
+        await new Promise(resolve => setTimeout(resolve, latencyMs));
+      }
+      
+      this.ws.send(message);
+    }
+  }
+
+  static configureLatency(enabled: boolean, minMs: number, maxMs: number, filter?: string): void {
+    MockPartyConnection.latencyEnabled = enabled;
+    MockPartyConnection.latencyMinMs = Math.max(0, minMs);
+    MockPartyConnection.latencyMaxMs = Math.max(MockPartyConnection.latencyMinMs, maxMs);
+    MockPartyConnection.latencyFilter = filter || '';
+  }
+
+  static getLatencyStatus(): { enabled: boolean; minMs: number; maxMs: number; filter: string } {
+    return {
+      enabled: MockPartyConnection.latencyEnabled,
+      minMs: MockPartyConnection.latencyMinMs,
+      maxMs: MockPartyConnection.latencyMaxMs,
+      filter: MockPartyConnection.latencyFilter
+    };
+  }
+}
+
+describe('Latency Simulation', () => {
+  let mockWs: any;
+
+  beforeEach(() => {
+    // Reset latency settings before each test
+    MockPartyConnection.configureLatency(false, 0, 0);
+    
+    // Create mock WebSocket
+    mockWs = {
+      readyState: 1, // WebSocket.OPEN
+      send: vi.fn(),
+      close: vi.fn()
+    };
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Configuration', () => {
+    it('should configure latency settings correctly', () => {
+      MockPartyConnection.configureLatency(true, 100, 300, 'sync');
+      
+      const status = MockPartyConnection.getLatencyStatus();
+      expect(status.enabled).toBe(true);
+      expect(status.minMs).toBe(100);
+      expect(status.maxMs).toBe(300);
+      expect(status.filter).toBe('sync');
+    });
+
+    it('should clamp minMs to 0', () => {
+      MockPartyConnection.configureLatency(true, -50, 200);
+      
+      const status = MockPartyConnection.getLatencyStatus();
+      expect(status.minMs).toBe(0);
+    });
+
+    it('should ensure maxMs is at least minMs', () => {
+      MockPartyConnection.configureLatency(true, 200, 100);
+      
+      const status = MockPartyConnection.getLatencyStatus();
+      expect(status.maxMs).toBe(200); // Should be set to minMs value
+    });
+
+    it('should disable latency when enabled is false', () => {
+      MockPartyConnection.configureLatency(false, 100, 300);
+      
+      const status = MockPartyConnection.getLatencyStatus();
+      expect(status.enabled).toBe(false);
+    });
+  });
+
+  describe('Message Sending', () => {
+    it('should send message immediately when latency is disabled', async () => {
+      const connection = new MockPartyConnection(mockWs);
+      const startTime = Date.now();
+      
+      await connection.send('test message');
+      
+      const endTime = Date.now();
+      expect(mockWs.send).toHaveBeenCalledWith('test message');
+      expect(endTime - startTime).toBeLessThan(10); // Should be almost immediate
+    });
+
+    it('should delay message when latency is enabled', async () => {
+      MockPartyConnection.configureLatency(true, 50, 100);
+      const connection = new MockPartyConnection(mockWs);
+      const startTime = Date.now();
+      
+      await connection.send('test message');
+      
+      const endTime = Date.now();
+      expect(mockWs.send).toHaveBeenCalledWith('test message');
+      expect(endTime - startTime).toBeGreaterThanOrEqual(50);
+      expect(endTime - startTime).toBeLessThanOrEqual(150); // Allow some buffer
+    });
+
+    it('should apply filter correctly', async () => {
+      MockPartyConnection.configureLatency(true, 50, 100, 'sync');
+      const connection = new MockPartyConnection(mockWs);
+      
+      // Message with filter should be delayed
+      const startTime1 = Date.now();
+      await connection.send('sync message');
+      const endTime1 = Date.now();
+      expect(endTime1 - startTime1).toBeGreaterThanOrEqual(50);
+      
+      // Message without filter should be sent immediately
+      const startTime2 = Date.now();
+      await connection.send('normal message');
+      const endTime2 = Date.now();
+      expect(endTime2 - startTime2).toBeLessThan(10);
+    });
+
+    it('should not send when WebSocket is not open', async () => {
+      mockWs.readyState = 3; // WebSocket.CLOSED
+      const connection = new MockPartyConnection(mockWs);
+      
+      await connection.send('test message');
+      
+      expect(mockWs.send).not.toHaveBeenCalled();
+    });
+
+    it('should handle JSON data correctly', async () => {
+      const connection = new MockPartyConnection(mockWs);
+      const testData = { type: 'test', value: 123 };
+      
+      await connection.send(testData);
+      
+      expect(mockWs.send).toHaveBeenCalledWith(JSON.stringify(testData));
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle zero latency range', async () => {
+      MockPartyConnection.configureLatency(true, 0, 0);
+      const connection = new MockPartyConnection(mockWs);
+      const startTime = Date.now();
+      
+      await connection.send('test message');
+      
+      const endTime = Date.now();
+      expect(mockWs.send).toHaveBeenCalledWith('test message');
+      expect(endTime - startTime).toBeLessThan(10); // Should be immediate
+    });
+
+    it('should handle very high latency', async () => {
+      MockPartyConnection.configureLatency(true, 1000, 2000);
+      const connection = new MockPartyConnection(mockWs);
+      const startTime = Date.now();
+      
+      await connection.send('test message');
+      
+      const endTime = Date.now();
+      expect(mockWs.send).toHaveBeenCalledWith('test message');
+      expect(endTime - startTime).toBeGreaterThanOrEqual(1000);
+      expect(endTime - startTime).toBeLessThanOrEqual(2100); // Allow buffer
+    });
+
+    it('should handle empty filter string', async () => {
+      MockPartyConnection.configureLatency(true, 50, 100, '');
+      const connection = new MockPartyConnection(mockWs);
+      const startTime = Date.now();
+      
+      await connection.send('test message');
+      
+      const endTime = Date.now();
+      expect(mockWs.send).toHaveBeenCalledWith('test message');
+      expect(endTime - startTime).toBeGreaterThanOrEqual(50); // Should still be delayed
+    });
+  });
+});