@signe/room 2.3.3 → 2.4.0

package/dist/index.d.ts

@@ -453,7 +453,7 @@ declare class Server implements Server$1 {
      * @method onClose
      * @async
      * @param {Party.Connection} conn - The connection object of the disconnecting user.
-     * @description Handles user disconnection, removing them from the room and triggering the onLeave event.
+     * @description Handles user disconnection, removing them from the room and triggering the onLeave event..
      * @returns {Promise<void>}
      *
      * @example
@@ -475,6 +475,16 @@ declare class Server implements Server$1 {
      * @returns {Promise<Response>} The response to return to the client
      */
     onRequest(req: Request$1): Promise<Response>;
+    /**
+     * @method handleSessionRestore
+     * @private
+     * @async
+     * @param {Party.Request} req - The HTTP request for session restore
+     * @param {ServerResponse} res - The response object
+     * @description Handles session restoration from transfer data, creates session from privateId
+     * @returns {Promise<Response>} The response to return to the client
+     */
+    private handleSessionRestore;
     /**
      * @method handleDirectRequest
      * @private
@@ -839,4 +849,57 @@ declare class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
     private createShard;
 }
 
-export { Action, ClientIo, Guard, MockConnection, Request, type RequestOptions, Room, RoomGuard, type RoomInterceptorPacket, type RoomMethods, type RoomOnJoin, type RoomOnLeave, type RoomOptions, Server, ServerIo, ServerResponse, Shard, type ShardOptions, WorldRoom, request, testRoom };
+/**
+ * @description Factory function that creates a session guard with access to room storage
+ * @param {Party.Storage} storage - The room storage instance
+ * @returns {Function} - The guard function
+ *
+ * @example
+ * ```typescript
+ * import { createRequireSessionGuard } from "./session.guard";
+ *
+ * export class GameRoom {
+ *   constructor(private room: Party.Room) {}
+ *
+ *   @Action("sendMessage")
+ *   @Guard([createRequireSessionGuard(this.room.storage)])
+ *   async sendMessage(user: User, message: string, conn: Party.Connection) {
+ *     // This action will only execute if the user has a valid session
+ *     this.$broadcast({ type: "message", user, message });
+ *   }
+ * }
+ * ```
+ */
+declare function createRequireSessionGuard(storage: Storage$1): (sender: Connection, value: any) => Promise<boolean>;
+/**
+ * @description Guard function that verifies if a user session exists (for room and request guards)
+ * @param {Party.Connection} sender - The connection object of the sender
+ * @param {any} value - The value/payload sent with the action or request
+ * @param {Party.Room} room - The room instance
+ * @returns {Promise<boolean>} - Returns true if session exists, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { requireSession } from "./session.guard";
+ *
+ * // For room guards
+ * @Room({
+ *   path: "game-{id}",
+ *   guards: [requireSession]
+ * })
+ * export class GameRoom {
+ *   // Room implementation
+ * }
+ *
+ * // For request guards
+ * @Request({ path: '/api/data', method: 'GET' })
+ * @Guard([requireSession])
+ * async getData(req: Party.Request, res: ServerResponse) {
+ *   // This request will only execute if the user has a valid session
+ *   return res.success({ data: "protected data" });
+ * }
+ * ```
+ */
+declare const requireSession: (sender: Connection, value: any, room: Room$1) => Promise<boolean>;
+
+export { Action, ClientIo, Guard, MockConnection, Request, type RequestOptions, Room, RoomGuard, type RoomInterceptorPacket, type RoomMethods, type RoomOnJoin, type RoomOnLeave, type RoomOptions, Server, ServerIo, ServerResponse, Shard, type ShardOptions, WorldRoom, createRequireSessionGuard, request, requireSession, testRoom };

package/dist/index.js

@@ -615,6 +615,101 @@ var Server = class {
     instance.$broadcast = (obj) => {
       return this.broadcast(obj, instance);
     };
+    instance.$sessionTransfer = async (userOrPublicId, targetRoomId) => {
+      let user;
+      let publicId = null;
+      const signal2 = this.getUsersProperty(instance);
+      if (!signal2) {
+        console.error("[sessionTransfer] `users` property not defined in the room.");
+        return null;
+      }
+      if (typeof userOrPublicId === "string") {
+        publicId = userOrPublicId;
+        user = signal2()[publicId];
+        if (!user) {
+          console.error(`[sessionTransfer] User with publicId ${publicId} not found.`);
+          return null;
+        }
+      } else {
+        user = userOrPublicId;
+        const users = signal2();
+        for (const [id2, u] of Object.entries(users)) {
+          if (u === user) {
+            publicId = id2;
+            break;
+          }
+        }
+        if (!publicId && user && typeof user === "object") {
+          for (const [id2, u] of Object.entries(users)) {
+            if (u && typeof u === "object") {
+              if (u.constructor === user.constructor) {
+                publicId = id2;
+                break;
+              }
+            }
+          }
+        }
+        if (!publicId) {
+          console.error("[sessionTransfer] User not found in users collection.", {
+            userType: user?.constructor?.name,
+            userKeys: user ? Object.keys(user) : "null",
+            usersCount: Object.keys(users).length,
+            userIds: Object.keys(users)
+          });
+          return null;
+        }
+      }
+      const sessions = await this.room.storage.list();
+      let userSession = null;
+      let privateId = null;
+      for (const [key, session] of sessions) {
+        if (key.startsWith("session:") && session.publicId === publicId) {
+          userSession = session;
+          privateId = key.replace("session:", "");
+          break;
+        }
+      }
+      if (!userSession || !privateId) {
+        console.error(`[sessionTransfer] Session for publicId ${publicId} not found.`);
+        return null;
+      }
+      const usersPropName = this.getUsersPropName(instance);
+      if (!usersPropName) {
+        console.error("[sessionTransfer] `users` property not defined in the room.");
+        return null;
+      }
+      const userSnapshot = createStatesSnapshot(user);
+      const transferData = {
+        privateId,
+        userSnapshot,
+        sessionState: userSession.state,
+        publicId
+      };
+      try {
+        const targetRoomParty = this.room.context.parties.main.get(targetRoomId);
+        const response2 = await targetRoomParty.fetch("/session-transfer", {
+          method: "POST",
+          body: JSON.stringify(transferData),
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        if (!response2.ok) {
+          throw new Error(`Transfer request failed: ${await response2.text()}`);
+        }
+        const { transferToken } = await response2.json();
+        await this.deleteSession(privateId);
+        await this.room.storage.delete(`${usersPropName}.${publicId}`);
+        const currentUsers = signal2();
+        if (currentUsers[publicId]) {
+          delete currentUsers[publicId];
+        }
+        return transferToken;
+      } catch (error) {
+        console.error(`[sessionTransfer] Failed to transfer session to room ${targetRoomId}:`, error);
+        return null;
+      }
+    };
     const syncCb = /* @__PURE__ */ __name((values) => {
       if (options.getMemoryAll) {
         buildObject(values, instance.$memoryAll);
@@ -805,29 +900,46 @@ var Server = class {
     });
     const roomGuards = subRoom.constructor["_roomGuards"] || [];
     for (const guard of roomGuards) {
-      const isAuthorized = await guard(conn, ctx);
+      const isAuthorized = await guard(conn, ctx, this.room);
       if (!isAuthorized) {
         conn.close();
         return;
       }
     }
+    let transferToken = null;
+    if (ctx.request?.url) {
+      const url = new URL(ctx.request.url);
+      transferToken = url.searchParams.get("transferToken");
+    }
+    let transferData = null;
+    if (transferToken) {
+      transferData = await this.room.storage.get(`transfer:${transferToken}`);
+      if (transferData) {
+        await this.room.storage.delete(`transfer:${transferToken}`);
+      }
+    }
     const existingSession = await this.getSession(conn.id);
-    const publicId = existingSession?.publicId || generateShortUUID2();
+    const publicId = existingSession?.publicId || transferData?.publicId || generateShortUUID2();
     let user = null;
     const signal2 = this.getUsersProperty(subRoom);
     const usersPropName = this.getUsersPropName(subRoom);
     if (signal2) {
       const { classType } = signal2.options;
       if (!existingSession?.publicId) {
-        user = isClass(classType) ? new classType() : classType(conn, ctx);
-        signal2()[publicId] = user;
-        const snapshot = createStatesSnapshot(user);
-        this.room.storage.put(`${usersPropName}.${publicId}`, snapshot);
+        if (transferData?.restored && signal2()[publicId]) {
+          user = signal2()[publicId];
+        } else {
+          user = isClass(classType) ? new classType() : classType(conn, ctx);
+          signal2()[publicId] = user;
+          const snapshot = createStatesSnapshot(user);
+          this.room.storage.put(`${usersPropName}.${publicId}`, snapshot);
+        }
       } else {
         user = signal2()[existingSession.publicId];
       }
       if (!existingSession) {
-        await this.saveSession(conn.id, {
+        const sessionPrivateId = transferData?.privateId || conn.id;
+        await this.saveSession(sessionPrivateId, {
           publicId
         });
       } else {
@@ -1115,7 +1227,7 @@ var Server = class {
   * @method onClose
   * @async
   * @param {Party.Connection} conn - The connection object of the disconnecting user.
-  * @description Handles user disconnection, removing them from the room and triggering the onLeave event.
+  * @description Handles user disconnection, removing them from the room and triggering the onLeave event..
   * @returns {Promise<void>}
   * 
   * @example
@@ -1181,6 +1293,58 @@ var Server = class {
     return this.handleDirectRequest(req, res);
   }
   /**
+  * @method handleSessionRestore
+  * @private
+  * @async
+  * @param {Party.Request} req - The HTTP request for session restore
+  * @param {ServerResponse} res - The response object
+  * @description Handles session restoration from transfer data, creates session from privateId
+  * @returns {Promise<Response>} The response to return to the client
+  */
+  async handleSessionRestore(req, res) {
+    try {
+      const transferData = await req.json();
+      const { privateId, userSnapshot, sessionState, publicId } = transferData;
+      if (!privateId || !publicId) {
+        return res.badRequest("Missing privateId or publicId in transfer data");
+      }
+      const subRoom = await this.getSubRoom();
+      if (!subRoom) {
+        return res.serverError("Room not available");
+      }
+      await this.saveSession(privateId, {
+        publicId,
+        state: sessionState,
+        created: Date.now(),
+        connected: false
+        // Will be set to true when user connects
+      });
+      if (userSnapshot) {
+        const signal2 = this.getUsersProperty(subRoom);
+        const usersPropName = this.getUsersPropName(subRoom);
+        if (signal2 && usersPropName) {
+          const { classType } = signal2.options;
+          const user = isClass(classType) ? new classType() : classType();
+          load(user, userSnapshot, true);
+          signal2()[publicId] = user;
+          await this.room.storage.put(`${usersPropName}.${publicId}`, userSnapshot);
+        }
+      }
+      const transferToken = generateShortUUID2();
+      await this.room.storage.put(`transfer:${transferToken}`, {
+        privateId,
+        publicId,
+        restored: true
+      });
+      return res.success({
+        transferToken
+      });
+    } catch (error) {
+      console.error("Error restoring session:", error);
+      return res.serverError("Failed to restore session");
+    }
+  }
+  /**
   * @method handleDirectRequest
   * @private
   * @async
@@ -1193,6 +1357,10 @@ var Server = class {
     if (!subRoom) {
       return res.notFound();
     }
+    const url = new URL(req.url);
+    if (url.pathname.endsWith("/session-transfer") && req.method === "POST") {
+      return this.handleSessionRestore(req, res);
+    }
     const response2 = await this.tryMatchRequestHandler(req, res, subRoom);
     if (response2) {
       return response2;
@@ -1291,7 +1459,7 @@ var Server = class {
   */
   pathMatches(requestPath, handlerPath) {
     const pathRegexString = handlerPath.replace(/\//g, "\\/").replace(/:([^\/]+)/g, "([^/]+)");
-    const pathRegex = new RegExp(`^${pathRegexString}$`);
+    const pathRegex = new RegExp(`^${pathRegexString}`);
     return pathRegex.test(requestPath);
   }
   /**
@@ -1311,7 +1479,7 @@ var Server = class {
       }
     });
     const pathRegexString = handlerPath.replace(/\//g, "\\/").replace(/:([^\/]+)/g, "([^/]+)");
-    const pathRegex = new RegExp(`^${pathRegexString}$`);
+    const pathRegex = new RegExp(`^${pathRegexString}`);
     const matches = requestPath.match(pathRegex);
     if (matches && matches.length > 1) {
       for (let i = 0; i < paramNames.length; i++) {
@@ -2433,6 +2601,49 @@ WorldRoom = _ts_decorate([
     typeof party_exports === "undefined" || typeof void 0 === "undefined" ? Object : void 0
   ])
 ], WorldRoom);
+
+// src/session.guard.ts
+function createRequireSessionGuard(storage) {
+  return async (sender, value) => {
+    if (!sender || !sender.id) {
+      return false;
+    }
+    try {
+      const session = await storage.get(`session:${sender.id}`);
+      if (!session) {
+        return false;
+      }
+      const typedSession = session;
+      if (!typedSession.publicId) {
+        return false;
+      }
+      return true;
+    } catch (error) {
+      console.error("Error checking session in requireSession guard:", error);
+      return false;
+    }
+  };
+}
+__name(createRequireSessionGuard, "createRequireSessionGuard");
+var requireSession = /* @__PURE__ */ __name(async (sender, value, room) => {
+  if (!sender || !sender.id) {
+    return false;
+  }
+  try {
+    const session = await room.storage.get(`session:${sender.id}`);
+    if (!session) {
+      return false;
+    }
+    const typedSession = session;
+    if (!typedSession.publicId) {
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error("Error checking session in requireSession guard:", error);
+    return false;
+  }
+}, "requireSession");
 export {
   Action,
   ClientIo,
@@ -2446,7 +2657,9 @@ export {
   ServerResponse,
   Shard,
   WorldRoom,
+  createRequireSessionGuard,
   request,
+  requireSession,
   testRoom
 };
 //# sourceMappingURL=index.js.map