@signe/room 2.1.0 → 2.2.0

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

@@ -6,7 +6,6 @@ import { RoomSchema } from "../shared/room.schema";
     sessionExpiryTime: 5000 
 })
 export class GameRoom extends RoomSchema {
-    
     @Action('increment')
     increment(player) {
         this.count.update((count) => count + 1); 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signe/room",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "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.1.0"
+    "@signe/sync": "2.2.0"
   },
   "publishConfig": {
     "access": "public"

package/src/mock.ts

@@ -1,13 +1,15 @@
 import { generateShortUUID } from "../../sync/src/utils";
 import { Server } from "./server";
 import { Storage } from "./storage";
+import { request } from "./testing";
 
 export class MockPartyClient {
     private events: Map<string, Function> = new Map();
-    id = generateShortUUID()
+    id : string
     conn: MockConnection;
 
-    constructor(public server: Server) {
+    constructor(public server: Server, id?: string) {
+      this.id = id || generateShortUUID()
       this.conn = new MockConnection(this)
     }
     
@@ -34,6 +36,10 @@ class MockLobby {
   socket() {
     return new MockPartyClient(this.server)
   }
+
+  fetch(url: string, options: any) {
+    return request(this.server, url, options)
+  }
 }
 
 class MockContext {
@@ -51,7 +57,6 @@ class MockContext {
   }
 }
 
-
 class MockPartyRoom {
   clients: Map<string, MockPartyClient> = new Map();
   storage = new Storage();
@@ -66,8 +71,8 @@ class MockPartyRoom {
     this.env = options.env || {}
   }
 
-  async connection(server: Server) {
-    const socket = new MockPartyClient(server);
+  async connection(server: Server, id?: string) {
+    const socket = new MockPartyClient(server, id);
     const url = new URL('http://localhost')
     const request = new Request(url.toString(), {
       method: 'GET',

package/src/server.ts

@@ -18,6 +18,7 @@ import {
 } from "./utils";
 import { ServerResponse } from "./request/response";
 import { createCorsInterceptor } from "./request/cors";
+import { Signal, WritableSignal } from "@signe/reactive";
 
 const Message = z.object({
   action: z.string(),
@@ -344,11 +345,63 @@ export class Server implements Party.Server {
   }
 
   private getUsersPropName(subRoom) {
-    const meta = subRoom.constructor["_propertyMetadata"];
-    return meta?.get("users")
+    if (!subRoom) return null;
+    const metadata = subRoom.constructor._propertyMetadata;
+    if (!metadata) return null;
+    return metadata.get("users");
+  }
+
+  /**
+   * Retrieves the connection status property from a user object.
+   * 
+   * @param {any} user - The user object to get the connection property from.
+   * @returns {Function|null} - The connection property signal function or null if not found.
+   * @private
+   */
+  private getUserConnectionProperty(user: any): WritableSignal<boolean> | null {
+    if (!user) return null;
+    
+    const metadata = user.constructor._propertyMetadata;
+    if (!metadata) return null;
+    
+    const connectedPropName = metadata.get("connected");
+    if (!connectedPropName) return null;
+
+    return user[connectedPropName];
+  }
+  
+  /**
+   * Updates a user's connection status in the signal.
+   * 
+   * @param {any} user - The user object to update.
+   * @param {boolean} isConnected - The new connection status.
+   * @returns {boolean} - Whether the update was successful.
+   * @private
+   */
+  private updateUserConnectionStatus(user: any, isConnected: boolean): boolean {
+    const connectionSignal = this.getUserConnectionProperty(user);
+
+    if (connectionSignal) {
+      connectionSignal.set(isConnected);
+      return true;
+    }
+    
+    return false;
   }
 
-  private async getSession(privateId: string): Promise<{ publicId: string, state?: any, created?: number, connected?: boolean } | null> {
+  /**
+   * @method getSession
+   * @private
+   * @param {string} privateId - The private ID of the session.
+   * @returns {Promise<Object|null>} The session object, or null if not found.
+   * 
+   * @example
+   * ```typescript
+   * const session = await server.getSession("privateId");
+   * console.log(session);
+   * ```
+   */
+  async getSession(privateId: string): Promise<{ publicId: string, state?: any, created?: number, connected?: boolean } | null> {
     if (!privateId) return null;
     try {
       const session = await this.room.storage.get(`session:${privateId}`);
@@ -374,7 +427,18 @@ export class Server implements Party.Server {
     }
   }
 
-  private async deleteSession(privateId: string) {
+  /**
+   * @method deleteSession
+   * @private
+   * @param {string} privateId - The private ID of the session to delete.
+   * @returns {Promise<void>}
+   * 
+   * @example
+   * ```typescript
+   * await server.deleteSession("privateId");
+   * ```
+   */
+  async deleteSession(privateId: string) {
     await this.room.storage.delete(`session:${privateId}`);
   }
 
@@ -421,6 +485,9 @@ export class Server implements Party.Server {
         const snapshot = createStatesSnapshot(user);
         this.room.storage.put(`${usersPropName}.${publicId}`, snapshot);
       }
+      else {
+        user = signal()[existingSession.publicId];
+      }
 
       // Only store new session if it doesn't exist
       if (!existingSession) {
@@ -432,6 +499,8 @@ export class Server implements Party.Server {
         await this.updateSessionConnection(conn.id, true);
       }
     }
+    // Update user connection status if applicable
+    this.updateUserConnectionStatus(user, true);
 
     // Call the room's onJoin method if it exists
     await awaitReturn(subRoom["onJoin"]?.(user, conn, ctx));
@@ -627,20 +696,16 @@ export class Server implements Party.Server {
    * @returns {Promise<void>}
    */
   private async handleShardClientConnect(message: any, shardConnection: Party.Connection) {
-    const { privateId, connectionInfo } = message;
+    const { privateId, requestInfo } = message;
     const shardState = shardConnection.state as any;
 
     // Create a virtual connection context for the client
     const virtualContext: Party.ConnectionContext = {
-      request: {
-        headers: new Headers({
-          'x-forwarded-for': connectionInfo.ip,
-          'user-agent': connectionInfo.userAgent,
-          // Add other headers as needed
-        }),
-        method: 'GET',
-        url: ''
-      } as unknown as Party.Request
+      request: requestInfo ? {
+        headers: new Headers(requestInfo.headers),
+        method: requestInfo.method,
+        url: requestInfo.url
+      } as unknown as Party.Request : undefined
     };
 
     // Create a virtual connection for the client
@@ -817,16 +882,22 @@ export class Server implements Party.Server {
 
     if (!user) return;
 
-    await awaitReturn(subRoom["onLeave"]?.(user, conn));
-
     // Mark session as disconnected instead of deleting it
     await this.updateSessionConnection(privateId, false);
 
-    // Broadcast user disconnection
-    this.broadcast({
-      type: "user_disconnected",
-      value: { publicId }
-    }, subRoom);
+    // Update user connection status in the signal
+    const connectionUpdated = this.updateUserConnectionStatus(user, false);
+
+    await awaitReturn(subRoom["onLeave"]?.(user, conn));
+    
+    // Only broadcast disconnection if we couldn't update the connection signal
+    if (!connectionUpdated) {
+      // Broadcast user disconnection the old way
+      this.broadcast({
+        type: "user_disconnected",
+        value: { publicId }
+      }, subRoom);
+    }
   }
 
   async onAlarm() {
@@ -1066,7 +1137,7 @@ export class Server implements Party.Server {
     // Create a context that preserves original client information
     const originalClientIp = req.headers.get('x-original-client-ip');
     const enhancedReq = this.createEnhancedRequest(req, originalClientIp);
-
+    
     try {
       // First try to match using the registered @Request handlers
       const response = await this.tryMatchRequestHandler(enhancedReq, res, subRoom);

package/src/shard.ts

@@ -93,15 +93,26 @@ export class Shard {
     // Store connection mapping
     this.connectionMap.set(conn.id, conn);
     
-    // Notify the main server about the new connection with connection metadata
+    // Capture all headers and request information
+    const headers: Record<string, string> = {};
+    if (ctx.request?.headers) {
+      ctx.request.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+    }
+
+    // Prepare connection context information
+    const requestInfo = ctx.request ? {
+      headers,
+      url: ctx.request.url,
+      method: ctx.request.method
+    } : null;
+
+    // Notify the main server about the new connection with complete connection metadata
     this.ws.send(JSON.stringify({
       type: 'shard.clientConnected',
       privateId: conn.id,
-      connectionInfo: {
-        ip: ctx.request?.headers.get('x-forwarded-for') || 'unknown',
-        userAgent: ctx.request?.headers.get('user-agent') || 'unknown',
-        // Add any other relevant connection info
-      }
+      requestInfo
     }));
 
     this.updateWorldStats();
@@ -222,7 +233,6 @@ export class Shard {
         headers,
         body
       };
-
       // Forward the request to the main server
       const response = await this.mainServerStub.fetch(path, requestInit);
       return response;

package/src/testing.ts

@@ -58,6 +58,9 @@ export async function testRoom(Room, options: {
         // Add subRoom property to Shard for compatibility with Server
         (shardServer as any).subRoom = null;
         server = shardServer;
+        for (const lobby of io.context.parties.main.values()) {
+            await lobby.server.onStart();
+        }
     } else {
         server = await createServer(io as any);
     }
@@ -67,14 +70,14 @@ export async function testRoom(Room, options: {
     return {
         server,
         room: (server as any).subRoom,
-        createClient: async () => {
-            const client = await io.connection(server as Server)
+        createClient: async (id?: string) => {
+            const client = await io.connection(server as Server, id)
             return client
         }
     }
 }
 
-export async function request(room: Server, path: string, options: {
+export async function request(room: Server | Shard, path: string, options: {
     method: 'GET' | 'POST' | 'PUT' | 'DELETE',
     body?: any,
     headers?: Record<string, string>