playsocketjs 5.3.0 → 5.3.2

package/package.json

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

package/src/server/server.js

@@ -213,9 +213,11 @@ export default class PlaySocketServer {
                 }
 
                 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 user is pending disconnect or still on a dropped connection, respond (otherwise it's too late)
+                    const pendingDisconnect = this.#pendingDisconnects.get(data.id);
+                    const staleSocket = this.#clients.get(data.id); // Client requests reconnect even though the server thinks they are still connected
+
+                    if ((pendingDisconnect || staleSocket) && data.sessionToken) {
                         if (data.sessionToken !== this.#clientTokens.get(data.id)) {
                             ws.send(encode({
                                 type: "reconnection_failed",
@@ -223,9 +225,15 @@ export default class PlaySocketServer {
                             }), { binary: true });
                             return;
                         }
-                        clearTimeout(pd.timeout);
+                        clearTimeout(pendingDisconnect?.timeout);
                         this.#pendingDisconnects.delete(data.id);
 
+                        // Only terminate if it's a different connection sending the reconnect
+                        if (staleSocket && staleSocket !== ws) {
+                            staleSocket.clientId = null; // So the close skips disconnection (handleDisconnection exits if the client ID is falsy)
+                            staleSocket.terminate();
+                        }
+
                         // Re-assign old client ID to the new ws connection
                         ws.clientId = data.id;
                         this.#clients.set(data.id, ws);
@@ -325,7 +333,8 @@ export default class PlaySocketServer {
 
                     if (room && data.update) {
                         // Check if update is allowed via event callback (provide clone to ensure update integrity)
-                        const updateAllowed = await this.#triggerEvent("storageUpdateRequested", { roomId, clientId: ws.clientId, update: structuredClone(data.update), storage: this.getRoomStorage(roomId) });
+                        // Must be synchronous so that messages that follow in the same read from the socket (which can flush multiple at once) get processed reliably in order (await would schedule to a new microtask, so the order can fall apart)
+                        const updateAllowed = this.#triggerEventSync("storageUpdateRequested", { roomId, clientId: ws.clientId, update: structuredClone(data.update), storage: this.getRoomStorage(roomId) });
                         if (updateAllowed === false || typeof updateAllowed === "string") {
                             ws.send(encode({
                                 type: "property_update_rejected",
@@ -416,9 +425,7 @@ export default class PlaySocketServer {
      * @returns {string} Token
      */
     #generateSessionToken() {
-        let token = "";
-        for (let i = 0; i < 16; i++) token += Math.floor(Math.random() * 16).toString(16);
-        return token;
+        return crypto.randomUUID();
     }
 
     /**
@@ -519,20 +526,41 @@ export default class PlaySocketServer {
      * @returns {Promise<any>} The first non-null callback return value if present (all callbacks run, a throwing callback counts as returning false), otherwise true
      */
     async #triggerEvent(event, ...args) {
-        const syncOnlyEvents = ["storageUpdateRequested"]; // Async storage validation could mess up GC and would lead to potentially poor UX (slow sync)
         const callbacks = this.#callbacks.get(event);
-        if (!callbacks) return;
+        if (!callbacks) return true;
+
+        let firstResult;
+        for (const callback of [...callbacks]) {
+            try {
+                let result = callback(...args);
+                if (typeof result?.then === "function") result = await result;
+                if (firstResult == null && result != null) firstResult = result;
+            } catch (error) {
+                console.error(ERROR_PREFIX + `${event} callback error:`, error);
+                if (firstResult == null) firstResult = false; // Fail closed (false blocks for most events)
+            }
+        }
+        return firstResult ?? true;
+    }
+
+    /**
+     * Trigger an event to registered synchronous callbacks (e.g. storage validation, async validation could mess up GC and lead to poor UX)
+     * @param {string} event - Event name
+     * @param {...*} args - Arguments
+     * @returns {any} The first non-null callback return value if present (all callbacks run, a throwing callback counts as returning false, an async one as a rejection), otherwise true
+     */
+    #triggerEventSync(event, ...args) {
+        const callbacks = this.#callbacks.get(event);
+        if (!callbacks) return true;
 
         let firstResult;
         for (const callback of [...callbacks]) {
             try {
                 let result = callback(...args);
                 if (typeof result?.then === "function") {
-                    if (syncOnlyEvents.includes(event)) {
-                        result.catch(() => { });
-                        console.error(ERROR_PREFIX + `${event} callbacks must be synchronous`);
-                        result = `${event} callback must be synchronous.`; // Rejection string to explicitly block this practice
-                    } else result = await result;
+                    result.catch(() => { });
+                    console.error(ERROR_PREFIX + `${event} callbacks must be synchronous`);
+                    result = `${event} callback must be synchronous`; // Rejection string to explicitly block this practice
                 }
                 if (firstResult == null && result != null) firstResult = result;
             } catch (error) {

package/src/universal/constants.js

@@ -9,7 +9,7 @@ export const HEARTBEAT_INTERVAL = 5000;
 /**
  * Library version, must match package.json
  */
-export const VERSION = "5.3.0";
+export const VERSION = "5.3.2";
 
 /**
  * Logging prefixes

package/src/universal/crdtManager.js

@@ -451,8 +451,8 @@ export default class CRDTManager {
         try {
             return structuredClone(this.#propertyStore); // Return deep clone
         } catch {
-            console.error(CONSOLE_PREFIX + "Failed to parse property store")
-            return {}
+            console.error(CONSOLE_PREFIX + "Failed to parse property store");
+            return {};
         }
     }
 
@@ -475,7 +475,7 @@ export default class CRDTManager {
                 return true;
             }
         } catch {
-            console.error(CONSOLE_PREFIX + "Failed to stringify and compare property stores")
+            console.error(CONSOLE_PREFIX + "Failed to stringify and compare property stores");
         }
         return false;
     }

package/types/universal/constants.d.ts

@@ -8,7 +8,7 @@ export declare const HEARTBEAT_INTERVAL = 5000;
 /**
  * Library version, must match package.json
  */
-export declare const VERSION = "5.3.0";
+export declare const VERSION = "5.3.2";
 /**
  * Logging prefixes
  */