@colyseus/bun-websockets 0.17.0 → 0.17.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colyseus/bun-websockets",
-  "version": "0.17.0",
+  "version": "0.17.2",
   "type": "module",
   "input": "./src/index.ts",
   "main": "./build/index.js",
@@ -8,22 +8,24 @@
   "typings": "./build/index.d.ts",
   "exports": {
     ".": {
+      "@source": "./src/index.ts",
       "types": "./build/index.d.ts",
-      "import": "./src/index.ts",
+      "import": "./build/index.mjs",
       "require": "./build/index.js"
     },
     "./*": {
+      "@source": "./src/*.ts",
       "types": "./build/*.d.ts",
-      "import": "./src/*.ts",
+      "import": "./build/*.mjs",
       "require": "./build/*.js"
     }
   },
   "dependencies": {
-    "@colyseus/core": "^0.17.0"
+    "@colyseus/core": "^0.17.2"
   },
   "devDependencies": {
     "bun-types": "^1.2.0",
-    "@colyseus/core": "^0.17.0"
+    "@colyseus/core": "^0.17.2"
   },
   "author": "Endel Dreyer",
   "license": "MIT",
@@ -35,8 +37,7 @@
   ],
   "files": [
     "build",
-    "LICENSE",
-    "README.md"
+    "src"
   ],
   "repository": {
     "type": "git",

package/src/BunWebSockets.ts

@@ -0,0 +1,160 @@
+// <reference types="bun-types" />
+
+// "bun-types" is currently conflicting with "ws" types.
+// @ts-ignore
+import { ServerWebSocket, WebSocketHandler } from 'bun';
+
+// import bunExpress from 'bun-serve-express';
+import type { Application, Request, Response } from "express";
+
+import { HttpServerMock, matchMaker, Protocol, Transport, debugAndPrintError, getBearerToken, CloseCode, connectClientToRoom } from '@colyseus/core';
+import { WebSocketClient, WebSocketWrapper } from './WebSocketClient.ts';
+
+export type TransportOptions = Partial<Omit<WebSocketHandler, "message" | "open" | "drain" | "close" | "ping" | "pong">>;
+
+interface WebSocketData {
+  url: URL;
+  headers: any;
+}
+
+export class BunWebSockets extends Transport {
+  public expressApp: Application;
+
+  protected clients: ServerWebSocket<WebSocketData>[] = [];
+  protected clientWrappers = new WeakMap<ServerWebSocket<WebSocketData>, WebSocketWrapper>();
+
+  private _listening: any;
+  private _originalRawSend: typeof WebSocketClient.prototype.raw | null = null;
+  private options: TransportOptions = {};
+
+  constructor(options: TransportOptions = {}) {
+    super();
+
+    const self = this;
+
+    this.options = options;
+
+    // this.expressApp = bunExpress({
+    //   websocket: {
+    //     ...this.options,
+
+    //     async open(ws) {
+    //       await self.onConnection(ws);
+    //     },
+
+    //     message(ws, message) {
+    //       self.clientWrappers.get(ws)?.emit('message', message);
+    //     },
+
+    //     close(ws, code, reason) {
+    //       // remove from client list
+    //       spliceOne(self.clients, self.clients.indexOf(ws));
+
+    //       const clientWrapper = self.clientWrappers.get(ws);
+    //       if (clientWrapper) {
+    //         self.clientWrappers.delete(ws);
+
+    //         // emit 'close' on wrapper
+    //         clientWrapper.emit('close', code);
+    //       }
+    //     },
+    //   }
+    // });
+
+    // Adding a mock object for Transport.server
+    if (!this.server) {
+      // @ts-ignore
+      this.server = new HttpServerMock();
+    }
+  }
+
+  public listen(port: number, hostname?: string, backlog?: number, listeningListener?: () => void) {
+    this._listening = this.expressApp.listen(port, listeningListener);
+
+    this.expressApp.use(`/${matchMaker.controller.matchmakeRoute}`, async (req, res) => {
+      try {
+        // TODO: use shared handler here
+        // await this.handleMatchMakeRequest(req, res);
+      } catch (e: any) {
+        res.status(500).json({
+          code: e.code,
+          error: e.message
+        });
+      }
+    });
+
+    // Mocking Transport.server behaviour, https://github.com/colyseus/colyseus/issues/458
+    // @ts-ignore
+    this.server.emit("listening");
+
+    return this;
+  }
+
+  public shutdown() {
+    if (this._listening) {
+      this._listening.close();
+
+      // @ts-ignore
+      this.server.emit("close"); // Mocking Transport.server behaviour, https://github.com/colyseus/colyseus/issues/458
+    }
+  }
+
+  public simulateLatency(milliseconds: number) {
+    if (this._originalRawSend == null) {
+      this._originalRawSend = WebSocketClient.prototype.raw;
+    }
+
+    const originalRawSend = this._originalRawSend;
+    WebSocketClient.prototype.raw = milliseconds <= Number.EPSILON ? originalRawSend : function (...args: any[]) {
+      let [buf, ...rest] = args;
+      buf = Buffer.from(buf);
+      // @ts-ignore
+      setTimeout(() => originalRawSend.apply(this, [buf, ...rest]), milliseconds);
+    };
+  }
+
+  protected async onConnection(rawClient: ServerWebSocket<WebSocketData>) {
+    const wrapper = new WebSocketWrapper(rawClient);
+    // keep reference to client and its wrapper
+    this.clients.push(rawClient);
+    this.clientWrappers.set(rawClient, wrapper);
+
+    const parsedURL = new URL(rawClient.data.url);
+
+    const sessionId = parsedURL.searchParams.get("sessionId");
+    const processAndRoomId = parsedURL.pathname.match(/\/[a-zA-Z0-9_\-]+\/([a-zA-Z0-9_\-]+)$/);
+    const roomId = processAndRoomId && processAndRoomId[1];
+
+    // If sessionId is not provided, allow ping-pong utility.
+    if (!sessionId && !roomId) {
+      // Disconnect automatically after 1 second if no message is received.
+      const timeout = setTimeout(() => rawClient.close(CloseCode.NORMAL_CLOSURE), 1000);
+      wrapper.on('message', (_) => rawClient.send(new Uint8Array([Protocol.PING])));
+      wrapper.on('close', () => clearTimeout(timeout));
+      return;
+    }
+
+    const room = matchMaker.getLocalRoomById(roomId);
+    const client = new WebSocketClient(sessionId, wrapper);
+    const reconnectionToken = parsedURL.searchParams.get("reconnectionToken");
+    const skipHandshake = (parsedURL.searchParams.has("skipHandshake"));
+
+    try {
+      await connectClientToRoom(room, client, {
+        token: parsedURL.searchParams.get("_authToken") ?? getBearerToken(rawClient.data.headers['authorization']),
+        headers: rawClient.data.headers,
+        ip: rawClient.data.headers['x-real-ip'] ?? rawClient.data.headers['x-forwarded-for'] ?? rawClient.remoteAddress,
+      }, {
+        reconnectionToken,
+        skipHandshake
+      });
+
+    } catch (e: any) {
+      debugAndPrintError(e);
+
+      // send error code to client then terminate
+      client.error(e.code, e.message, () => rawClient.close());
+    }
+  }
+
+}

package/src/WebSocketClient.ts

@@ -0,0 +1,119 @@
+// <reference types="bun-types" />
+
+// "bun-types" is currently conflicting with "ws" types.
+// @ts-ignore
+import type { ServerWebSocket } from 'bun';
+import EventEmitter from 'events';
+
+import { Protocol, type Client, type ClientPrivate, ClientState, type ISendOptions, getMessageBytes, logger, debugMessage } from '@colyseus/core';
+
+export class WebSocketWrapper extends EventEmitter {
+  public ws: ServerWebSocket<any>;
+
+  constructor(ws: ServerWebSocket<any>) {
+    super();
+    this.ws = ws;
+  }
+}
+
+export class WebSocketClient implements Client, ClientPrivate {
+  '~messages': any;
+
+  public id: string;
+  public ref: WebSocketWrapper;
+
+  public sessionId: string;
+  public state: ClientState = ClientState.JOINING;
+  public reconnectionToken: string;
+
+  public _enqueuedMessages: any[] = [];
+  public _afterNextPatchQueue;
+  public _reconnectionToken: string;
+  public _joinedAt: number;
+
+  constructor(id: string, ref: WebSocketWrapper,) {
+    this.id = this.sessionId = id;
+    this.ref = ref;
+  }
+
+  public sendBytes(type: string | number, bytes: Buffer | Uint8Array, options?: ISendOptions) {
+    debugMessage("send bytes(to %s): '%s' -> %j", this.sessionId, type, bytes);
+
+    this.enqueueRaw(
+      getMessageBytes.raw(Protocol.ROOM_DATA_BYTES, type, undefined, bytes),
+      options,
+    );
+  }
+
+  public send(messageOrType: any, messageOrOptions?: any | ISendOptions, options?: ISendOptions) {
+    debugMessage("send(to %s): '%s' -> %j", this.sessionId, messageOrType, messageOrOptions);
+
+    this.enqueueRaw(
+      getMessageBytes.raw(Protocol.ROOM_DATA, messageOrType, messageOrOptions),
+      options,
+    );
+  }
+
+  public enqueueRaw(data: Uint8Array | Buffer, options?: ISendOptions) {
+    // use room's afterNextPatch queue
+    if (options?.afterNextPatch) {
+      this._afterNextPatchQueue.push([this, [data]]);
+      return;
+    }
+
+    if (this.state === ClientState.JOINING) {
+      // sending messages during `onJoin`.
+      // - the client-side cannot register "onMessage" callbacks at this point.
+      // - enqueue the messages to be send after JOIN_ROOM message has been sent
+      // - create a new buffer for enqueued messages, as the underlying buffer might be modified
+      this._enqueuedMessages.push(data);
+      return;
+    }
+
+    this.raw(data, options);
+  }
+
+  public raw(data: Uint8Array | Buffer, options?: ISendOptions, cb?: (err?: Error) => void) {
+    // skip if client not open
+
+    // WebSocket is globally available on Bun runtime
+    // @ts-ignore
+    if (this.ref.ws.readyState !== WebSocket.OPEN) {
+      return;
+    }
+
+    // FIXME: can we avoid creating a new buffer here?
+    this.ref.ws.sendBinary(data);
+  }
+
+  public error(code: number, message: string = '', cb?: (err?: Error) => void) {
+    this.raw(getMessageBytes[Protocol.ERROR](code, message));
+
+    if (cb) {
+      // (same API as "ws" transport)
+      setTimeout(cb, 1);
+    }
+  }
+
+  get readyState() {
+    return this.ref.ws.readyState;
+  }
+
+  public leave(code?: number, data?: string) {
+    this.ref.ws.close(code, data);
+  }
+
+  public close(code?: number, data?: string) {
+    logger.warn('DEPRECATION WARNING: use client.leave() instead of client.close()');
+    try {
+      throw new Error();
+    } catch (e: any) {
+      logger.info(e.stack);
+    }
+    this.leave(code, data);
+  }
+
+  public toJSON() {
+    return { sessionId: this.sessionId, readyState: this.readyState };
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { WebSocketClient } from './WebSocketClient.ts';
+export { BunWebSockets, type TransportOptions } from './BunWebSockets.ts';