@signe/room 2.4.0 → 2.4.2

package/package.json

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

package/src/mock.ts

@@ -47,29 +47,62 @@ export class MockPartyClient {
 }
 
 class MockLobby {
-  constructor(public server: Server) {}
+  constructor(public server: Server, public lobbyId: string) {}
 
-  socket() {
+  socket(_init?: any) {
     return new MockPartyClient(this.server)
   }
 
+  async connection(idOrOptions?: string | { id?: string, query?: Record<string, string>, headers?: Record<string, string> }, maybeOptions?: { query?: Record<string, string>, headers?: Record<string, string> }) {
+    const id = typeof idOrOptions === 'string' ? idOrOptions : idOrOptions?.id;
+    const options = (typeof idOrOptions === 'string' ? maybeOptions : idOrOptions) || {};
+    return (this.server.room as any).connection(this.server, id, options as any);
+  }
+
   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)
   }
 }
 
+interface MockContextOptions {
+  parties?: any;
+  partyFn?: (room: MockPartyRoom) => any;
+}
+
 class MockContext {
   parties: {
-    main: Map<string, any>
+    main: any
   } = {
     main: new Map()
   }
 
-  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)))
-   }
+  constructor(public room: MockPartyRoom, options: MockContextOptions = {}) {
+    const parties = options.parties || {}
+    if (options.partyFn) {
+      const serverCache = new Map<string, Server>();
+      this.parties.main = {
+        get: async (lobbyId: string) => {
+          if (!serverCache.has(lobbyId)) {
+            // Create an isolated IO for the specified lobby without recursive parties
+            const io = new MockPartyRoom(lobbyId, { env: this.room.env });
+            const server = options.partyFn(io);
+            if (typeof server.onStart === 'function') {
+              await server.onStart();
+            }
+            serverCache.set(lobbyId, server);
+          }
+          const server = serverCache.get(lobbyId)!;
+          return new MockLobby(server, lobbyId)
+        }
+      }
+    }
+    else {
+      for (let lobbyId in parties) {
+        const server = parties[lobbyId](room)
+        ;(this.parties.main as Map<string, any>).set(lobbyId, new MockLobby(server, lobbyId))
+      }
+    }
   }
 }
 
@@ -82,18 +115,25 @@ class MockPartyRoom {
   constructor(public id?: string, options: any = {}) {
     this.id = id || generateShortUUID()
     this.context = new MockContext(this, {
-      parties: options.parties || {}
+      parties: options.parties,
+      partyFn: options.partyFn
     })
     this.env = options.env || {}
   }
 
-  async connection(server: Server, id?: string) {
+  async connection(server: Server, id?: string, opts?: { query?: Record<string, string>, headers?: Record<string, string> }) {
     const socket = new MockPartyClient(server, id);
     const url = new URL('http://localhost')
+    if (opts?.query) {
+      for (const [key, value] of Object.entries(opts.query)) {
+        url.searchParams.set(key, String(value))
+      }
+    }
     const request = new Request(url.toString(), {
       method: 'GET',
       headers: {
-        'Content-Type': 'application/json'
+        'Content-Type': 'application/json',
+        ...(opts?.headers || {})
       }
     })
     await server.onConnect(socket.conn as any, { request } as any);

package/src/server.ts

@@ -335,7 +335,7 @@ export class Server implements Party.Server {
       };
 
       try {
-        const targetRoomParty = this.room.context.parties.main.get(targetRoomId);
+        const targetRoomParty = await this.room.context.parties.main.get(targetRoomId);
         const response = await targetRoomParty.fetch('/session-transfer', {
           method: 'POST',
           body: JSON.stringify(transferData),

package/src/testing.ts

@@ -30,7 +30,9 @@ import { Shard } from "./shard"
 export async function testRoom(Room, options: {
     hibernate?: boolean,
     shard?: boolean,
-    env?: Record<string, string>
+    env?: Record<string, string>,
+    parties?: Record<string, (io: any) => any>,
+    partyFn?: (io: any) => any
 } = {}) {
 
     const createServer = (io: any) => {
@@ -42,10 +44,14 @@ export async function testRoom(Room, options: {
     const isShard = options.shard || false
     const io = new ServerIo(Room.path, isShard ? {
         parties: {
-            game: createServer
+            game: createServer,
+            ...(options.parties || {})
         },
+        partyFn: options.partyFn,
         env: options.env
     } : {
+        parties: options.parties,
+        partyFn: options.partyFn,
         env: options.env
     })
     Room.prototype.throttleSync = 0
@@ -58,11 +64,22 @@ 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();
+        // In shard mode, parties.main is a Map of lobbies; ensure their servers are started
+        if (io.context.parties.main instanceof Map) {
+            for (const lobby of io.context.parties.main.values()) {
+                await lobby.server.onStart();
+            }
         }
     } else {
         server = await createServer(io as any);
+        // If extra parties are provided in non-shard mode, start them too
+        if (io.context.parties.main instanceof Map) {
+            for (const lobby of io.context.parties.main.values()) {
+                if (lobby.server && lobby.server !== server) {
+                    await lobby.server.onStart();
+                }
+            }
+        }
     }
     
     await server.onStart()
@@ -70,8 +87,8 @@ export async function testRoom(Room, options: {
     return {
         server,
         room: (server as any).subRoom,
-        createClient: async (id?: string) => {
-            const client = await io.connection(server as Server, id)
+        createClient: async (id?: string, opts?: { query?: Record<string, string>, headers?: Record<string, string> }) => {
+            const client = await io.connection(server as Server, id, opts)
             return client
         }
     }