@signe/room 2.9.4 → 3.0.0

package/src/world.ts

@@ -1,9 +1,10 @@
 import { signal } from "@signe/reactive";
-import { Room, Guard, Request } from "./decorators";
+import { Room, Action, Guard, Request } from "./decorators";
 import { sync, id, persist } from "@signe/sync";
 import { z } from "zod";
 import * as Party from "./types/party";
 import { guardManageWorld } from "./world.guard";
+import { response } from "./utils";
 import { RoomInterceptorPacket, RoomOnJoin } from "./interfaces";
 import { ServerResponse } from "./request/response";
 
@@ -23,8 +24,17 @@ const RoomConfigSchema = z.object({
   maxShards: z.number().int().positive().optional(),
 });
 
+const RegisterShardSchema = z.object({
+  shardId: z.string(),
+  roomId: z.string(),
+  worldId: z.string().optional(),
+  url: z.string().url(),
+  maxConnections: z.number().int().positive(),
+});
+
 const UpdateShardStatsSchema = z.object({
   shardId: z.string(),
+  worldId: z.string().optional(),
   connections: z.number().int().min(0),
   status: z.enum(['active', 'maintenance', 'draining']).optional(),
 });
@@ -52,6 +62,7 @@ class RoomConfig {
 class ShardInfo {
   @id() id: string;
   @sync() roomId = signal("");
+  @sync() worldId = signal("");
   @sync() url = signal("");
   @sync({
     persist: false
@@ -72,10 +83,10 @@ export class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
   // Synchronized state
   @sync(RoomConfig) rooms = signal<Record<string, RoomConfig>>({});
   @sync(ShardInfo) shards = signal<Record<string, ShardInfo>>({});
-  
+
   // Only persisted state (not synced to clients)
   @persist() rrCounters = signal<Record<string, number>>({});
-  
+
   // Configuration
   defaultShardUrlTemplate = signal("{shardId}");
   defaultMaxConnectionsPerShard = signal(MAX_PLAYERS_PER_SHARD);
@@ -88,8 +99,7 @@ export class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
     if (!SHARD_SECRET) {
       throw new Error("SHARD_SECRET env variable is not set");
     }
-    // TODO
-    //setTimeout(() => this.cleanupInactiveShards(), 60000);
+    this.scheduleInactiveShardCleanup();
   }
 
   async onJoin(user: any, conn: Party.Connection, ctx: Party.ConnectionContext) {
@@ -106,26 +116,43 @@ export class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
     }
     return obj;
   }
-  
+
   // Helper methods
+  private getWorldId() {
+    return this.room.id;
+  }
+
+  private scheduleInactiveShardCleanup() {
+    const timeoutId = setTimeout(() => this.cleanupInactiveShards(), 60000);
+    timeoutId?.unref?.();
+  }
+
   private cleanupInactiveShards() {
     const now = Date.now();
     const timeout = 5 * 60 * 1000; // 5 minutes timeout
     const shardsValue = this.shards();
-    
+
     let hasChanges = false;
     Object.values(shardsValue).forEach(shard => {
       if (now - shard.lastHeartbeat() > timeout) {
         delete this.shards()[shard.id];
-        
+
         hasChanges = true;
       }
     });
-    
+
     // Schedule next cleanup
-    setTimeout(() => this.cleanupInactiveShards(), 60000);
+    this.scheduleInactiveShardCleanup();
+  }
+
+  private removeShard(shardId: string) {
+    delete this.shards()[shardId];
   }
-  
+
+  private shouldCompleteDrain(shard: ShardInfo) {
+    return shard.status() === 'draining' && shard.currentConnections() === 0;
+  }
+
   // Actions
   @Request({
     path: 'register-room',
@@ -133,16 +160,20 @@ export class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
   })
   @Guard([guardManageWorld])
   async registerRoom(req: Party.Request, res?: ServerResponse) {
-    const roomConfigResult = RoomConfigSchema.safeParse(await req.json());
-    if (!roomConfigResult.success) {
+    const parseResult = RoomConfigSchema.safeParse(await req.json());
+    if (!parseResult.success) {
       return res?.badRequest("Invalid room configuration", {
-        details: roomConfigResult.error
+        details: parseResult.error
       });
     }
 
-    const roomConfig = roomConfigResult.data;
+    const roomConfig = parseResult.data;
+    if (roomConfig.maxShards !== undefined && roomConfig.minShards > roomConfig.maxShards) {
+      return res?.badRequest("minShards cannot be greater than maxShards");
+    }
+
     const roomId = roomConfig.name;
-    
+
     if (!this.rooms()[roomId]) {
       const newRoom = new RoomConfig();
       newRoom.id = roomId;
@@ -152,9 +183,9 @@ export class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
       newRoom.maxPlayersPerShard.set(roomConfig.maxPlayersPerShard);
       newRoom.minShards.set(roomConfig.minShards);
       newRoom.maxShards.set(roomConfig.maxShards);
-      
+
       this.rooms()[roomId] = newRoom;
-      
+
       // Ensure minimum shards are created
       if (roomConfig.minShards > 0) {
         for (let i = 0; i < roomConfig.minShards; i++) {
@@ -170,63 +201,73 @@ export class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
       room.minShards.set(roomConfig.minShards);
       room.maxShards.set(roomConfig.maxShards);
     }
+
+    await this.ensureMinShards(roomId);
   }
-  
+
   @Request({
     path: 'update-shard',
     method: 'POST',
   })
   @Guard([guardManageWorld])
   async updateShardStats(req: Party.Request, res: ServerResponse) {
-    const bodyResult = UpdateShardStatsSchema.safeParse(await req.json());
-    if (!bodyResult.success) {
-      return res.badRequest("Invalid shard statistics", {
-        details: bodyResult.error
+    const parseResult = UpdateShardStatsSchema.safeParse(await req.json());
+    if (!parseResult.success) {
+      return res.badRequest("Invalid shard stats", {
+        details: parseResult.error
       });
     }
 
-    const body = bodyResult.data;
+    const body = parseResult.data;
     const { shardId, connections, status } = body;
     const shard = this.shards()[shardId];
 
     if (!shard) {
       return res.notFound(`Shard ${shardId} not found`);
     }
-    
+
+    if (body.worldId && body.worldId !== this.getWorldId()) {
+      return res.badRequest(`Shard ${shardId} belongs to world ${body.worldId}, not ${this.getWorldId()}`);
+    }
+
     shard.currentConnections.set(connections);
     if (status) {
       shard.status.set(status);
     }
     shard.lastHeartbeat.set(Date.now());
+
+    if (this.shouldCompleteDrain(shard)) {
+      this.removeShard(shard.id);
+    }
   }
-  
+
   @Request({
     path: 'scale-room',
     method: 'POST',
   })
   @Guard([guardManageWorld])
   async scaleRoom(req: Party.Request, res: ServerResponse) {
-    const dataResult = ScaleRoomSchema.safeParse(await req.json());
-    if (!dataResult.success) {
-      return res.badRequest("Invalid scale request", {
-        details: dataResult.error
+    const parseResult = ScaleRoomSchema.safeParse(await req.json());
+    if (!parseResult.success) {
+      return res.badRequest("Invalid scale room request", {
+        details: parseResult.error
       });
     }
 
-    const data = dataResult.data;
+    const data = parseResult.data;
     const { targetShardCount, shardTemplate, roomId } = data;
-    
+
     // Validate room exists
     const room = this.rooms()[roomId];
     if (!room) {
       return res.notFound(`Room ${roomId} does not exist`);
     }
-    
+
     const roomShards = Object.values(this.shards())
       .filter(shard => shard.roomId() === roomId);
-    
+
     const previousShardCount = roomShards.length;
-    
+
     // Check max shards constraint
     if (room.maxShards() !== undefined && targetShardCount > room.maxShards()!) {
       return res.badRequest(`Cannot scale beyond maximum allowed shards (${room.maxShards()})`, {
@@ -234,33 +275,36 @@ export class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
         currentShardCount: previousShardCount
       });
     }
-    
+
     // Handle scaling down
     if (targetShardCount < previousShardCount) {
-      // Find candidates for removal (prioritize draining or low-connection shards)
-      const shardsToRemove = [...roomShards]
+      // Find drain candidates (prioritize already-draining or low-connection shards)
+      const shardsToDrain = [...roomShards]
         .sort((a, b) => {
           // Prioritize draining status
           if (a.status() === 'draining' && b.status() !== 'draining') return -1;
           if (a.status() !== 'draining' && b.status() === 'draining') return 1;
-          
+
           // Then by connection count (ascending)
           return a.currentConnections() - b.currentConnections();
         })
         .slice(0, previousShardCount - targetShardCount);
-      
-      // Update shards
-      for (const shard of shardsToRemove) {
-        delete this.shards()[shard.id];
+
+      // Complete empty drains immediately, otherwise stop routing new clients there.
+      for (const shard of shardsToDrain) {
+        shard.status.set('draining');
+        if (this.shouldCompleteDrain(shard)) {
+          this.removeShard(shard.id);
+        }
       }
-      
+
       return;
     }
-    
+
     // Handle scaling up
     if (targetShardCount > previousShardCount) {
       const newShards = [];
-      
+
       // Create new shards
       for (let i = 0; i < targetShardCount - previousShardCount; i++) {
         const newShard = await this.createShard(
@@ -268,7 +312,7 @@ export class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
           shardTemplate?.urlTemplate,
           shardTemplate?.maxConnections
         );
-        
+
         if (newShard) {
           newShards.push(newShard);
         }
@@ -284,35 +328,35 @@ export class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
     try {
       // Extract request data
       let data: { roomId: string; autoCreate?: boolean };
- 
+
       try {
         // Handle potential empty body or malformed JSON
         const body = await req.text();
         if (!body || body.trim() === '') {
           return res.badRequest("Request body is empty");
         }
-        
+
         data = JSON.parse(body);
       } catch (parseError) {
         return res.badRequest("Invalid JSON in request body");
       }
-      
+
       // Verify roomId is provided
       if (!data.roomId) {
         return res.badRequest("roomId parameter is required");
       }
-      
+
       // Determine if auto-creation is enabled (default to true)
       const autoCreate = data.autoCreate !== undefined ? data.autoCreate : true;
-      
+
       // Find optimal shard
       const result = await this.findOptimalShard(data.roomId, autoCreate);
- 
+
       // Check for errors
       if ('error' in result) {
         return res.notFound(result.error);
       }
-      
+
       // Return shard information to the client
       return res.success({
         success: true,
@@ -324,9 +368,9 @@ export class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
       return res.serverError();
     }
   }
-  
+
   private async findOptimalShard(
-    roomId: string, 
+    roomId: string,
     autoCreate: boolean = true
   ): Promise<{ shardId: string; url: string } | { error: string }> {
     // Ensure room exists
@@ -343,11 +387,11 @@ export class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
             maxShards: undefined
           })
         } as Party.Request;
-        
+
         await this.registerRoom(mockRequest);
-        
+
         room = this.rooms()[roomId];
-        
+
         if (!room) {
           return { error: `Failed to create room ${roomId}` };
         }
@@ -355,11 +399,11 @@ export class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
         return { error: `Room ${roomId} does not exist` };
       }
     }
-    
+
     // Get shards for this room
     const roomShards = Object.values(this.shards())
       .filter(shard => shard.roomId() === roomId);
-    
+
     if (roomShards.length === 0) {
       if (autoCreate) {
         // Auto-create a shard
@@ -376,51 +420,76 @@ export class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
         return { error: `No shards available for room ${roomId}` };
       }
     }
-    
-    // Get active shards
-    const activeShards = roomShards
-      .filter(shard => shard && shard.status() === 'active');
-    
+
+    // Get active shards with available capacity
+    let activeShards = this.getAvailableShards(roomShards);
+
     if (activeShards.length === 0) {
+      if (autoCreate && this.canCreateShard(room, roomShards.length)) {
+        const newShard = await this.createShard(roomId);
+        if (newShard) {
+          return {
+            shardId: newShard.id,
+            url: newShard.url()
+          };
+        }
+      }
+
+      if (roomShards.some(shard => shard.status() === 'active')) {
+        return { error: `No shard capacity available for room ${roomId}` };
+      }
+
       return { error: `No active shards available for room ${roomId}` };
     }
-    
+
     // Apply balancing strategy
     const balancingStrategy = room.balancingStrategy();
     let selectedShard: ShardInfo;
-    
+
     switch (balancingStrategy) {
       case 'least-connections':
         // Choose shard with fewest connections
         selectedShard = activeShards.reduce(
-          (min, shard) => 
+          (min, shard) =>
             shard.currentConnections() < min.currentConnections() ? shard : min,
           activeShards[0]
         );
         break;
-        
+
       case 'random':
         // Choose random shard
         selectedShard = activeShards[Math.floor(Math.random() * activeShards.length)];
         break;
-        
+
       case 'round-robin':
       default:
         // Round-robin selection
         const counter = this.rrCounters()[roomId] || 0;
         const nextCounter = (counter + 1) % activeShards.length;
         this.rrCounters()[roomId] = nextCounter;
-        
+
         selectedShard = activeShards[counter];
         break;
     }
-    
+
     return {
       shardId: selectedShard.id,
       url: selectedShard.url()
     };
   }
-  
+
+  private getAvailableShards(shards: ShardInfo[]) {
+    return shards.filter(shard =>
+      shard
+      && shard.status() === 'active'
+      && shard.currentConnections() < shard.maxConnections()
+    );
+  }
+
+  private canCreateShard(room: RoomConfig, currentShardCount: number) {
+    return room.maxShards() === undefined || currentShardCount < room.maxShards()!;
+  }
+
   // Private methods
   private async createShard(
     roomId: string,
@@ -432,29 +501,51 @@ export class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
       console.error(`Cannot create shard for non-existent room: ${roomId}`);
       return null;
     }
-    
+
     // Generate shard ID
-    const shardId = `${roomId}:${Date.now()}-${Math.floor(Math.random() * 10000)}`;
-    
+    const worldId = this.getWorldId();
+    const shardId = `${roomId}:${worldId}:${Date.now()}-${Math.floor(Math.random() * 10000)}`;
+
     // Generate URL from template
     const template = urlTemplate || this.defaultShardUrlTemplate();
     const url = template.replace('{shardId}', shardId).replace('{roomId}', roomId);
 
     // Set max connections
     const max = maxConnections || room.maxPlayersPerShard();
-    
+
     // Create the shard
     const newShard = new ShardInfo();
     newShard.id = shardId;
     newShard.roomId.set(roomId);
+    newShard.worldId.set(worldId);
     newShard.url.set(url);
     newShard.maxConnections.set(max);
     newShard.currentConnections.set(0);
     newShard.status.set("active");
     newShard.lastHeartbeat.set(Date.now());
-    
+
     // Update shards collection
     this.shards()[shardId] = newShard;
     return newShard;
   }
+
+  private async ensureMinShards(roomId: string) {
+    const room = this.rooms()[roomId];
+    if (!room) {
+      return;
+    }
+
+    const currentShardCount = Object.values(this.shards())
+      .filter(shard => shard.roomId() === roomId)
+      .length;
+    const targetShardCount = room.minShards();
+
+    if (currentShardCount >= targetShardCount) {
+      return;
+    }
+
+    for (let i = currentShardCount; i < targetShardCount; i++) {
+      await this.createShard(roomId);
+    }
+  }
 }

package/examples/game/.vscode/launch.json

@@ -1,11 +0,0 @@
-{
-  "configurations": [
-    {
-      "type": "node",
-      "request": "attach",
-      "name": "PartyKit debugger",
-      "address": "localhost",
-      "port": 9229
-    }
-  ]
-}

package/examples/game/.vscode/settings.json

@@ -1,11 +0,0 @@
-{
-  "files.associations": {
-    "partykit.json": "jsonc"
-  },
-  "json.schemas": [
-    {
-      "fileMatch": ["partykit.json"],
-      "url": "https://www.partykit.io/schema.json"
-    }
-  ]
-}

package/examples/game/README.md

@@ -1,40 +0,0 @@
-# 🎈 game
-
-Welcome to the party, pal!
-
-This is a [Partykit](https://partykit.io) project, which lets you create real-time collaborative applications with minimal coding effort.
-
-This is the **React starter** which pairs a PartyKit server with a React client.
-
-Refer to our docs for more information: https://github.com/partykit/partykit/blob/main/README.md. For more help, reach out to us on [Discord](https://discord.gg/g5uqHQJc3z), [GitHub](https://github.com/partykit/partykit), or [Twitter](https://twitter.com/partykit_io).
-
-## Usage
-
-You can start developing by running `npm run dev` and opening [http://localhost:1999](http://localhost:1999) in your browser. When you're ready, you can deploy your application on to the PartyKit cloud with `npm run deploy`.
-
-## Finding your way around
-
-[`party/server.ts`](./party/server.ts) is the server-side code, which is responsible for handling WebSocket events and HTTP requests.
-
-It implements a simple counter that can be incremented by any connected client. The latest state is broadcast to all connected clients.
-
-> [!NOTE]
-> The full Server API is available at [Party.Server in the PartyKit docs](https://docs.partykit.io/reference/partyserver-api/)
-
-[`app/client.tsx`](./src/client.ts) is the entrypoint to client-side code.
-
-[`app/components/Counter.tsx`](./src/components/Counter.tsx) connects to the server, sends `increment` events on the WebSocket, and listens for updates.
-
-> [!NOTE]
-> The client-side reference can be found at [PartySocket in the PartyKit docs](https://docs.partykit.io/reference/partysocket-api/)
-
-As a client-side React app, the app could be hosted every. During development, for convenience, the server serves the client-side code as well.
-
-This is achieved with the optional `serve` property in the [`partykit.json`](./partykit.json) config file.
-
-> [!NOTE]
-> Learn about PartyKit config under [Configuration in the PartyKit docs](https://docs.partykit.io/reference/partykit-configuration/)
-
-## Next Steps
-
-Learn about deploying PartyKit applications in the [Deployment guide of the PartyKit docs](https://docs.partykit.io/guides/deploying-your-partykit-server/).

package/examples/game/app/client.tsx

@@ -1,15 +0,0 @@
-import { createRoot } from "react-dom/client";
-import  Admin  from "./components/Admin";
-import "./styles.css";
-import Room from "./components/Room";
-
-
-function App() {
-  return (
-    <main>
-      <Room />
-    </main>
-  );
-}
-
-createRoot(document.getElementById("app")!).render(<App />);