playsocketjs 5.3.1 → 5.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playsocketjs",
-  "version": "5.3.1",
+  "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

@@ -333,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",
@@ -525,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.1";
+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.1";
+export declare const VERSION = "5.3.2";
 /**
  * Logging prefixes
  */