playsocketjs 2.5.4 → 2.6.0

package/README.md

@@ -96,7 +96,7 @@ new PlaySocket(id?: string, options: PlaySocketOptions)
 ### Methods
 
 - `init()`: Initialize the WebSocket connection – Returns Promise (async) which resolves with the client's ID
-- `createRoom(initialStorage?: object, maxSize?: number)`: Create a new room and become host – Returns Promise (async) which resolves with the room ID. The room participant maximum is 100
+- `createRoom(initialStorage?: object, size?: number)`: Create a new room and become host – Returns Promise (async) which resolves with the room ID. The room participant maximum is 100
 - `joinRoom(hostId: string)`: Join an existing room – Returns Promise (async)
 - `destroy()`: Use this to leave a room and close the connection
 - `updateStorage(key: string, type: 'set' | 'array-add' | 'array-add-unique' | 'array-remove-matching' | 'array-update-matching', value: any, updateValue?: any)`: Update a key in the shared storage (max. 100 keys). Array operation types allow for conflict-free simultaneous array updates. For '-matching' operations, value becomes the value to match, and updateValue the replacement. 
@@ -213,6 +213,8 @@ Creates a new PlaySocket Server instance with configuration options.
 - `onEvent(event: string, callback: Function)`: Register a server-side event callback
 - `getRoomStorage(roomId: string)`: Get a snapshot of the current room storage (returns storage `object`)
 - `updateRoomStorage(roomId: string, key: string, type: 'set' | 'array-add' | 'array-add-unique' | 'array-remove-matching' | 'array-update-matching', value: any, updateValue?: any)`: Update a key in the shared room storage from the server.
+- `createRoom(initialStorage?: object, size?: number, host?: string)`: 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
+- `destroyRoom(roomId: string)`: Destroy a room & kick all participants
 
 #### Event types
 
