playsocketjs 2.6.3 → 2.7.0

package/README.md

@@ -216,6 +216,26 @@ new PlaySocket(options: PlaySocketServerOptions)
 | `server` | http.Server | - | Existing http server (optional) |
 | `rateLimit` | number | 20 | Adjust the messages/second rate limit |
 | `debug` | boolean | false | Set to true to enable extra logging |
+| `verifyClient` | function | - | Optional callback to verify connections before WebSocket upgrade |
+
+#### verifyClient callback
+
+The `verifyClient` option allows you to implement custom connection verification logic, such as rate limiting, before the WebSocket handshake completes.
+
+```javascript
+const server = new PlaySocketServer({
+    server: httpServer,
+    path: '/socket',
+    verifyClient: (info, callback) => {
+        // info.req - the HTTP request object, info.origin - the Origin header value
+        const ip = info.req.headers['x-forwarded-for'] || info.req.socket.remoteAddress;
+        if (isRateLimited(ip)) return callback(false, 429, 'Too Many Requests');
+        callback(true);
+    }
+});
+```
+
+The callback signature is `callback(verified, code?, message?)` where `code` and `message` are the optional HTTP response status for rejected connections.
 
 ### Methods
 
@@ -226,7 +246,7 @@ new PlaySocket(options: PlaySocketServerOptions)
 | `onEvent()` | `event: string, callback: Function` | `void` | Register a server-side event callback |
 | `getRoomStorage()` | `roomId: string` | `object` | Get a snapshot of the current room storage |
 | `updateRoomStorage()` | `roomId: string, key: string, type: 'set' \| 'array-add' \| 'array-add-unique' \| 'array-remove-matching' \| 'array-update-matching', value: any, updateValue?: any` | `void` | Update a key in the shared room storage from the server |
-| `createRoom()` | `initialStorage?: object, size?: number, host?: string` | `object` | Create a room (returns object containing room ID and state) – Rooms created with a non-player host like "server" (default) will not be deleted when the last participant leaves |
+| `createRoom()` | `initialStorage?: object, size?: number, host?: string` | `object` | Create a room (returns object containing room ID and state)|
 | `destroyRoom()` | `roomId: string` | `void` | Destroy a room & kick all participants |
 
 ### Event types
@@ -239,7 +259,7 @@ new PlaySocket(options: PlaySocketServerOptions)
 | `clientJoinedRoom` | `clientId: string, roomId: string` | Client joined a room (clients can only leave by disconnecting) | - |
 | `clientJoinRequested` | `clientId: string, roomId: string` | Client requests to join a room | Return `false` or rejection reason `string` to block |
 | `roomCreated` | `roomId: string` | Client created a room | - |
-| `roomDestroyed` | `roomId: string` | Room was destroyed (happens when all participants leave) | - |
+| `roomDestroyed` | `roomId: string` | Room was destroyed (happens when all participants leave, unless room host is "server") | - |
 | `roomCreationRequested` | `{clientId: string, initialStorage: object}` | Room creation requested by client | Return `object` to override initial storage, `false` to deny |
 | `storageUpdated` | `{clientId: string, roomId: string, update: object, storage: object}` | Room storage property updated | - |
 | `storageUpdateRequested` | `{clientId: string, roomId: string, update: object, storage: object}` | Room storage property update requested by client | Return `false` to block the update |

package/dist/playsocket-server.js

@@ -2119,9 +2119,10 @@ class PlaySocketServer {
      * @param {string} [options.path='/'] - WebSocket endpoint path
      * @param {boolean} [options.debug=false] - Enable debug logging
      * @param {number} [options.rateLimit=20] - Maximum number of operations per second per client
+     * @param {Function} [options.verifyClient] - Optional callback to verify client connections before upgrade. Receives (info, callback) where info contains { req, origin } and callback is (verified, code?, message?) => void
      */
     constructor(options = {}) {
-        const { server, port = 3000, path = '/', debug = false, rateLimit = 20 } = options;
+        const { server, port = 3000, path = '/', debug = false, rateLimit = 20, verifyClient } = options;
 
         if (debug) this.#debug = true; // Enable extra logging
 
@@ -2141,7 +2142,8 @@ class PlaySocketServer {
         // Create WebSocket server
         this.#wss = new WebSocketServer({
             server: this.#server,
-            path
+            path,
+            ...(verifyClient && { verifyClient })
         });
 
         // Set up ws event handlers
@@ -2257,6 +2259,9 @@ class PlaySocketServer {
                         const formerRoomId = this.#clientRooms.get(data.id);
                         const formerRoom = this.#rooms[formerRoomId];
                         if (formerRoom) {
+                            // If the room has no host (they were the only one and disconnected), restore them as host
+                            if (formerRoom.host === null) formerRoom.host = data.id;
+
                             if (this.#debug) console.log(`State sent for reconnection for room ${formerRoomId}:`, formerRoom.crdtManager.getState);
                             roomData = {
                                 state: formerRoom.crdtManager.getState,
@@ -2339,6 +2344,17 @@ class PlaySocketServer {
                         version: this.#roomVersions.get(roomId)
                     }), { binary: true });
 
+                    // If the room has no host (previous host disconnected and was the only participant), make joiner the host
+                    // Since the room had to be empty, only the joiner needs to be notified
+                    const becameHost = room.host === null;
+                    if (becameHost) {
+                        room.host = ws.clientId;
+                        ws.send(encode({
+                            type: 'host_migrated',
+                            newHost: room.host,
+                        }), { binary: true });
+                    }
+
                     // Notify existing participants
                     room.participants.forEach(p => {
                         if (p === ws.clientId) return;
@@ -2427,18 +2443,21 @@ class PlaySocketServer {
      */
     #changeHostIfDisconnected(roomId, clientId) {
         const room = this.#rooms[roomId];
-        if (room && room.host === clientId && room.participants.length > 1) {
+        if (room && room.host === clientId) {
             const participantsWithoutClient = room.participants.filter((e) => e !== clientId);
-            room.host = participantsWithoutClient[0]; // Set new host
 
-            // Inform all participants about the new host
-            participantsWithoutClient.forEach(p => {
-                const client = this.#clients.get(p);
-                if (client) client.send(encode({
-                    type: 'host_migrated',
-                    newHost: room.host,
-                }), { binary: true });
-            });
+            if (participantsWithoutClient.length >= 1) {
+                room.host = participantsWithoutClient[0]; // Set new host
+
+                // Inform all participants about the new host
+                participantsWithoutClient.forEach(p => {
+                    const client = this.#clients.get(p);
+                    if (client) client.send(encode({
+                        type: 'host_migrated',
+                        newHost: room.host,
+                    }), { binary: true });
+                });
+            } else room.host = null; // The next person to join will become the host
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playsocketjs",
-  "version": "2.6.3",
+  "version": "2.7.0",
   "description": "WebSocket wrapper for creating simple multiplayer systems with ease.",
   "type": "module",
   "module": "dist/playsocket-client.js",