@signe/room 1.2.1 → 1.4.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Request as Request$1, AnalyticsEngineDataset, WebSocket, R2Bucket, KVNamespace, DurableObjectState, DurableObjectStorage, VectorizeIndex } from '@cloudflare/workers-types';
+import { Request as Request$1, WebSocket, DurableObjectState, AnalyticsEngineDataset, DurableObjectStorage, VectorizeIndex, R2Bucket, KVNamespace } from '@cloudflare/workers-types';
 import { z } from 'zod';
 
 type AssetFetcher = {
@@ -47,16 +47,6 @@ type Context = {
     bindings: CustomBindings;
 };
 type AI = Record<string, never>;
-type Lobby = {
-    id: string;
-    env: Record<string, unknown>;
-    ai: AI;
-    parties: Context["parties"];
-    vectorize: Context["vectorize"];
-    analytics: AnalyticsEngineDataset;
-    assets: AssetFetcher;
-    bindings: CustomBindings;
-};
 type ImmutablePrimitive = undefined | null | boolean | string | number;
 type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>;
 type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
@@ -191,7 +181,7 @@ interface RoomOptions {
     throttleSync?: number;
     hibernate?: boolean;
     guards?: RoomGuardFn[];
-    disconnectTimeout?: number;
+    sessionExpiryTime?: number;
 }
 declare function Room(options: RoomOptions): (target: any) => void;
 /**
@@ -227,6 +217,7 @@ declare class MockPartyRoom {
     constructor(id?: string);
     connection(client: any): void;
     broadcast(data: any): void;
+    getConnections(): Map<string, MockPartySocket>;
     clear(): void;
 }
 declare class MockConnection {
@@ -262,8 +253,6 @@ declare class Server implements Server$1 {
     readonly room: Room$1;
     subRoom: any;
     rooms: any[];
-    private timeoutHandles;
-    static onBeforeConnect(request: Request, lobby: Lobby): Promise<Request>;
     /**
      * @constructor
      * @param {Party.Room} room - The room object representing the current game or application instance.
@@ -301,13 +290,13 @@ declare class Server implements Server$1 {
      * ```
      */
     onStart(): Promise<void>;
+    private garbageCollector;
     /**
      * @method createRoom
      * @private
      * @async
      * @param {CreateRoomOptions} [options={}] - Options for creating the room.
      * @returns {Promise<Object>} The created room instance.
-     * @throws {Error} If no matching room is found.
      *
      * @example
      * ```typescript
@@ -352,8 +341,10 @@ declare class Server implements Server$1 {
      * ```
      */
     private getUsersProperty;
+    private getUsersPropName;
     private getSession;
     private saveSession;
+    private updateSessionConnection;
     private deleteSession;
     /**
      * @method onConnect
@@ -406,6 +397,8 @@ declare class Server implements Server$1 {
      */
     onClose(conn: Connection): Promise<void>;
     onAlarm(): Promise<void>;
+    onError(connection: Connection, error: Error): Promise<void>;
+    onRequest(req: Request): Promise<Response>;
 }
 
 export { Action, ClientIo, Guard, MockConnection, Room, RoomGuard, type RoomOptions, Server, ServerIo };

package/dist/index.js

