playsocketjs 1.1.8 → 1.1.10

package/dist/playsocket-client.js

@@ -2287,9 +2287,17 @@ class PlaySocket {
                         }
                         break;
 
+                    case 'server_stopped':
+                        this.#triggerEvent("error", "Server restart.");
+                        this.destroy();
+                        break;
+
+                    case 'host_migrated':
+                        this.#setHost(message.newHost);
+                        break;
+
                     case 'client_disconnected':
                         this.#connectionCount = message.participantCount - 1; // Counted without the user themselves
-                        this.#setHost(message.host);
                         this.#triggerEvent("clientDisconnected", message.client);
                         this.#triggerEvent("status", `Client ${message.client} disconnected.`);
                         break;
@@ -2325,7 +2333,8 @@ class PlaySocket {
      * @private
      */
     async #attemptReconnect() {
-        if (this.#reconnectCount++ >= 3) {
+        this.#reconnectCount++;
+        if (this.#reconnectCount > 9) {
             this.#triggerEvent("error", "Disconnected from server.");
             return this.destroy();
         }

package/dist/playsocket-server.js

@@ -2226,6 +2226,7 @@ function requireServer () {
 
 	        // Set up ws event handlers
 	        this.#wss.on('connection', ws => {
+	            ws.connectionId = crypto.randomUUID();
 	            ws.isAlive = true;
 	            ws.on('pong', () => { ws.isAlive = true; });
 	            ws.on('message', msg => this.#handleMessage(ws, msg));
@@ -2258,9 +2259,14 @@ function requireServer () {
 	        try {
 	            const data = decode(message);
 
-	            // Apply rate limiting after client is registered
-	            if (ws.clientId && !this.#checkRateLimit(ws.clientId, data.type)) {
-	                return console.error(`Client ${ws.clientId} rate limit exceeded.`);
+	            // Apply rate limiting to all connections (including unregistered)
+	            if (!this.#checkRateLimit(ws.connectionId, data.type)) {
+	                ws.rateLimitViolations = (ws.rateLimitViolations || 0) + 1;
+	                if (ws.rateLimitViolations > 5) {
+	                    ws.terminate();
+	                    return console.error(`Connection ${ws.connectionId} terminated due to repeated rate limit violations.`);
+	                }
+	                return console.error(`Connection ${ws.connectionId} rate limit exceeded.`);
 	            }
 
 	            switch (data.type) {
@@ -2306,7 +2312,7 @@ function requireServer () {
 	                            roomData = {
 	                                state: formerRoom.crdtManager.getState,
 	                                participantCount: formerRoom.participants.length,
-	                                host: formerRoom.participants[0],
+	                                host: formerRoom.host,
 	                                version: this.#roomVersions.get(formerRoomId)
 	                            };
 	                        }
@@ -2332,6 +2338,7 @@ function requireServer () {
 	                    this.#roomVersions.set(newRoomId, 0); // Start with version 0
 	                    this.#rooms[newRoomId] = {
 	                        participants: [ws.clientId],
+	                        host: ws.clientId,
 	                        maxSize: data.size || null,
 	                        crdtManager: new CRDTManager(crypto.randomUUID(), this.#debug)
 	                    };
@@ -2373,7 +2380,7 @@ function requireServer () {
 	                        type: 'join_accepted',
 	                        state: room.crdtManager.getState,
 	                        participantCount: room.participants.length,
-	                        host: room.participants[0],
+	                        host: room.host,
 	                        version: this.#roomVersions.get(roomId)
 	                    }), { binary: true });
 
@@ -2427,6 +2434,29 @@ function requireServer () {
 	        }
 	    }
 
+	    /**
+	     * If the client that disconnected (and is now in the reconnection-phase) was the room host,
+	     * pick a new room host immediately to avoid host-less phase (in case important logic is attached to the host)
+	     * @param {string} roomId
+	     * @param {string} clientId
+	     */
+	    #changeHostIfDisconnected(roomId, clientId) {
+	        const room = this.#rooms[roomId];
+	        if (room && room.host === clientId && room.participants.length > 1) {
+	            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 });
+	            });
+	        }
+	    }
+
 	    /**
 	     * Generate a random token to prevent malicious reconnect attempts
 	     * @returns {string} - Token
@@ -2441,24 +2471,24 @@ function requireServer () {
 	     * Check rate limit using token bucket algorithm
 	     * @private
 	     */
-	    #checkRateLimit(clientId, operationType) {
-	        const MAX_POINTS = 100;
+	    #checkRateLimit(connectionId, operationType) {
+	        const MAX_POINTS = 20;
 	        const now = Date.now();
 
-	        if (!this.#rateLimits.has(clientId)) {
-	            this.#rateLimits.set(clientId, { points: MAX_POINTS, lastReset: now });
+	        if (!this.#rateLimits.has(connectionId)) {
+	            this.#rateLimits.set(connectionId, { points: MAX_POINTS, lastReset: now });
 	            return true;
 	        }
 
-	        const limit = this.#rateLimits.get(clientId);
+	        const limit = this.#rateLimits.get(connectionId);
 
-	        // Reset points if interval has passed (5s)
-	        if (now - limit.lastReset > 5000) {
+	        // Reset points if interval has passed (1s)
+	        if (now - limit.lastReset > 1000) {
 	            limit.points = MAX_POINTS;
 	            limit.lastReset = now;
 	        }
 
-	        const pointCost = ['create_room', 'join_room'].includes(operationType) ? 20 : 1;
+	        const pointCost = ['create_room', 'join_room'].includes(operationType) ? 5 : 1;
 	        if (limit.points < pointCost) return false;
 
 	        limit.points -= pointCost;
@@ -2470,18 +2500,25 @@ function requireServer () {
 	     * @private
 	     */
 	    #handleDisconnection(ws) {
-	        if (!ws.clientId) return;
-	        this.#clients.delete(ws.clientId); // Immediately remove from active clients (otherwise, server would try to message this client)
+	        this.#rateLimits.delete(ws.connectionId);
 
-	        if (ws.willfulDisconnect) {
-	            this.#disconnectClient(ws); // Immediate disconnection
-	        } else {
-	            // Pending complete disconnection with 2s grace period to allow for reconnections
-	            this.#pendingDisconnects.set(ws.clientId, {
-	                timeout: setTimeout(() => {
-	                    this.#disconnectClient(ws);
-	                }, 2000)
-	            });
+	        if (ws.clientId) {
+	            this.#clients.delete(ws.clientId); // Immediately remove from active clients (otherwise, server would try to message this client)
+
+	            // If client was in a room, check if they were the host & migrate
+	            const roomId = this.#clientRooms.get(ws.clientId);
+	            if (roomId != null) this.#changeHostIfDisconnected(roomId, ws.clientId);
+
+	            if (ws.willfulDisconnect) {
+	                this.#disconnectClient(ws); // Immediate disconnection
+	            } else {
+	                // Pending complete disconnection with 5s grace period to allow for reconnections
+	                this.#pendingDisconnects.set(ws.clientId, {
+	                    timeout: setTimeout(() => {
+	                        this.#disconnectClient(ws);
+	                    }, 5000)
+	                });
+	            }
 	        }
 	    }
 
@@ -2492,7 +2529,6 @@ function requireServer () {
 	     */
 	    #disconnectClient(ws) {
 	        this.#pendingDisconnects.delete(ws.clientId);
-	        this.#rateLimits.delete(ws.clientId);
 	        this.#clientTokens.delete(ws.clientId);
 	        const roomId = this.#clientRooms.get(ws.clientId);
 	        const room = this.#rooms[roomId];
@@ -2512,7 +2548,6 @@ function requireServer () {
 	                    if (client) client.send(encode({
 	                        type: 'client_disconnected',
 	                        client: ws.clientId,
-	                        host: room.participants[0],
 	                        participantCount: room.participants.length
 	                    }), { binary: true });
 	                });
@@ -2551,7 +2586,10 @@ function requireServer () {
 	    stop() {
 	        clearInterval(this.#heartbeatInterval);
 	        if (this.#wss) {
-	            this.#wss.clients.forEach(client => client.close());
+	            this.#wss.clients.forEach(client => {
+	                client.send(encode({ type: 'server_stopped' }), { binary: true });
+	                client.close();
+	            });
 	            this.#wss.close();
 	        }
 	        if (this.#server && this.#ownsServer) {

package/package.json

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