@gravito/ripple 4.0.0 → 4.0.1

package/dist/index.js

@@ -745,7 +745,7 @@ var require_writer = __commonJS((exports, module) => {
     this.tail = this.head;
     this.states = null;
   }
-  var create = function create() {
+  var create = function create2() {
     return util.Buffer ? function create_buffer_setup() {
       return (Writer.create = function create_buffer() {
         return new BufferWriter;
@@ -969,12 +969,12 @@ var require_reader = __commonJS((exports, module) => {
     if (buffer instanceof Uint8Array || Array.isArray(buffer))
       return new Reader(buffer);
     throw Error("illegal buffer");
-  } : function create_array(buffer) {
+  } : function create_array2(buffer) {
     if (Array.isArray(buffer))
       return new Reader(buffer);
     throw Error("illegal buffer");
   };
-  var create = function create() {
+  var create = function create2() {
     return util.Buffer ? function create_buffer_setup(buffer) {
       return (Reader.create = function create_buffer(buffer2) {
         return util.Buffer.isBuffer(buffer2) ? new BufferReader(buffer2) : create_array(buffer2);
@@ -1400,10 +1400,10 @@ var require_fetch = __commonJS((exports, module) => {
 // ../../node_modules/.bun/@protobufjs+path@1.1.2/node_modules/@protobufjs/path/index.js
 var require_path = __commonJS((exports) => {
   var path = exports;
-  var isAbsolute = path.isAbsolute = function isAbsolute(path2) {
+  var isAbsolute = path.isAbsolute = function isAbsolute2(path2) {
     return /^(?:\/|\w+:)/.test(path2);
   };
-  var normalize = path.normalize = function normalize(path2) {
+  var normalize = path.normalize = function normalize2(path2) {
     path2 = path2.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
     var parts = path2.split("/"), absolute = isAbsolute(path2), prefix = "";
     if (absolute)
@@ -5302,8 +5302,9 @@ class NATSDriver {
     return this._initialized;
   }
   async init() {
-    if (this._initialized)
+    if (this._initialized) {
       return;
+    }
     this.logger.info("Initializing NATSDriver", {
       servers: this.config.servers ?? "nats://localhost:4222"
     });
@@ -5957,7 +5958,7 @@ class BunEngine {
       hostname: this.config.hostname,
       tls: this.config.tls,
       development: this.config.development,
-      fetch: (req, server) => {
+      fetch: (_req, _server) => {
         return new Response("WebSocket endpoint. Use upgrade() to connect.", { status: 404 });
       },
       websocket: {
@@ -5968,19 +5969,21 @@ class BunEngine {
         },
         message: (ws, message) => {
           const socket = this.sockets.get(ws.data.id);
-          if (!socket)
+          if (!socket) {
             return;
+          }
           const data = typeof message === "string" ? message : message instanceof Buffer ? new Uint8Array(message.buffer, message.byteOffset, message.byteLength) : new Uint8Array(message);
           this.messageHandler?.(socket, data);
         },
         close: (ws, code, reason) => {
           const socket = this.sockets.get(ws.data.id);
-          if (!socket)
+          if (!socket) {
             return;
+          }
           this.disconnectionHandler?.(socket, code, reason);
           this.sockets.delete(ws.data.id);
         },
-        drain: (ws) => {}
+        drain: (_ws) => {}
       }
     });
   }
@@ -5992,8 +5995,9 @@ class BunEngine {
     this.sockets.clear();
   }
   broadcast(topic, data, excludeSocketId) {
-    if (!this.server)
+    if (!this.server) {
       return;
+    }
     if (excludeSocketId) {
       for (const [id, socket] of this.sockets) {
         if (id !== excludeSocketId && socket.raw.isSubscribed(topic)) {
@@ -6025,6 +6029,324 @@ class BunEngine {
   }
 }
 
+// src/engines/UWebSocketsEngine.ts
+import { randomUUID } from "crypto";
+
+class UWebSocketsRippleSocket {
+  ws;
+  constructor(ws) {
+    this.ws = ws;
+  }
+  get id() {
+    return this.ws.getUserData().id;
+  }
+  get data() {
+    return this.ws.getUserData();
+  }
+  send(data, compress) {
+    if (typeof data === "string") {
+      this.ws.send(data, false, compress);
+    } else {
+      const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+      this.ws.send(buffer, true, compress);
+    }
+  }
+  close(_code, _reason) {
+    this.ws.close();
+  }
+  getBufferedAmount() {
+    return this.ws.getBufferedAmount();
+  }
+  subscribe(topic) {
+    this.ws.subscribe(topic);
+  }
+  unsubscribe(topic) {
+    this.ws.unsubscribe(topic);
+  }
+  publish(topic, data) {
+    if (typeof data === "string") {
+      this.ws.publish(topic, data, false);
+    } else {
+      const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+      this.ws.publish(topic, buffer, true);
+    }
+  }
+  get raw() {
+    return this.ws;
+  }
+}
+
+class UWebSocketsEngine {
+  config;
+  name = "node-uws";
+  app;
+  uws;
+  connectionHandler;
+  disconnectionHandler;
+  messageHandler;
+  sockets = new Map;
+  listenSocket;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  onConnection(handler) {
+    this.connectionHandler = handler;
+  }
+  onDisconnection(handler) {
+    this.disconnectionHandler = handler;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  async listen(port) {
+    try {
+      this.uws = await import("uWebSockets.js");
+    } catch (_error) {
+      throw new Error("uWebSockets.js is not installed. Install it with: npm install uWebSockets.js@uNetworking/uWebSockets.js#v20.44.0");
+    }
+    if (!this.uws) {
+      throw new Error("Failed to load uWebSockets.js module");
+    }
+    this.app = this.config.tls ? this.uws.App({
+      cert_file_name: this.config.tls.cert,
+      key_file_name: this.config.tls.key
+    }) : this.uws.App();
+    this.app.ws("/*", {
+      compression: this.config.compression ?? this.uws.SHARED_COMPRESSOR,
+      maxPayloadLength: this.config.maxPayloadLength ?? 16777216,
+      idleTimeout: this.config.idleTimeout ?? 120,
+      maxBackpressure: this.config.maxBackpressure ?? 1048576,
+      open: (ws) => {
+        const data = ws.getUserData();
+        const id = randomUUID();
+        Object.assign(data, {
+          id,
+          channels: new Set,
+          remoteAddress: undefined
+        });
+        const socket = new UWebSocketsRippleSocket(ws);
+        this.sockets.set(socket.id, socket);
+        this.connectionHandler?.(socket);
+      },
+      message: (ws, message, isBinary) => {
+        const data = ws.getUserData();
+        const socket = this.sockets.get(data.id);
+        if (!socket) {
+          return;
+        }
+        const payload = isBinary ? new Uint8Array(message) : new TextDecoder().decode(message);
+        this.messageHandler?.(socket, payload);
+      },
+      drain: (ws) => {
+        if (this.config.development) {
+          const buffered = ws.getBufferedAmount();
+          if (buffered > 0) {
+            console.log(`[uWS] Draining backpressure: ${buffered} bytes`);
+          }
+        }
+      },
+      close: (ws, code, message) => {
+        const data = ws.getUserData();
+        const socket = this.sockets.get(data.id);
+        if (!socket) {
+          return;
+        }
+        const reason = new TextDecoder().decode(message);
+        this.disconnectionHandler?.(socket, code, reason);
+        this.sockets.delete(data.id);
+      }
+    });
+    return new Promise((resolve, reject) => {
+      this.app?.listen(port, (listenSocket) => {
+        if (listenSocket) {
+          this.listenSocket = listenSocket;
+          resolve();
+        } else {
+          reject(new Error(`Failed to listen on port ${port}`));
+        }
+      });
+    });
+  }
+  async close() {
+    for (const socket of this.sockets.values()) {
+      socket.close();
+    }
+    this.sockets.clear();
+    if (this.listenSocket && this.uws) {
+      this.listenSocket = undefined;
+    }
+    this.app = undefined;
+  }
+  broadcast(topic, data, excludeSocketId) {
+    if (!this.app) {
+      throw new Error("Engine not started. Call listen() first.");
+    }
+    if (excludeSocketId) {
+      for (const socket of this.sockets.values()) {
+        if (socket.id !== excludeSocketId) {
+          socket.send(data);
+        }
+      }
+    } else {
+      if (typeof data === "string") {
+        this.app.publish(topic, data, false);
+      } else {
+        const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+        this.app.publish(topic, buffer, true);
+      }
+    }
+  }
+  getConnectedSockets() {
+    return Array.from(this.sockets.values());
+  }
+  getSocket(id) {
+    return this.sockets.get(id);
+  }
+  upgrade(_req, _data) {
+    throw new Error("upgrade() is not supported in uWebSocketsEngine. Use the ws() route instead.");
+  }
+}
+
+// src/engines/WsEngine.ts
+import { WebSocketServer } from "ws";
+
+class WsRippleSocket {
+  ws;
+  clientData;
+  engine;
+  constructor(ws, clientData, engine) {
+    this.ws = ws;
+    this.clientData = clientData;
+    this.engine = engine;
+  }
+  get id() {
+    return this.clientData.id;
+  }
+  get data() {
+    return this.clientData;
+  }
+  send(data, compress) {
+    this.ws.send(data, { compress });
+  }
+  close(code, reason) {
+    this.ws.close(code, reason);
+  }
+  getBufferedAmount() {
+    return this.ws.bufferedAmount;
+  }
+  subscribe(topic) {
+    this.engine.subscribe(this.id, topic);
+  }
+  unsubscribe(topic) {
+    this.engine.unsubscribe(this.id, topic);
+  }
+  publish(topic, data) {
+    this.engine.broadcast(topic, data);
+  }
+  get raw() {
+    return this.ws;
+  }
+}
+
+class WsEngine {
+  config;
+  name = "node-ws";
+  wss;
+  connectionHandler;
+  disconnectionHandler;
+  messageHandler;
+  sockets = new Map;
+  subscriptions = new Map;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  onConnection(handler) {
+    this.connectionHandler = handler;
+  }
+  onDisconnection(handler) {
+    this.disconnectionHandler = handler;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  async listen(port) {
+    this.wss = new WebSocketServer({
+      port,
+      host: this.config.hostname,
+      path: this.config.path
+    });
+    this.wss.on("connection", (ws, req) => {
+      const clientData = {
+        id: crypto.randomUUID(),
+        remoteAddress: req.socket.remoteAddress,
+        channels: new Set
+      };
+      const socket = new WsRippleSocket(ws, clientData, this);
+      this.sockets.set(socket.id, socket);
+      ws.on("message", (data, isBinary) => {
+        let payload;
+        if (isBinary) {
+          payload = data instanceof Uint8Array ? data : new Uint8Array(data);
+        } else {
+          payload = data.toString();
+        }
+        this.messageHandler?.(socket, payload);
+      });
+      ws.on("close", (code, reason) => {
+        this.cleanupSocket(socket.id);
+        this.sockets.delete(socket.id);
+        this.disconnectionHandler?.(socket, code, reason.toString());
+      });
+      this.connectionHandler?.(socket);
+    });
+    return new Promise((resolve) => {
+      this.wss?.once("listening", () => resolve());
+    });
+  }
+  async close() {
+    return new Promise((resolve, reject) => {
+      if (!this.wss) {
+        return resolve();
+      }
+      this.wss.close((err) => {
+        if (err) {
+          return reject(err);
+        }
+        this.sockets.clear();
+        this.subscriptions.clear();
+        resolve();
+      });
+    });
+  }
+  subscribe(socketId, topic) {
+    if (!this.subscriptions.has(topic)) {
+      this.subscriptions.set(topic, new Set);
+    }
+    this.subscriptions.get(topic)?.add(socketId);
+  }
+  unsubscribe(socketId, topic) {
+    this.subscriptions.get(topic)?.delete(socketId);
+  }
+  cleanupSocket(socketId) {
+    for (const subscribers of this.subscriptions.values()) {
+      subscribers.delete(socketId);
+    }
+  }
+  broadcast(topic, data, excludeSocketId) {
+    const subscribers = this.subscriptions.get(topic);
+    if (!subscribers) {
+      return;
+    }
+    for (const socketId of subscribers) {
+      if (socketId === excludeSocketId) {
+        continue;
+      }
+      const socket = this.sockets.get(socketId);
+      socket?.send(data);
+    }
+  }
+}
+
 // src/middleware/InterceptorManager.ts
 class InterceptorManager {
   interceptors;
@@ -6073,7 +6395,7 @@ class RippleMetrics {
   export() {
     const activeConnections = this.tracker.getActiveConnections();
     const pendingAcks = this.ackManager?.getPendingCount() ?? 0;
-    return [
+    return `${[
       `# HELP ${this.prefix}_connections_active Currently active WebSocket connections`,
       `# TYPE ${this.prefix}_connections_active gauge`,
       `${this.prefix}_connections_active ${activeConnections}`,
@@ -6084,7 +6406,7 @@ class RippleMetrics {
       `# TYPE ${this.prefix}_slow_clients_total counter`,
       `${this.prefix}_slow_clients_total ${this.slowClients}`
     ].join(`
-`) + `
+`)}
 `;
   }
 }
@@ -6185,14 +6507,14 @@ var ClientMessageProto = null;
 var ServerMessageProto = null;
 
 class ProtobufSerializer {
-  protoPath;
+  options;
   contentType = "protobuf";
   broadcastCache = null;
   initialized = false;
-  constructor(protoPath) {
-    this.protoPath = protoPath;
-    if (!protoPath) {
-      this.protoPath = this.resolveProtoPath();
+  constructor(options = {}) {
+    this.options = options;
+    if (!options.protoPath) {
+      this.options.protoPath = this.resolveProtoPath();
     }
   }
   resolveProtoPath() {
@@ -6214,11 +6536,12 @@ class ProtobufSerializer {
     return join(__dirname2, "../proto/ripple.proto");
   }
   async init() {
-    if (this.initialized)
+    if (this.initialized) {
       return;
+    }
     try {
-      if (!existsSync(this.protoPath)) {
-        throw new Error(`Proto file not found at: ${this.protoPath}
+      if (!existsSync(this.options.protoPath)) {
+        throw new Error(`Proto file not found at: ${this.options.protoPath}
 ` + `Working directory: ${process.cwd()}
 ` + `Please ensure ripple.proto exists or provide a custom protoPath.`);
       }
@@ -6230,13 +6553,13 @@ class ProtobufSerializer {
 Install it with: npm install protobufjs
 Or use JSON serializer instead: new RippleServer({ serializer: 'json' })`);
       }
-      protoRoot = await protobuf.load(this.protoPath);
+      protoRoot = await protobuf.load(this.options.protoPath);
       ClientMessageProto = protoRoot.lookupType("ripple.ClientMessage");
       ServerMessageProto = protoRoot.lookupType("ripple.ServerMessage");
       this.initialized = true;
     } catch (error) {
       throw new Error(`Failed to initialize ProtobufSerializer: ${error.message}
-Proto path attempted: ${this.protoPath}
+Proto path attempted: ${this.options.protoPath}
 Ensure 'protobufjs' is installed or switch to JSON serializer.`);
     }
   }
@@ -6244,8 +6567,9 @@ Ensure 'protobufjs' is installed or switch to JSON serializer.`);
     this.checkInitialized();
     const payload = this.toProtoPayload(message);
     const errMsg = ServerMessageProto.verify(payload);
-    if (errMsg)
+    if (errMsg) {
       throw Error(errMsg);
+    }
     const msg = ServerMessageProto.create(payload);
     return ServerMessageProto.encode(msg).finish();
   }
@@ -6256,7 +6580,7 @@ Ensure 'protobufjs' is installed or switch to JSON serializer.`);
     const obj = ClientMessageProto.toObject(decoded, {
       enums: String,
       longs: String,
-      bytes: String,
+      bytes: this.options.pure ? undefined : String,
       defaults: true,
       oneofs: true
     });
@@ -6341,8 +6665,9 @@ Ensure 'protobufjs' is installed or switch to JSON serializer.`);
         } : undefined
       };
     }
-    if (obj.unsubscribe)
+    if (obj.unsubscribe) {
       return { type: "unsubscribe", channel: obj.unsubscribe.channel };
+    }
     if (obj.whisper) {
       return {
         type: "whisper",
@@ -6351,10 +6676,12 @@ Ensure 'protobufjs' is installed or switch to JSON serializer.`);
         data: this.decodeData(obj.whisper.data)
       };
     }
-    if (obj.ping)
+    if (obj.ping) {
       return { type: "ping" };
-    if (obj.ack)
+    }
+    if (obj.ack) {
       return { type: "ack", seq: obj.ack.seq };
+    }
     if (obj.binary) {
       return {
         type: "binary",
@@ -6366,13 +6693,30 @@ Ensure 'protobufjs' is installed or switch to JSON serializer.`);
     throw new Error("Unknown client message payload");
   }
   encodeData(data) {
-    if (typeof data === "string")
+    if (this.options.pure) {
+      if (data instanceof Uint8Array) {
+        return data;
+      }
+      if (Object.prototype.toString.call(data) === "[object Uint8Array]") {
+        return data;
+      }
+      if (Buffer.isBuffer(data)) {
+        return data;
+      }
+      throw new Error("In pure mode, data must be Uint8Array or Buffer");
+    }
+    if (typeof data === "string") {
       return new TextEncoder().encode(data);
-    if (data instanceof Uint8Array)
+    }
+    if (data instanceof Uint8Array) {
       return data;
+    }
     return new TextEncoder().encode(JSON.stringify(data));
   }
   decodeData(data) {
+    if (this.options.pure) {
+      return data;
+    }
     if (typeof data === "string") {
       try {
         return JSON.parse(atob(data));
@@ -6605,7 +6949,7 @@ class RippleServer {
     this.authorizer = config.authorizer;
     this.tracker = config.connectionTracker ?? new DefaultConnectionTracker(this.logger);
     this.healthChecker = new HealthChecker(this, this.driver);
-    this.serializer = config.serializer === "protobuf" ? new ProtobufSerializer : new JsonSerializer;
+    this.serializer = config.serializer === "protobuf" ? new ProtobufSerializer(config.serializerOptions) : new JsonSerializer;
     if (config.reconnection?.enabled) {
       this.sessionManager = new SessionManager({
         sessionTTL: config.reconnection.sessionTTL ?? 60000,
@@ -6630,6 +6974,19 @@ class RippleServer {
           hostname: config.hostname,
           development: true
         });
+      case "node-uws":
+        return new UWebSocketsEngine({
+          port: config.port,
+          hostname: config.hostname,
+          development: true
+        });
+      case "node-ws":
+        return new WsEngine({
+          port: config.port,
+          hostname: config.hostname,
+          path: config.path,
+          development: true
+        });
       default:
         throw new Error(`Unsupported runtime: ${runtime}`);
     }
@@ -6787,12 +7144,14 @@ class RippleServer {
   }
   async handleBinaryMessage(ws, message) {
     const buffer = message;
-    if (buffer.length < 4)
+    if (buffer.length < 4) {
       return;
+    }
     const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
     const headerLength = view.getInt32(0, true);
-    if (buffer.length < 4 + headerLength)
+    if (buffer.length < 4 + headerLength) {
       return;
+    }
     try {
       const headerBytes = buffer.subarray(4, 4 + headerLength);
       const headerRaw = new TextDecoder().decode(headerBytes);
@@ -6818,8 +7177,9 @@ class RippleServer {
   }
   broadcastBinaryToChannel(channel, event, data, excludeClientId) {
     const subscribers = this.channels.getSubscribers(channel);
-    if (subscribers.length === 0)
+    if (subscribers.length === 0) {
       return;
+    }
     const header = JSON.stringify({ type: "binary", channel, event });
     const headerBuffer = Buffer.from(header);
     const totalBuffer = Buffer.allocUnsafe(4 + headerBuffer.length + data.byteLength);
@@ -6827,8 +7187,9 @@ class RippleServer {
     headerBuffer.copy(totalBuffer, 4);
     Buffer.from(data).copy(totalBuffer, 4 + headerBuffer.length);
     for (const ws of subscribers) {
-      if (excludeClientId && ws.data.id === excludeClientId)
+      if (excludeClientId && ws.data.id === excludeClientId) {
         continue;
+      }
       ws.send(totalBuffer);
     }
   }
@@ -6871,7 +7232,6 @@ class RippleServer {
     }
     this.ackManager.clearClient(ws.data.id);
   }
-  handleDrain(_ws) {}
   async handleSubscribe(ws, channel, _auth) {
     if (requiresAuth(channel)) {
       if (!this.authorizer) {
@@ -6956,8 +7316,9 @@ class RippleServer {
   }
   broadcastToChannel(channel, event, data, excludeClientId, options) {
     const subscribers = this.channels.getSubscribers(channel);
-    if (subscribers.length === 0)
+    if (subscribers.length === 0) {
       return;
+    }
     const message = event === "presence" ? {
       type: "presence",
       channel,
@@ -6966,8 +7327,9 @@ class RippleServer {
     } : { type: "event", channel, event, data };
     const serialized = this.serializer.serializeForBroadcast(message);
     for (const ws of subscribers) {
-      if (excludeClientId && ws.data.id === excludeClientId)
+      if (excludeClientId && ws.data.id === excludeClientId) {
         continue;
+      }
       this.interceptors.execute({ ws, message, direction: "outgoing", channel, event }, async () => {
         if (options?.needAck) {
           const { seq, promise } = this.ackManager.register(ws.data.id, options.timeout);
@@ -7071,8 +7433,9 @@ class RippleServer {
   }
   async shutdown() {
     this.logger.info("Shutting down RippleServer");
-    if (this.pingInterval)
+    if (this.pingInterval) {
       clearInterval(this.pingInterval);
+    }
     await this.driver.shutdown?.();
   }
 }
@@ -7166,4 +7529,4 @@ export {
   AckManager
 };
 
-//# debugId=7FB174B3B1EE198164756E2164756E21
+//# debugId=5BEEEDA722E6EBC364756E2164756E21