@signe/room 2.3.3 → 2.4.1

package/examples/game/app/client.tsx

@@ -1,12 +1,13 @@
 import { createRoot } from "react-dom/client";
 import  Admin  from "./components/Admin";
 import "./styles.css";
+import Room from "./components/Room";
 
 
 function App() {
   return (
     <main>
-      <Admin />
+      <Room />
     </main>
   );
 }

package/examples/game/app/components/Room.tsx

@@ -1,5 +1,5 @@
 import { useState, useEffect, useRef } from "react";
-import { connectionWorld } from '../../../../../sync/src/client';
+import { connectionRoom, connectionWorld } from '../../../../../sync/src/client';
 import { RoomSchema } from "../../shared/room.schema";
 import { effect } from "@signe/reactive";
 
@@ -7,7 +7,7 @@ export default function Room() {
   const [isConnected, setIsConnected] = useState(false);
   const [isConnecting, setIsConnecting] = useState(false);
   const [error, setError] = useState<string | null>(null);
-  const [roomId, setRoomId] = useState("quiz");
+  const [roomId, setRoomId] = useState("game");
   const [count, setCount] = useState(0);
   const socketRef = useRef<any>(null);
   const roomRef = useRef<any>(null);
@@ -21,11 +21,15 @@ export default function Room() {
       roomRef.current = new RoomSchema();
       
       // Connect to the room through the World service with auto-creation enabled
-      socketRef.current = await connectionWorld({
+      socketRef.current = await connectionRoom({
         host: 'http://localhost:1999',
+        id: 'test',
         room: roomId,
-        autoCreate: true // Enable auto-creation of room and shards
       }, roomRef.current);
+
+      socketRef.current.on('sync', (data) => {
+        console.log('sync', data);
+      })
       
       // Listen for disconnection events
       socketRef.current.on('disconnect', () => {

package/examples/game/party/game.room.ts

@@ -1,4 +1,4 @@
-import { Action, Guard, Room } from "../../../src";
+import { Action, Guard, requireSession, Room } from "../../../src";
 import { RoomSchema } from "../shared/room.schema";
 
 @Room({
@@ -10,10 +10,23 @@ export class GameRoom extends RoomSchema  {
     increment(player) {
         this.count.update((count) => count + 1); 
         player.score.update((score) => score + 1);
+        this.$sessionTransfer(player.id(), "protected-1");
     }
 
     async onRequest(req: Party.Request, room: any) {
        const map = await room.storage.list() as Map<string, any>;
        return Object.fromEntries(map);
     }
+} 
+
+@Room({
+    path: 'protected-{gameId}',
+    sessionExpiryTime: 5000, 
+    guards: [requireSession]
+})
+export class ProtectedRoom extends RoomSchema  {
+    @Action('increment')
+    increment(player) {
+        console.log('increment', player);
+    }
 } 

package/examples/game/party/server.ts

@@ -1,10 +1,10 @@
 import { Server, WorldRoom } from '../../../src';
 import type * as Party from "../../../src/types/party";
-import { GameRoom } from "./game.room";
+import { GameRoom, ProtectedRoom } from "./game.room";
 
 export default class MainServer extends Server {
   rooms = [
     GameRoom ,
-    WorldRoom
+    ProtectedRoom
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signe/room",
-  "version": "2.3.3",
+  "version": "2.4.1",
   "description": "",
   "main": "./dist/index.js",
   "keywords": [],
@@ -17,7 +17,7 @@
     "dset": "^3.1.3",
     "partysocket": "^1.0.1",
     "zod": "^3.23.8",
-    "@signe/sync": "2.3.3"
+    "@signe/sync": "2.4.1"
   },
   "publishConfig": {
     "access": "public"

package/src/index.ts

@@ -5,4 +5,5 @@ export * from './testing';
 export * from './shard';
 export * from './world';
 export * from './interfaces';
-export * from './request/response';
+export * from './request/response';
+export { requireSession, createRequireSessionGuard } from './session.guard';

package/src/mock.ts

@@ -47,14 +47,15 @@ export class MockPartyClient {
 }
 
 class MockLobby {
-  constructor(public server: Server) {}
+  constructor(public server: Server, public lobbyId: string) {}
 
   socket() {
     return new MockPartyClient(this.server)
   }
 
   fetch(url: string, options: any) {
-    return request(this.server, url, options)
+    const baseUrl = url.includes('shard') ? '' :( '/parties/main/' + this.lobbyId )
+    return request(this.server, baseUrl + url, options)
   }
 }
 
@@ -68,7 +69,7 @@ class MockContext {
   constructor(public room: MockPartyRoom, options: any = {}) {
    const parties = options.parties || {}
    for (let lobbyId in parties) {
-    this.parties.main.set(lobbyId, new MockLobby(parties[lobbyId](room)))
+    this.parties.main.set(lobbyId, new MockLobby(parties[lobbyId](room), lobbyId))
    }
   }
 }

package/src/server.ts

@@ -245,6 +245,126 @@ export class Server implements Party.Server {
     instance.$broadcast = (obj: any) => {
       return this.broadcast(obj, instance)
     }
+    instance.$sessionTransfer = async (userOrPublicId: any | string, targetRoomId: string) => {
+      let user: any;
+      let publicId: string | null = null;
+      
+      const signal = this.getUsersProperty(instance);
+      if (!signal) {
+        console.error('[sessionTransfer] `users` property not defined in the room.');
+        return null;
+      }
+      
+      // Check if the first parameter is a string (publicId) or an object (user)
+      if (typeof userOrPublicId === 'string') {
+        publicId = userOrPublicId;
+        user = signal()[publicId];
+        if (!user) {
+          console.error(`[sessionTransfer] User with publicId ${publicId} not found.`);
+          return null;
+        }
+      } else {
+        user = userOrPublicId;
+        const users = signal();
+        
+        // Try to find the publicId by comparing object references
+        for (const [id, u] of Object.entries(users)) {
+          if (u === user) {
+            publicId = id;
+            break;
+          }
+        }
+
+        // If not found by reference, try to find by user properties (fallback)
+        if (!publicId && user && typeof user === 'object') {
+          // Look for a unique identifier in the user object
+          for (const [id, u] of Object.entries(users)) {
+            if (u && typeof u === 'object') {
+              // Compare by constructor and other identifying properties
+              if (u.constructor === user.constructor) {
+                // Additional checks could be added here based on user structure
+                publicId = id;
+                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: any = null;
+      let privateId: string | null = null;
+
+      for (const [key, session] of sessions) {
+        if (key.startsWith('session:') && (session as any).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;
+      }
+
+      // Create a snapshot of the user state
+      const userSnapshot = createStatesSnapshot(user);
+
+      const transferData = {
+        privateId,
+        userSnapshot,
+        sessionState: userSession.state,
+        publicId
+      };
+
+      try {
+        const targetRoomParty = this.room.context.parties.main.get(targetRoomId);
+        const response = await targetRoomParty.fetch('/session-transfer', {
+          method: 'POST',
+          body: JSON.stringify(transferData),
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        });
+
+        if (!response.ok) {
+          throw new Error(`Transfer request failed: ${await response.text()}`);
+        }
+
+        const { transferToken } = await response.json();
+
+        // On success, remove user from current room
+        await this.deleteSession(privateId);
+        await this.room.storage.delete(`${usersPropName}.${publicId}`);
+        
+        const currentUsers = signal();
+        if (currentUsers[publicId]) {
+          delete currentUsers[publicId];
+        }
+
+        return transferToken;
+      } catch (error) {
+        console.error(`[sessionTransfer] Failed to transfer session to room ${targetRoomId}:`, error);
+        return null;
+      }
+    };
 
     // Sync callback: Broadcast changes to all clients
     const syncCb = (values) => {
@@ -464,18 +584,32 @@ export class Server implements Party.Server {
     // Check room guards
     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;
       }
     }
 
+    // Handle session transfer
+    let transferToken = null;
+    if (ctx.request?.url) {
+      const url = new URL(ctx.request.url);
+      transferToken = url.searchParams.get('transferToken');
+    }
+    let transferData: any = null;
+    if (transferToken) {
+      transferData = await this.room.storage.get(`transfer:${transferToken}`);
+      if (transferData) {
+        await this.room.storage.delete(`transfer:${transferToken}`);
+      }
+    }
+
     // Check for existing session
     const existingSession = await this.getSession(conn.id)
 
     // Generate IDs
-    const publicId = existingSession?.publicId || generateShortUUID();
+    const publicId = existingSession?.publicId || transferData?.publicId || generateShortUUID();
 
     let user = null;
     const signal = this.getUsersProperty(subRoom);
@@ -486,10 +620,15 @@ export class Server implements Party.Server {
 
       // Restore state if exists
       if (!existingSession?.publicId) {
-        user = isClass(classType) ? new classType() : classType(conn, ctx);
-        signal()[publicId] = user;
-        const snapshot = createStatesSnapshot(user);
-        this.room.storage.put(`${usersPropName}.${publicId}`, snapshot);
+        // Check if we have a transferred user already restored
+        if (transferData?.restored && signal()[publicId]) {
+          user = signal()[publicId];
+        } else {
+          user = isClass(classType) ? new classType() : classType(conn, ctx);
+          signal()[publicId] = user;
+          const snapshot = createStatesSnapshot(user);
+          this.room.storage.put(`${usersPropName}.${publicId}`, snapshot);
+        }
       }
       else {
         user = signal()[existingSession.publicId];
@@ -497,7 +636,9 @@ export class Server implements Party.Server {
 
       // Only store new session if it doesn't exist
       if (!existingSession) {
-        await this.saveSession(conn.id, {
+        // Use the transferred privateId if available, otherwise use connection id
+        const sessionPrivateId = transferData?.privateId || conn.id;
+        await this.saveSession(sessionPrivateId, {
           publicId
         });
       }
@@ -858,7 +999,7 @@ export class Server implements Party.Server {
    * @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
@@ -946,6 +1087,80 @@ export class Server implements Party.Server {
     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
+   */
+  private async handleSessionRestore(req: Party.Request, res: ServerResponse): Promise<Response> {
+    try {
+      const transferData = await req.json() as {
+        privateId: string;
+        userSnapshot?: any;
+        sessionState?: any;
+        publicId: string;
+      };
+      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');
+      }
+
+      // Create session from privateId
+      await this.saveSession(privateId, {
+        publicId,
+        state: sessionState,
+        created: Date.now(),
+        connected: false // Will be set to true when user connects
+      });
+
+      // If userSnapshot exists, restore user data
+      if (userSnapshot) {
+        const signal = this.getUsersProperty(subRoom);
+        const usersPropName = this.getUsersPropName(subRoom);
+        
+        if (signal && usersPropName) {
+          const { classType } = signal.options;
+          
+          // Create new user instance
+          const user = isClass(classType) ? new classType() : classType();
+          
+          // Load user data from snapshot
+          load(user, userSnapshot, true);
+          
+          // Add user to signal
+          signal()[publicId] = user;
+          
+          // Save user snapshot to storage
+          await this.room.storage.put(`${usersPropName}.${publicId}`, userSnapshot);
+        }
+      }
+
+      // Generate transfer token for the client to use when connecting
+      const transferToken = generateShortUUID();
+      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
@@ -956,10 +1171,16 @@ export class Server implements Party.Server {
    */
   private async handleDirectRequest(req: Party.Request, res: ServerResponse): Promise<Response> {
     const subRoom = await this.getSubRoom();
+
     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);
+    }
+
     // First try to match using the registered @Request handlers
     const response = await this.tryMatchRequestHandler(req, res, subRoom);
     if (response) {
@@ -1083,7 +1304,7 @@ export class Server implements Party.Server {
       .replace(/\//g, '\\/') // Escape slashes
       .replace(/:([^\/]+)/g, '([^/]+)'); // Convert :params to capture groups
 
-    const pathRegex = new RegExp(`^${pathRegexString}$`);
+    const pathRegex = new RegExp(`^${pathRegexString}`);
     return pathRegex.test(requestPath);
   }
 
@@ -1111,7 +1332,7 @@ export class Server implements Party.Server {
       .replace(/\//g, '\\/') // Escape slashes
       .replace(/:([^\/]+)/g, '([^/]+)'); // Convert :params to capture groups
 
-    const pathRegex = new RegExp(`^${pathRegexString}$`);
+    const pathRegex = new RegExp(`^${pathRegexString}`);
     const matches = requestPath.match(pathRegex);
 
     if (matches && matches.length > 1) {

package/src/session.guard.ts

@@ -0,0 +1,111 @@
+import type * as Party from "./types/party";
+
+/**
+ * @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 });
+ *   }
+ * }
+ * ```
+ */
+export function createRequireSessionGuard(storage: Party.Storage) {
+    return async (sender: Party.Connection, value: any): Promise<boolean> => {
+        if (!sender || !sender.id) {
+            return false;
+        }
+
+        try {
+            // Check if session exists in storage
+            const session = await storage.get(`session:${sender.id}`);
+            
+            // Return false if no session found
+            if (!session) {
+                return false;
+            }
+
+            // Verify session has required properties
+            const typedSession = session as { publicId: string, created?: number, connected?: boolean };
+            if (!typedSession.publicId) {
+                return false;
+            }
+
+            // Session exists and is valid
+            return true;
+        } catch (error) {
+            // If there's an error accessing storage, deny access
+            console.error('Error checking session in requireSession guard:', error);
+            return false;
+        }
+    };
+}
+
+/**
+ * @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" });
+ * }
+ * ```
+ */
+export const requireSession = async (sender: Party.Connection, value: any, room: Party.Room): Promise<boolean> => {
+    if (!sender || !sender.id) {
+        return false;
+    }
+
+    try {
+        // Check if session exists in storage
+        const session = await room.storage.get(`session:${sender.id}`);
+        
+        // Return false if no session found
+        if (!session) {
+            return false;
+        }
+
+        // Verify session has required properties
+        const typedSession = session as { publicId: string, created?: number, connected?: boolean };
+        if (!typedSession.publicId) {
+            return false;
+        }
+
+        // Session exists and is valid
+        return true;
+    } catch (error) {
+        // If there's an error accessing storage, deny access
+        console.error('Error checking session in requireSession guard:', error);
+        return false;
+    }
+};