playsocketjs 1.0.7 → 1.0.8

package/dist/playsocket-client.js

@@ -9,6 +9,7 @@ const TIMEOUT_MS = 5000; // 5 second timeout for operations
 class PlaySocket {
     // Core properties
     #id; // Unique client ID
+    #sessionToken; // Unique session token
     #endpoint;
     #socket; // WebSocket connection
     #initialized = false; // Initialization status
@@ -17,7 +18,6 @@ class PlaySocket {
     // Room properties
     #storage = {}; // Shared storage object
     #storageTimestamps = {}; // Tracks update timestamps per key
-    #isHost = false; // Whether this client is host
     #roomHost;
     #roomId; // ID of the host (client only)
     #connectionCount = 0;
@@ -29,10 +29,14 @@ class PlaySocket {
     // Async server operations
     #pendingJoin;
     #pendingHost;
-    #pendingInit;
+    #pendingRegistration;
+    #pendingConnect;
+    #pendingReconnect;
 
     // Timeouts or intervals
     #reconnectTimeout;
+    #reconnectCount = 0;
+    #isReconnecting = false;
 
     /**
      * Create a new PlaySocket instance
@@ -72,7 +76,7 @@ class PlaySocket {
      */
     onEvent(event, callback) {
         const validEvents = [
-            "status", "error", "instanceDestroyed", "storageUpdated", "hostMigrated", "clientConnected", "clientDisconnected",
+            "status", "error", "instanceDestroyed", "storageUpdated", "hostMigrated", "clientConnected", "clientDisconnected"
         ];
         if (!validEvents.includes(event)) return console.warn(WARNING_PREFIX + `Invalid event type "${event}".`);
         if (!this.#callbacks.has(event)) this.#callbacks.set(event, []);
@@ -99,41 +103,45 @@ class PlaySocket {
      * @returns {Promise} Resolves when connection is established
      */
     async init() {
-        if (this.#initialized) return Promise.reject(new Error("Already initialized."));
-        if (!this.#endpoint) return Promise.reject(new Error("No websocket endpoint provided."));
+        if (this.#initialized) return Promise.reject(new Error("Already initialized"));
+        if (!this.#endpoint) return Promise.reject(new Error("No websocket endpoint provided"));
         this.#triggerEvent("status", "Initializing...");
 
-        return Promise.race([
-            this.#connect(),
-            this.#createTimeout("Initialization")
-        ]);
-    }
+        // Connect to WS server
+        await this.#connect();
 
+        // Register with server
+        await Promise.race([
+            new Promise(async (resolve, reject) => {
+                this.#pendingRegistration = { resolve, reject }; // Resolve or reject depending on answer to registration msg
 
-    /**
-     * Connect to the WS server and register
-     * @returns {Promise} Resolves when user is registered on the WS server
-     * @private 
-     */
-    async #connect() {
-        return new Promise((resolve, reject) => {
-            this.#socket = new WebSocket(this.#endpoint);
-            this.#setupSocketHandlers(); // Message & close events
-
-            // Resolve or reject depending on answer to registration msg
-            this.#pendingInit = { resolve, reject };
-
-            // Register with server
-            this.#socket.onopen = () => {
-                this.#initialized = true;
+                // Register with server
                 this.#sendToServer({
                     type: 'register',
                     id: this.#id,
                     customData: this.#customData || undefined,
                     clientTime: Date.now()
                 });
-            };
-        });
+            }),
+            this.#createTimeout("Registration")
+        ]);
+    }
+
+    /**
+     * Connect to the WS server and
+     * @returns {Promise} Resolves when the connection was established
+     * @private 
+     */
+    async #connect() {
+        return Promise.race([
+            new Promise((resolve, reject) => {
+                this.#pendingConnect = { reject };
+                this.#socket = new WebSocket(this.#endpoint);
+                this.#setupSocketHandlers(); // Message & close events
+                this.#socket.onopen = resolve;
+            }),
+            this.#createTimeout("Connection attempt")
+        ]);
     }
 
     /**
@@ -147,12 +155,13 @@ class PlaySocket {
                 if (!message.type) return;
 
                 switch (message.type) {
-                    case 'connection_accepted':
+                    case 'join_accepted':
                         // Connected to room
                         if (this.#pendingJoin) {
                             this.#storage = message.storage;
                             this.#storageTimestamps = message.storageTimestamps;
-                            this.#connectionCount = message.participantCount - 1;
+                            this.#connectionCount = message.participantCount - 1; // Counted without the user themselves
+                            this.#roomHost = message.host;
                             this.#triggerEvent("status", `Connected to room.`);
                             this.#triggerEvent("storageUpdated", { ...this.#storage });
                             this.#pendingJoin.resolve();
@@ -160,7 +169,7 @@ class PlaySocket {
                         }
                         break;
 
-                    case 'connection_rejected':
+                    case 'join_rejected':
                         // Connection to room failed
                         if (this.#pendingJoin) {
                             this.#triggerEvent("status", "Connection rejected: " + message.reason || 'Unknown reason');
@@ -169,6 +178,37 @@ class PlaySocket {
                         }
                         break;
 
+                    case 'reconnected':
+                        // Successfully reconnected
+                        if (this.#pendingReconnect) {
+                            this.#isReconnecting = false;
+                            this.#reconnectCount = 0;
+                            if (message.roomData) {
+                                this.#storage = message.roomData.storage;
+                                this.#storageTimestamps = message.roomData.storageTimestamps;
+                                this.#connectionCount = message.roomData.participantCount - 1; // Counted without the user themselves
+                                this.#setHost(message.roomData.host);
+                                this.#triggerEvent("storageUpdated", { ...this.#storage });
+                            } else {
+                                if (this.#roomId) {
+                                    this.#triggerEvent("error", "Reconnected, but room no longer exists.");
+                                    return this.destroy();
+                                }
+                            }
+                            this.#triggerEvent("status", "Reconnected.");
+                            this.#pendingReconnect.resolve();
+                            this.#pendingReconnect = null;
+                        }
+                        break;
+
+                    case 'reconnection_failed':
+                        if (this.#pendingReconnect) {
+                            this.#triggerEvent("status", `Reconnection failed: ${message.reason}`);
+                            this.#pendingReconnect.resolve();
+                            this.#pendingReconnect = null;
+                        }
+                        break;
+
                     case 'room_created':
                         if (this.#pendingHost) {
                             this.#pendingHost.resolve(this.#roomId);
@@ -187,21 +227,23 @@ class PlaySocket {
                         break;
 
                     case 'id_taken':
-                        if (this.#pendingInit) {
-                            this.#pendingInit.reject(new Error("This id is already in use."));
+                        if (this.#pendingRegistration) {
+                            this.#pendingRegistration.reject(new Error("This id is already in use"));
+                            this.#pendingRegistration = null;
                             this.#triggerEvent("error", "This id is taken.");
-                            this.#pendingInit = null;
                         }
                         break;
 
                     case 'registered':
-                        if (this.#pendingInit) {
+                        if (this.#pendingRegistration) {
                             const roundTripTime = Date.now() - message.clientTime;
                             const serverTimeAtClientNow = message.serverTime + (roundTripTime / 2);
                             this.#serverTimeOffset = serverTimeAtClientNow - Date.now();
-                            this.#pendingInit.resolve();
+                            this.#sessionToken = message.sessionToken;
+                            this.#initialized = true;
+                            this.#pendingRegistration.resolve();
+                            this.#pendingRegistration = null;
                             this.#triggerEvent("status", "Connected to server.");
-                            this.#pendingInit = null;
                         }
                         break;
 
@@ -217,21 +259,15 @@ class PlaySocket {
                         break;
 
                     case 'client_disconnected':
-                        this.#isHost = this.#id == message.updatedHost;
                         this.#connectionCount = message.participantCount - 1; // Counted without the user themselves
-
-                        // If host has changed...
-                        if (this.#roomHost != message.updatedHost) {
-                            this.#roomHost = message.updatedHost;
-                            this.#triggerEvent("hostMigrated", this.#roomHost);
-                        }
+                        this.#setHost(message.host);
 
                         this.#triggerEvent("clientDisconnected", message.client);
                         this.#triggerEvent("status", `Client ${message.client} disconnected.`);
                         break;
 
                     case 'client_connected':
-                        this.#connectionCount = message.participantCount - 1;
+                        this.#connectionCount = message.participantCount - 1; // Counted without the user themselves
                         this.#triggerEvent("clientConnected", message.client);
                         this.#triggerEvent("status", `Client ${message.client} connected.`);
                         break;
@@ -244,37 +280,67 @@ class PlaySocket {
         // Handle socket errors
         this.#socket.onerror = () => {
             this.#triggerEvent("error", "WebSocket error.");
-            if (this.#pendingInit) this.#pendingInit.reject(new Error("WebSocket error."));
+            if (this.#pendingConnect) this.#pendingConnect.reject(new Error("WebSocket error"));
         };
 
         // Handle socket close & attempt reconnect
         this.#socket.onclose = () => {
-            if (!this.#initialized) return;
-            this.#triggerEvent("status", "Disconnected from server.");
-
-            this.#reconnectTimeout = setTimeout(async () => {
-                try {
-                    await this.#connect(); // Will set status to connected if successful
-
-                    // Rejoin room if needed
-                    if (this.#roomId) {
-                        this.#triggerEvent("status", "Rejoining room...");
-                        await this.joinRoom(this.#roomId); // If this fails, it will be caught by the outer catch
-                    }
-                } catch (error) {
-                    this.#triggerEvent("error", "WebSocket connection permanently closed: " + error);
-                    this.destroy();
-                }
-            }, 1000);
+            if (!this.#initialized || this.#isReconnecting) return;
+            this.#triggerEvent("status", "Disconnected.");
+            this.#reconnectCount = 0;
+            this.#attemptReconnect();
         };
     };
 
+    /**
+     * Attempt to reconnect with a fixed number of retries
+     * @private
+     */
+    async #attemptReconnect() {
+        if (this.#reconnectCount++ >= 3) {
+            this.#triggerEvent("error", "Disconnected from server.");
+            return this.destroy();
+        }
+
+        this.#triggerEvent("status", `Attempting to reconnect... (${this.#reconnectCount})`);
+        this.#isReconnecting = true;
+        try {
+            await this.#connect();
+            await Promise.race([
+                new Promise(async (resolve, reject) => {
+                    this.#pendingReconnect = { resolve, reject };
+                    this.#sendToServer({
+                        type: 'reconnect',
+                        id: this.#id,
+                        sessionToken: this.#sessionToken
+                    });
+                }),
+                this.#createTimeout("Reconnection request")
+            ]);
+        } catch (error) {
+            this.#triggerEvent("status", "Reconnection failed: " + error.message);
+            this.#reconnectTimeout = setTimeout(() => this.#attemptReconnect(), 500);
+        }
+    }
+
+    /**
+     * Update the host in case a new one was chosen
+     * @param {string} hostId - Client id of new host
+     * @private
+     */
+    #setHost(hostId) {
+        if (this.#roomHost != hostId) {
+            this.#roomHost = hostId;
+            this.#triggerEvent("hostMigrated", hostId);
+        }
+    }
+
     /**
      * Send a message to the server
      * @private
      */
     #sendToServer(data) {
-        if (!this.#initialized || !this.#socket || this.#socket.readyState !== WebSocket.OPEN) {
+        if (!this.#socket || this.#socket.readyState !== WebSocket.OPEN) {
             return console.error(ERROR_PREFIX + "Cannot send message - not connected.");
         }
         try {
@@ -299,7 +365,6 @@ class PlaySocket {
 
         return Promise.race([
             new Promise((resolve, reject) => {
-                this.#isHost = true;
                 this.#storage = initialStorage;
                 this.#roomId = this.#id; // Create room with your own ID as the room ID to mimic p2p
                 this.#roomHost = this.#id;
@@ -329,9 +394,7 @@ class PlaySocket {
 
         return Promise.race([
             new Promise((resolve, reject) => {
-                this.#isHost = false;
                 this.#roomId = roomId;
-                this.#roomHost = roomId;
                 this.#pendingJoin = { resolve, reject };
 
                 // Send connection request
@@ -436,19 +499,20 @@ class PlaySocket {
         }
 
         // Reset state
-        this.#isHost = false;
+        clearTimeout(this.#reconnectTimeout);
         this.#roomHost = null;
         this.#storage = {};
         this.#storageTimestamps = {};
         this.#roomId = null;
         this.#connectionCount = 0;
-        clearTimeout(this.#reconnectTimeout);
+        this.#isReconnecting = false;
+        this.#reconnectCount = 0;
     }
 
     // Public getters
     get connectionCount() { return this.#connectionCount; }
     get getStorage() { return { ...this.#storage }; }
-    get isHost() { return this.#isHost; }
+    get isHost() { return this.#id == this.#roomHost; }
     get id() { return this.#id; }
 }
 

package/dist/playsocket-server.js

@@ -27,8 +27,10 @@ function requireServer () {
 	    #rooms = {};
 	    #clientRooms = new Map(); // ClientId -> RoomId
 	    #rateLimits = new Map(); // Rate limiting storage
-	    #callbacks = new Map();
+	    #callbacks = new Map(); // Event -> [callback functions]
 	    #heartbeatInterval;
+	    #pendingDisconnects = new Map(); // ClientId -> {timeout, roomId}
+	    #clientTokens = new Map(); // ClientId -> Token
 
 	    /**
 	     * Create a new PlaySocketServer instance
@@ -98,10 +100,45 @@ function requireServer () {
 	                    }
 	                    ws.clientId = data.id; // Adds the provided id to the ws object as clientId
 	                    this.#clients.set(data.id, ws);
-	                    ws.send(JSON.stringify({ type: 'registered', serverTime: Date.now(), clientTime: data.clientTime }));
+	                    const sessionToken = this.#generateSessionToken();
+	                    this.#clientTokens.set(data.id, sessionToken); // Token is used when reconnecting to prevent impersonation attacks
+	                    ws.send(JSON.stringify({ type: 'registered', sessionToken, serverTime: Date.now(), clientTime: data.clientTime }));
 	                    this.#triggerEvent("clientRegistered", data.id, data.customData);
 	                    break;
 
+	                case 'reconnect':
+	                    // If user is pending disconnect, respond (otherwise it's too late)
+	                    const pd = this.#pendingDisconnects.get(data.id);
+	                    if (pd && data.sessionToken) {
+	                        if (data.sessionToken !== this.#clientTokens.get(data.id)) {
+	                            ws.send(JSON.stringify({ type: 'reconnection_failed', reason: "Session token does not match" }));
+	                            return;
+	                        }
+	                        clearTimeout(pd.timeout);
+	                        this.#pendingDisconnects.delete(data.id);
+
+	                        // Re-assign old client id to the new ws connection
+	                        ws.clientId = data.id;
+	                        this.#clients.set(data.id, ws);
+
+	                        // If they were in a room, provide updated room data
+	                        let roomData;
+	                        const formerRoom = this.#rooms[this.#clientRooms.get(data.id)];
+	                        if (formerRoom) {
+	                            roomData = {
+	                                storage: formerRoom.storage,
+	                                storageTimestamps: formerRoom.storageTimestamps,
+	                                participantCount: formerRoom.participants.length,
+	                                host: formerRoom.participants[0]
+	                            };
+	                        }
+
+	                        ws.send(JSON.stringify({ type: 'reconnected', roomData }));
+	                    } else {
+	                        ws.send(JSON.stringify({ type: 'reconnection_failed', reason: "Client unknown to server" }));
+	                    }
+	                    break;
+
 	                case 'create_room':
 	                    if (!ws.clientId) return;
 	                    const newRoomId = ws.clientId;
@@ -126,7 +163,7 @@ function requireServer () {
 	                    break;
 
 	                case 'join_room':
-	                    if (!data.roomId) return;
+	                    if (!data.roomId || !ws.clientId) return;
 	                    const roomId = data.roomId;
 	                    const room = this.#rooms[roomId];
 
@@ -134,7 +171,7 @@ function requireServer () {
 	                        (room.maxSize && room.participants.length >= room.maxSize) ||
 	                        this.#clientRooms.get(ws.clientId)) {
 	                        ws.send(JSON.stringify({
-	                            type: 'connection_rejected',
+	                            type: 'join_rejected',
 	                            reason: !room ? 'Room not found' :
 	                                room.maxSize && room.participants.length >= room.maxSize ? 'Room full' :
 	                                    'Already in a room'
@@ -147,10 +184,11 @@ function requireServer () {
 
 	                    // Notify joiner with initial storage
 	                    ws.send(JSON.stringify({
-	                        type: 'connection_accepted',
+	                        type: 'join_accepted',
 	                        storage: room.storage,
 	                        storageTimestamps: room.storageTimestamps,
-	                        participantCount: room.participants.length
+	                        participantCount: room.participants.length,
+	                        host: room.participants[0]
 	                    }));
 
 	                    // Notify existing participants
@@ -199,6 +237,16 @@ function requireServer () {
 	        }
 	    }
 
+	    /**
+	     * Generate a random token to prevent malicious reconnect attempts
+	     * @returns {string} - Token
+	     */
+	    #generateSessionToken() {
+	        let token = '';
+	        for (let i = 0; i < 16; i++) token += Math.floor(Math.random() * 16).toString(16);
+	        return token;
+	    }
+
 	    /**
 	     * Check rate limit using token bucket algorithm
 	     * @private
@@ -284,37 +332,40 @@ function requireServer () {
 	     */
 	    #handleDisconnection(ws) {
 	        if (!ws.clientId) return;
-
-	        this.#clients.delete(ws.clientId);
-	        this.#rateLimits.delete(ws.clientId);
-
-	        const roomId = this.#clientRooms.get(ws.clientId);
-	        const room = roomId ? this.#rooms[roomId] : null;
-
-	        if (room) {
-	            room.participants = room.participants?.filter(p => p !== ws.clientId);
-	            this.#clientRooms.delete(ws.clientId);
-
-	            // Notify remaining participants
-	            room.participants?.forEach(p => {
-	                const client = this.#clients.get(p);
-	                if (client) {
-	                    try {
-	                        client.send(JSON.stringify({
-	                            type: 'client_disconnected',
-	                            updatedHost: room.participants?.[0],
-	                            client: ws.clientId,
-	                            participantCount: room.participants?.length
-	                        }));
-	                    } catch (error) {
-	                        console.error(`Error notifying client of disconnection:`, error);
+	        this.#clients.delete(ws.clientId); // Immediately remove from active clients (otherwise, server would try to message this client)
+
+	        // Pending disconnection with 2s grace period to allow for reconnections
+	        this.#pendingDisconnects.set(ws.clientId, {
+	            timeout: setTimeout(() => {
+	                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];
+
+	                if (room) {
+	                    room.participants = room.participants.filter(p => p !== ws.clientId); // Remove client from room
+	                    this.#clientRooms.delete(ws.clientId);
+
+	                    if (room.participants?.length === 0) {
+	                        delete this.#rooms[roomId]; // Delete room if now empty
+	                    } else {
+	                        // Notify remaining participants
+	                        room.participants.forEach(p => {
+	                            const client = this.#clients.get(p);
+	                            if (client) client.send(JSON.stringify({
+	                                type: 'client_disconnected',
+	                                client: ws.clientId,
+	                                host: room.participants[0],
+	                                participantCount: room.participants.length
+	                            }));
+	                        });
 	                    }
 	                }
-	            });
-	            if (room.participants?.length === 0) delete this.#rooms[roomId]; // Delete room if now empty
-	        }
 
-	        this.#triggerEvent("clientDisconnected", ws.clientId);
+	                this.#triggerEvent("clientDisconnected", ws.clientId);
+	            }, 2000)
+	        });
 	    }
 
 	    /**
@@ -354,6 +405,9 @@ function requireServer () {
 	                console.log('PlaySocket server stopped');
 	            });
 	        }
+	        this.#pendingDisconnects.forEach((data) => {
+	            clearTimeout(data.timeout);
+	        });
 	    }
 
 	    get getRooms() { return { ...this.#rooms } }

package/package.json

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