@@ -20,7 +20,7 @@ function Room(options) {
     target.maxUsers = options.maxUsers;
     target.throttleStorage = options.throttleStorage;
     target.throttleSync = options.throttleSync;
-    target.disconnectTimeout = options.disconnectTimeout ?? 0;
+    target.sessionExpiryTime = options.sessionExpiryTime ?? 5 * 60 * 1e3;
     if (options.guards) {
       target["_roomGuards"] = options.guards;
     }
@@ -44,11 +44,6 @@ function Guard(guards) {
 __name(Guard, "Guard");
 
 // ../sync/src/utils.ts
-function isClass(obj) {
-  return typeof obj === "function" && obj.prototype && obj.prototype.constructor === obj;
-}
-__name(isClass, "isClass");
-var isObject = /* @__PURE__ */ __name((item) => item && typeof item === "object" && !Array.isArray(item) && item !== null, "isObject");
 function generateShortUUID() {
   const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
   let uuid = "";
@@ -81,7 +76,7 @@ var Storage = class {
 };
 
 // src/mock.ts
-var MockPartySocket = class MockPartySocket2 {
+var MockPartySocket = class {
   static {
     __name(this, "MockPartySocket");
   }
@@ -120,6 +115,9 @@ var MockPartyRoom = class MockPartyRoom2 {
       client._trigger("message", data);
     });
   }
+  getConnections() {
+    return this.clients;
+  }
   clear() {
     this.clients.clear();
   }
@@ -139,172 +137,7 @@ var ClientIo = MockPartySocket;
 // src/server.ts
 import { dset as dset2 } from "dset";
 import z from "zod";
-
-// ../sync/src/core.ts
-import { ArraySubject, ObjectSubject, isSignal } from "@signe/reactive";
-var syncClass = /* @__PURE__ */ __name((instance, options = {}) => {
-  const cacheSync = /* @__PURE__ */ new Map();
-  const cachePersist = /* @__PURE__ */ new Set();
-  instance.$valuesChanges = {
-    set: /* @__PURE__ */ __name((path, value) => {
-      cacheSync.set(path, value);
-      options.onSync?.(cacheSync);
-    }, "set"),
-    setPersist: /* @__PURE__ */ __name((path) => {
-      if (path == "") path = ".";
-      cachePersist.add(path);
-      options.onPersist?.(cachePersist);
-    }, "setPersist"),
-    has: /* @__PURE__ */ __name((path) => {
-      return cacheSync.has(path);
-    }, "has"),
-    get: /* @__PURE__ */ __name((path) => {
-      return cacheSync.get(path);
-    }, "get")
-  };
-  createSyncClass(instance);
-}, "syncClass");
-function createStatesSnapshot(instance) {
-  let persistObject = {};
-  if (instance.$snapshot) {
-    for (const key of instance.$snapshot.keys()) {
-      const signal = instance.$snapshot.get(key);
-      const persist = signal.options.persist ?? true;
-      let value = signal();
-      if (isObject(value) || Array.isArray(value)) {
-        break;
-      }
-      if (persist) {
-        persistObject[key] = value;
-      }
-    }
-  }
-  return persistObject;
-}
-__name(createStatesSnapshot, "createStatesSnapshot");
-function setMetadata(target, key, value) {
-  const meta = target.constructor._propertyMetadata;
-  const propId = meta?.get(key);
-  if (propId) {
-    if (isSignal(target[propId])) {
-      target[propId].set(value);
-    } else {
-      target[propId] = value;
-    }
-  }
-}
-__name(setMetadata, "setMetadata");
-var createSyncClass = /* @__PURE__ */ __name((currentClass, parentKey = null, parentClass = null, path = "") => {
-  currentClass.$path = path;
-  if (parentClass) {
-    currentClass.$valuesChanges = parentClass.$valuesChanges;
-  }
-  if (parentKey) {
-    setMetadata(currentClass, "id", parentKey);
-  }
-  if (currentClass.$snapshot) {
-    for (const key of currentClass.$snapshot.keys()) {
-      const signal = currentClass.$snapshot.get(key);
-      const syncToClient = signal.options.syncToClient ?? true;
-      const persist = signal.options.persist ?? true;
-      let value = signal();
-      if (isObject(value) || Array.isArray(value)) {
-        value = {
-          ...value
-        };
-      }
-      const newPath = (path ? path + "." : "") + key;
-      if (syncToClient) {
-        currentClass.$valuesChanges.set(newPath, value);
-      }
-      if (persist) {
-        if (parentClass) currentClass.$valuesChanges.setPersist(path);
-      }
-    }
-  }
-}, "createSyncClass");
-
-// ../sync/src/load.ts
-import { isSignal as isSignal2 } from "@signe/reactive";
-function load(rootInstance, values, valueIsObject) {
-  if (valueIsObject) {
-    loadFromObject(rootInstance, values);
-  } else {
-    loadFromPaths(rootInstance, values);
-  }
-}
-__name(load, "load");
-function loadFromPaths(rootInstance, values) {
-  for (const [path, value] of Object.entries(values)) {
-    const parts = path.split(".");
-    loadValue(rootInstance, parts, value);
-  }
-}
-__name(loadFromPaths, "loadFromPaths");
-function loadFromObject(rootInstance, values, currentPath = "") {
-  for (let key in values) {
-    const value = values[key];
-    const newPath = currentPath ? `${currentPath}.${key}` : key;
-    if (typeof value === "object" && !Array.isArray(value) && value !== null) {
-      loadFromObject(rootInstance, value, newPath);
-    } else {
-      const parts = newPath.split(".");
-      loadValue(rootInstance, parts, value);
-    }
-  }
-}
-__name(loadFromObject, "loadFromObject");
-function loadValue(rootInstance, parts, value) {
-  let current = rootInstance;
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    if (i === parts.length - 1) {
-      if (value == "$delete") {
-        if (isSignal2(current)) {
-          current = current();
-        }
-        Reflect.deleteProperty(current, part);
-      } else if (current[part]?._subject) {
-        current[part].set(value);
-      } else {
-        current[part] = value;
-      }
-    } else {
-      if (isSignal2(current)) {
-        current = current();
-      }
-      const currentValue = current[part];
-      if (currentValue === void 0) {
-        const parentInstance = getByPath(rootInstance, parts.slice(0, i).join("."));
-        const classType = parentInstance?.options?.classType;
-        if (classType) {
-          current[part] = !isClass(classType) ? classType(part) : new classType();
-          setMetadata(current[part], "id", part);
-        } else {
-          current[part] = {};
-        }
-      }
-      current = current[part];
-    }
-  }
-}
-__name(loadValue, "loadValue");
-function getByPath(root, path) {
-  const parts = path.split(".");
-  let current = root;
-  for (const part of parts) {
-    if (isSignal2(current)) {
-      current = current();
-    }
-    if (current[part]) {
-      current = current[part];
-    } else {
-      return void 0;
-    }
-  }
-  return current;
-}
-__name(getByPath, "getByPath");
+import { createStatesSnapshot, getByPath, load, syncClass, DELETE_TOKEN, generateShortUUID as generateShortUUID2 } from "@signe/sync";
 
 // src/utils.ts
 import { dset } from "dset";
@@ -316,10 +149,10 @@ async function awaitReturn(val) {
   return isPromise(val) ? await val : val;
 }
 __name(awaitReturn, "awaitReturn");
-function isClass2(obj) {
+function isClass(obj) {
   return typeof obj === "function" && obj.prototype && obj.prototype.constructor === obj;
 }
-__name(isClass2, "isClass");
+__name(isClass, "isClass");
 function throttle(func, wait) {
   let timeout = null;
   let lastArgs = null;
@@ -399,12 +232,6 @@ var Server = class {
   room;
   subRoom;
   rooms;
-  timeoutHandles;
-  static async onBeforeConnect(request, lobby) {
-    const token = new URL(request.url).searchParams.get("token") ?? "";
-    request.headers.set("X-User-ID", token);
-    return request;
-  }
   /**
   * @constructor
   * @param {Party.Room} room - The room object representing the current game or application instance.
@@ -418,7 +245,6 @@ var Server = class {
     this.room = room;
     this.subRoom = null;
     this.rooms = [];
-    this.timeoutHandles = /* @__PURE__ */ new Map();
   }
   /**
   * @readonly
@@ -453,13 +279,51 @@ var Server = class {
       this.subRoom = await this.createRoom();
     }
   }
+  async garbageCollector(options) {
+    const subRoom = await this.getSubRoom();
+    if (!subRoom) return;
+    const activeConnections = [
+      ...this.room.getConnections()
+    ];
+    const activePrivateIds = new Set(activeConnections.map((conn) => conn.id));
+    try {
+      const sessions = await this.room.storage.list();
+      const users = this.getUsersProperty(subRoom);
+      const usersPropName = this.getUsersPropName(subRoom);
+      const validPublicIds = /* @__PURE__ */ new Set();
+      const expiredPublicIds = /* @__PURE__ */ new Set();
+      const SESSION_EXPIRY_TIME = options.sessionExpiryTime;
+      const now = Date.now();
+      for (const [key, session] of sessions) {
+        if (!key.startsWith("session:")) continue;
+        const privateId = key.replace("session:", "");
+        const typedSession = session;
+        if (!activePrivateIds.has(privateId) && !typedSession.connected && now - typedSession.created > SESSION_EXPIRY_TIME) {
+          await this.deleteSession(privateId);
+          expiredPublicIds.add(typedSession.publicId);
+        } else if (typedSession && typedSession.publicId) {
+          validPublicIds.add(typedSession.publicId);
+        }
+      }
+      if (users && usersPropName) {
+        const currentUsers = users();
+        for (const publicId in currentUsers) {
+          if (expiredPublicIds.has(publicId) && !validPublicIds.has(publicId)) {
+            delete currentUsers[publicId];
+            await this.room.storage.delete(`${usersPropName}.${publicId}`);
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Error in garbage collector:", error);
+    }
+  }
   /**
   * @method createRoom
   * @private
   * @async
   * @param {CreateRoomOptions} [options={}] - Options for creating the room.
   * @returns {Promise<Object>} The created room instance.
-  * @throws {Error} If no matching room is found.
   * 
   * @example
   * ```typescript
@@ -473,6 +337,7 @@ var Server = class {
   async createRoom(options = {}) {
     let instance;
     let init = true;
+    let initPersist = true;
     for (let room of this.rooms) {
       const params = extractParams(room.path, this.room.id);
       if (params) {
@@ -481,21 +346,23 @@ var Server = class {
       }
     }
     if (!instance) {
-      throw new Error("Room not found");
+      return null;
     }
     const loadMemory = /* @__PURE__ */ __name(async () => {
       const root = await this.room.storage.get(".");
       const memory = await this.room.storage.list();
       const tmpObject = root || {};
       for (let [key, value] of memory) {
+        if (key.startsWith("session:")) {
+          continue;
+        }
         if (key == ".") {
           continue;
         }
         dset2(tmpObject, key, value);
       }
-      load(instance, tmpObject);
+      load(instance, tmpObject, true);
     }, "loadMemory");
-    await loadMemory();
     instance.$memoryAll = {};
     const syncCb = /* @__PURE__ */ __name((values) => {
       if (options.getMemoryAll) {
@@ -513,10 +380,18 @@ var Server = class {
       values.clear();
     }, "syncCb");
     const persistCb = /* @__PURE__ */ __name(async (values) => {
-      for (let path of values) {
+      if (initPersist) {
+        values.clear();
+        return;
+      }
+      for (let [path, value] of values) {
         const _instance = path == "." ? instance : getByPath(instance, path);
         const itemValue = createStatesSnapshot(_instance);
-        await this.room.storage.put(path, itemValue);
+        if (value == DELETE_TOKEN) {
+          await this.room.storage.delete(path);
+        } else {
+          await this.room.storage.put(path, itemValue);
+        }
       }
       values.clear();
     }, "persistCb");
@@ -524,6 +399,8 @@ var Server = class {
       onSync: throttle(syncCb, instance["throttleSync"] ?? 500),
       onPersist: throttle(persistCb, instance["throttleStorage"] ?? 2e3)
     });
+    await loadMemory();
+    initPersist = false;
     return instance;
   }
   /**
@@ -574,6 +451,10 @@ var Server = class {
     }
     return null;
   }
+  getUsersPropName(subRoom) {
+    const meta = subRoom.constructor["_propertyMetadata"];
+    return meta?.get("users");
+  }
   async getSession(privateId) {
     if (!privateId) return null;
     try {
@@ -584,7 +465,21 @@ var Server = class {
     }
   }
   async saveSession(privateId, data) {
-    await this.room.storage.put(`session:${privateId}`, data);
+    const sessionData = {
+      ...data,
+      created: data.created || Date.now(),
+      connected: data.connected !== void 0 ? data.connected : true
+    };
+    await this.room.storage.put(`session:${privateId}`, sessionData);
+  }
+  async updateSessionConnection(privateId, connected) {
+    const session = await this.getSession(privateId);
+    if (session) {
+      await this.saveSession(privateId, {
+        ...session,
+        connected
+      });
+    }
   }
   async deleteSession(privateId) {
     await this.room.storage.delete(`session:${privateId}`);
@@ -609,6 +504,14 @@ var Server = class {
     const subRoom = await this.getSubRoom({
       getMemoryAll: true
     });
+    if (!subRoom) {
+      conn.close();
+      return;
+    }
+    const sessionExpiryTime = subRoom.constructor.sessionExpiryTime;
+    await this.garbageCollector({
+      sessionExpiryTime
+    });
     const roomGuards = subRoom.constructor["_roomGuards"] || [];
     for (const guard of roomGuards) {
       const isAuthorized = await guard(conn, ctx);
@@ -617,34 +520,35 @@ var Server = class {
         return;
       }
     }
-    const providedPrivateId = ctx.request?.headers.get("X-User-ID");
-    const existingSession = providedPrivateId ? await this.getSession(providedPrivateId) : null;
-    const publicId = existingSession?.publicId || generateShortUUID();
-    const privateId = existingSession ? providedPrivateId : generateShortUUID();
+    const existingSession = await this.getSession(conn.id);
+    const publicId = existingSession?.publicId || generateShortUUID2();
     let user = null;
     const signal = this.getUsersProperty(subRoom);
+    const usersPropName = this.getUsersPropName(subRoom);
     if (signal) {
       const { classType } = signal.options;
       if (!existingSession?.publicId) {
-        user = isClass2(classType) ? new classType() : classType(conn, ctx);
+        user = isClass(classType) ? new classType() : classType(conn, ctx);
         signal()[publicId] = user;
+        const snapshot = createStatesSnapshot(user);
+        this.room.storage.put(`${usersPropName}.${publicId}`, snapshot);
       }
       if (!existingSession) {
-        await this.saveSession(privateId, {
+        await this.saveSession(conn.id, {
           publicId
         });
+      } else {
+        await this.updateSessionConnection(conn.id, true);
       }
     }
     await awaitReturn(subRoom["onJoin"]?.(user, conn, ctx));
     conn.setState({
-      publicId,
-      privateId
+      publicId
     });
     conn.send(JSON.stringify({
       type: "sync",
       value: {
         pId: publicId,
-        privateId,
         ...subRoom.$memoryAll
       }
     }));
@@ -725,60 +629,57 @@ var Server = class {
   */
   async onClose(conn) {
     const subRoom = await this.getSubRoom();
+    if (!subRoom) {
+      return;
+    }
     const signal = this.getUsersProperty(subRoom);
     if (!conn.state) {
       return;
     }
-    const { publicId, privateId } = conn.state;
+    const privateId = conn.id;
+    const { publicId } = conn.state;
     const user = signal?.()[publicId];
     if (!user) return;
-    if (privateId) {
-      await this.saveSession(privateId, {
+    await awaitReturn(subRoom["onLeave"]?.(user, conn));
+    await this.updateSessionConnection(privateId, false);
+    this.room.broadcast(JSON.stringify({
+      type: "user_disconnected",
+      value: {
         publicId
-      });
-    }
-    const existingTimeout = this.timeoutHandles.get(privateId);
-    if (existingTimeout) {
-      clearTimeout(existingTimeout);
-      this.timeoutHandles.delete(privateId);
-    }
-    const cleanup = /* @__PURE__ */ __name(async () => {
-      await awaitReturn(subRoom["onLeave"]?.(user, conn));
-      if (signal) {
-        delete signal()[publicId];
-      }
-      if (privateId) {
-        await this.deleteSession(privateId);
       }
-      this.room.broadcast(JSON.stringify({
-        type: "user_disconnected",
-        value: {
-          publicId
-        }
-      }));
-      this.timeoutHandles.delete(privateId);
-    }, "cleanup");
-    const disconnectTimeout = subRoom.constructor.disconnectTimeout ?? 0;
-    if (disconnectTimeout > 0) {
-      if (user.status) {
-        user.status.set("offline");
-      }
-      this.room.broadcast(JSON.stringify({
-        type: "user_offline",
-        value: {
-          publicId
-        }
-      }));
-      const timeout = setTimeout(cleanup, disconnectTimeout);
-      this.timeoutHandles.set(privateId, timeout);
-    } else {
-      await cleanup();
-    }
+    }));
   }
   async onAlarm() {
     const subRoom = await this.getSubRoom();
     await awaitReturn(subRoom["onAlarm"]?.(subRoom));
   }
+  async onError(connection, error) {
+    const subRoom = await this.getSubRoom();
+    await awaitReturn(subRoom["onError"]?.(connection, error));
+  }
+  async onRequest(req) {
+    const subRoom = await this.getSubRoom();
+    const res = /* @__PURE__ */ __name((body, status) => {
+      return new Response(JSON.stringify(body), {
+        status
+      });
+    }, "res");
+    if (!subRoom) {
+      return res({
+        error: "Not found"
+      }, 404);
+    }
+    const response = await awaitReturn(subRoom["onRequest"]?.(req, this.room));
+    if (!response) {
+      return res({
+        error: "Not found"
+      }, 404);
+    }
+    if (response instanceof Response) {
+      return response;
+    }
+    return res(response, 200);
+  }
 };
 export {
   Action,