@@ -223,7 +225,7 @@ Creates a new PlaySocket Server instance with configuration options.
 - `clientJoinRequested`: Client requests to join a room (returns the client's ID `string`, room ID `string`) – return `false` or a rejection reason `string` to block them from joining
 - `roomCreated`: Client created a room (returns room ID `string`)
 - `roomDestroyed`: Room was destroyed, this happens when all participants leave (returns room ID `string`)
-- `roomCreationRequested`: Room creation requested by client (returns `object` containing the client's ID `string`, room ID `string` and the initialStorage `object`) – if you return an `object` in the callback, it will take that as the initial storage instead. If you return `false`, the creation will be denied
+- `roomCreationRequested`: Room creation requested by client (returns `object` containing the client's ID `string` and the initialStorage `object`) – if you return an `object` in the callback, it will take that as the initial storage instead. If you return `false`, the creation will be denied
 - `storageUpdated`: Room storage property updated (returns `object` containing the ID of the client who requested the update `string`, room ID `string`, the update `object`, and the storage `object`)
 - `storageUpdateRequested`: Room storage property update requested by client (returns `object` containing the client's ID `string`, room ID `string`, the update `object`, and the current storage `object` that hasn't been updated yet) – if you return `false` in the callback, the update will be blocked
 - `requestReceived`: Request from client was received by the server (returns `object` containing client's ID `string`, if in room – room ID `string`, request name `string` and optional passed data of type `any`)

package/dist/playsocket-client.js

@@ -2312,7 +2312,7 @@ class PlaySocket {
                     case 'room_created':
                         if (this.#pendingCreate) {
                             this.#inRoom = true;
-                            this.#triggerEvent("status", `Room created with max. size ${message.size}.`);
+                            this.#triggerEvent("status", `Room created.`);
                             this.#crdtManager.importState(message.state);
                             this.#triggerEvent("storageUpdated", this.getStorage);
                             this.#pendingCreate.resolve(message.roomId);
@@ -2343,11 +2343,6 @@ class PlaySocket {
                         this.#triggerEvent("storageUpdated", this.getStorage);
                         break;
 
-                    case 'server_stopped':
-                        this.#triggerEvent("error", "Server restart.");
-                        this.destroy();
-                        break;
-
                     case 'kicked':
                         this.#triggerEvent("error", `Kicked out of room: ${message.reason || "No reason provided."}`);
                         this.destroy();
@@ -2458,10 +2453,10 @@ class PlaySocket {
     /**
      * Create a new room and become host
      * @param {object} initialStorage - Initial state
-     * @param {number} maxSize - Max number of participants
+     * @param {number} size - Max number of participants
      * @returns {Promise} Resolves with room ID
      */
-    async createRoom(initialStorage = {}, maxSize) {
+    async createRoom(initialStorage = {}, size) {
         if (!this.#initialized) {
             this.#triggerEvent("error", "Cannot create room - not initialized");
             return Promise.reject(new Error("Not initialized"));
@@ -2474,7 +2469,7 @@ class PlaySocket {
                 this.#sendToServer({
                     type: 'create_room',
                     initialStorage,
-                    size: maxSize
+                    size
                 });
             }),
             this.#createTimeout("Room creation")

package/dist/playsocket-server.js

@@ -2185,7 +2185,7 @@ class PlaySocketServer {
                 if (!ws.isTerminating) {
                     ws.isTerminating = true; // Prevent multiple terminate calls (it is async)
                     ws.terminate();
-                    console.error(`Connection ${ws.connectionId} terminated due to rate limit violations.`);
+                    console.error(`PlaySocket connection ${ws.connectionId} terminated due to rate limit violations.`);
                     return;
                 }
             }
@@ -2193,7 +2193,7 @@ class PlaySocketServer {
             switch (data.type) {
                 case 'register': {
                     // Register client ID if provided & check for a duplicate
-                    if (data.id && this.#clients.get(data.id)) {
+                    if (data.id && (this.#clients.get(data.id) || data.id === "server")) {
                         ws.send(encode({ type: 'registration_failed', reason: 'ID is taken.' }), { binary: true });
                         return;
                     }
@@ -2274,8 +2274,6 @@ class PlaySocketServer {
                 case 'create_room': {
                     if (!ws.clientId) return;
 
-                    let newRoomId;
-
                     if (this.#clientRooms.get(ws.clientId)) {
                         ws.send(encode({
                             type: 'room_creation_failed',
@@ -2284,24 +2282,8 @@ class PlaySocketServer {
                         return;
                     }
 
-                    // Generate room ID
-                    for (let i = 0; i < 50; i++) {
-                        const id = this.#generateId();
-                        if (!this.#rooms[id]) {
-                            newRoomId = id;
-                            break;
-                        }
-                    }
-
-                    if (!newRoomId) {
-                        ws.send(encode({ type: 'room_creation_failed', reason: 'No available ID found.' }), { binary: true });
-                        throw new Error('Failed to generate unique room ID!');
-                    }
-
-                    const roomCrdtManager = new CRDTManager(this.#debug); // Create the room's crdt manager
-
                     // Event callback with potential initial storage modifications
-                    const reviewedStorage = await this.#triggerEvent("roomCreationRequested", { roomId: newRoomId, clientId: ws.clientId, initialStorage: structuredClone({ ...data.initialStorage }) });
+                    const reviewedStorage = await this.#triggerEvent("roomCreationRequested", { clientId: ws.clientId, initialStorage: structuredClone({ ...data.initialStorage }) });
                     if (typeof reviewedStorage === 'object') data.initialStorage = reviewedStorage;
                     if (reviewedStorage === false) {
                         ws.send(encode({
@@ -2311,33 +2293,21 @@ class PlaySocketServer {
                         return;
                     }
 
-                    // Check if client/creator is still connected
+                    // Check if client/creator is still connected - abort if not
                     if (!this.#clients.has(ws.clientId)) {
                         if (this.#debug) console.log(`Room creation cancelled - client ${ws.clientId} disconnected during event callback.`);
-                        return; // Abort room creation if client is no longer connected
+                        return;
                     }
 
-                    // Load initial storage if provided
-                    if (data.initialStorage) {
-                        Object.entries(data.initialStorage)?.forEach(([key, value]) => {
-                            roomCrdtManager.updateProperty(key, "set", value);
-                        });
+                    try {
+                        const newRoom = this.createRoom(data.initialStorage, data.size, ws.clientId);
+                        this.#rooms[newRoom.id].participants.push(ws.clientId); // Add client to the room
+                        this.#clientRooms.set(ws.clientId, newRoom.id); // Add client to the client-room map
+                        ws.send(encode({ type: 'room_created', state: newRoom.state, roomId: newRoom.id }), { binary: true });
+                    } catch (error) {
+                        console.error("PlaySocket error creating room:", error);
+                        ws.send(encode({ type: 'room_creation_failed', reason: error.message }), { binary: true });
                     }
-
-                    // Create room
-                    const maxSize = Math.min(Number(data.size), 100) || 100; // Max. limit is 100 clients / room
-                    this.#roomVersions.set(newRoomId, 0); // Start with version 0
-                    this.#rooms[newRoomId] = {
-                        participants: [ws.clientId],
-                        host: ws.clientId,
-                        maxSize,
-                        crdtManager: roomCrdtManager
-                    };
-                    this.#clientRooms.set(ws.clientId, newRoomId); // Add client to the room
-
-                    ws.send(encode({ type: 'room_created', state: roomCrdtManager.getState, roomId: newRoomId, size: maxSize }), { binary: true });
-                    this.#triggerEvent("roomCreated", newRoomId);
-                    if (this.#debug) console.log(`Room ${newRoomId} created with initial storage:`, data.initialStorage);
                     break;
                 }
 
@@ -2356,7 +2326,7 @@ class PlaySocketServer {
 
                     if (!room) return rejectJoin("Room not found.");
                     if (this.#clientRooms.get(ws.clientId)) return rejectJoin("Already in a room.");
-                    if (room.participants.length >= room.maxSize) return rejectJoin("Room full.");
+                    if (room.participants.length >= room.size) return rejectJoin("Room full.");
 
                     room.participants.push(ws.clientId);
                     this.#clientRooms.set(ws.clientId, roomId);
@@ -2438,7 +2408,7 @@ class PlaySocketServer {
                     break;
             }
         } catch (error) {
-            console.error('Error in message handler:', error);
+            console.error('PlaySocket error in message handler:', error);
         }
     }
 
@@ -2557,11 +2527,8 @@ class PlaySocketServer {
             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
-                this.#roomVersions.delete(roomId); // Delete room version
-                this.#triggerEvent("roomDestroyed", roomId);
-                if (this.#debug) console.log("Deleted room with id " + roomId + ".");
+            if (room.participants?.length === 0 && room.host !== "server") {
+                this.destroyRoom(roomId); // Destroy room if now empty & not created by server
                 roomId = null; // If room was destroyed, set roomId to null
             } else {
                 // Notify remaining participants
@@ -2669,16 +2636,72 @@ class PlaySocketServer {
         }
     }
 
+    /**
+     * Create a room from the server
+     * @param {object} [initialStorage] - Optional initial storage object
+     * @param {number} [size] - Max. room size, up to 100 (defaults to 100)
+     * @param {string} [host] - Host ID, defaults to "server" (when set to "server", room will not be deleted if all clients leave)
+     * @returns {object} - Object containing room state and room ID
+     */
+    createRoom(initialStorage, size, host = "server") {
+        let newRoomId;
+
+        for (let i = 0; i < 100; i++) {
+            const id = this.#generateId();
+            if (!this.#rooms[id]) {
+                newRoomId = id;
+                break;
+            }
+        }
+
+        if (!newRoomId) throw new Error("No available ID found.")
+        const roomCrdtManager = new CRDTManager(this.#debug);
+
+        if (initialStorage) Object.entries(initialStorage)?.forEach(([key, value]) => {
+            roomCrdtManager.updateProperty(key, "set", value);
+        });
+
+        this.#roomVersions.set(newRoomId, 0);
+        this.#rooms[newRoomId] = {
+            participants: [],
+            host,
+            size: Math.min(Number(size), 100) || 100,
+            crdtManager: roomCrdtManager
+        };
+
+        this.#triggerEvent("roomCreated", newRoomId);
+        if (this.#debug) console.log(`Room ${newRoomId} created with initial storage:`, initialStorage);
+        return { state: roomCrdtManager.getState, id: newRoomId };
+    }
+
+    /**
+     * Destroy a room
+     * @param {string} roomId - Room ID
+     */
+    destroyRoom(roomId) {
+        const room = this.#rooms[roomId];
+        if (!room) return; // Return if room does not exist
+
+        // Disconnect participants if still in room
+        const participants = room.participants;
+        participants.forEach((clientId) => {
+            this.kick(clientId, "Room destroyed by server.");
+        });
+
+        // Delete the room
+        delete this.#rooms[roomId];
+        this.#roomVersions.delete(roomId); // Delete room version (used to ensure all clients are up-2-date)
+        this.#triggerEvent("roomDestroyed", roomId);
+        if (this.#debug) console.log("Deleted room with id " + roomId + ".");
+    }
+
     /**
      * Close all client connections, then close the websocket and http server
      */
     stop() {
         clearInterval(this.#heartbeatInterval);
         if (this.#wss) {
-            this.#clients.forEach(client => {
-                client.send(encode({ type: 'server_stopped' }), { binary: true });
-                client.close();
-            });
+            this.#clients.forEach((client, clientId) => this.kick(clientId, "Server restart."));
             this.#wss.close();
         }
         if (this.#server && this.#ownsServer) this.#server.close(() => { console.log('PlaySocket server stopped.'); });

package/package.json

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