@signe/room 2.9.4 → 3.0.0

package/examples/node-shard/room-server.ts

@@ -0,0 +1,68 @@
+import { createServer } from "node:http";
+import { WebSocketServer } from "ws";
+import { createMemoryNodeRoomStorage, createNodeRoomTransport } from "@signe/room/node";
+import { MainServer, ShardServer } from "./room";
+import { AUTH_JWT_SECRET, ROOM_ORIGIN, ROOM_PORT, SHARD_SECRET, WORLD_ORIGIN } from "./shared";
+
+const storage = createMemoryNodeRoomStorage();
+
+const transport = createNodeRoomTransport(MainServer, {
+  partiesPath: "/parties/main",
+  storage,
+  env: {
+    AUTH_JWT_SECRET,
+    SHARD_SECRET,
+  },
+  rooms: {
+    main: MainServer,
+    shard: ShardServer,
+  },
+  externalParties: {
+    world: {
+      get(worldId: string) {
+        return {
+          fetch(pathOrInit?: string | RequestInit | Request, init?: RequestInit) {
+            const path = typeof pathOrInit === "string" ? pathOrInit : "/";
+            const requestInit = typeof pathOrInit === "string" ? init : pathOrInit;
+            return fetch(`${WORLD_ORIGIN}/parties/world/${encodeURIComponent(worldId)}${normalizeStubPath(path)}`, requestInit as RequestInit);
+          },
+        };
+      },
+    },
+  },
+});
+
+const server = createServer(async (req, res) => {
+  if (req.url?.startsWith("/parties/")) {
+    await transport.handleNodeRequest(req, res);
+    return;
+  }
+
+  res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+  res.end("Not Found");
+});
+
+const wsServer = new WebSocketServer({ noServer: true });
+
+server.on("upgrade", (request, socket, head) => {
+  if (request.url?.startsWith("/parties/")) {
+    transport.handleUpgrade(wsServer, request, socket, head);
+    return;
+  }
+
+  socket.destroy();
+});
+
+server.listen(ROOM_PORT, () => {
+  console.log(`Room process: ${ROOM_ORIGIN}`);
+  console.log(`Main rooms:    ${ROOM_ORIGIN}/parties/main/demo/state`);
+  console.log(`Shard rooms:   ws://localhost:${ROOM_PORT}/parties/shard/{shardId}`);
+  console.log(`World origin:  ${WORLD_ORIGIN}`);
+});
+
+function normalizeStubPath(path: string) {
+  if (!path || path === "/") {
+    return "";
+  }
+  return path.startsWith("/") ? path : `/${path}`;
+}

package/examples/node-shard/room.ts

@@ -0,0 +1,105 @@
+import { signal } from "@signe/reactive";
+import { Action, Request, Room, Server, Shard, WorldRoom } from "@signe/room";
+import { connected, sync, users } from "@signe/sync";
+import { z } from "zod";
+import type * as Party from "../../src/types/party";
+
+class DemoUser {
+  @sync() name = signal("Anonymous");
+  @connected() connected = signal(false);
+}
+
+@Room({ path: "{roomId}", sessionExpiryTime: 5000 })
+class DemoRoom {
+  @sync() count = signal(0);
+  @users(DemoUser) users = signal<Record<string, DemoUser>>({});
+
+  onJoin(user: DemoUser, _conn: unknown, ctx: { request?: Request }) {
+    const url = new URL(ctx.request?.url ?? "http://localhost");
+    const name = url.searchParams.get("name")?.trim();
+
+    if (name) {
+      user.name.set(name.slice(0, 40));
+    }
+  }
+
+  @Action("increment", z.object({ amount: z.number().optional() }))
+  increment(_user: DemoUser, value: { amount?: number }) {
+    this.count.update((count) => count + (value.amount ?? 1));
+  }
+
+  @Request({ path: "/state" })
+  getState() {
+    return this.snapshot();
+  }
+
+  @Request({ path: "/reset", method: "POST" })
+  reset() {
+    this.count.set(0);
+    return this.snapshot();
+  }
+
+  private snapshot() {
+    return {
+      count: this.count(),
+      users: Object.fromEntries(
+        Object.entries(this.users()).map(([id, user]) => [
+          id,
+          {
+            name: user.name(),
+            connected: user.connected(),
+          },
+        ])
+      ),
+    };
+  }
+}
+
+@Room({
+  path: "world-{worldId}",
+  maxUsers: 100,
+  throttleStorage: 2000,
+  throttleSync: 500,
+})
+class DashboardWorldRoom extends WorldRoom {
+  constructor(private readonly dashboardRoom: Party.Room) {
+    super(dashboardRoom);
+  }
+
+  @Request({ path: "/dashboard" })
+  dashboard() {
+    return {
+      worldId: this.dashboardRoom.id,
+      rooms: Object.values(this.rooms()).map((room) => ({
+        id: room.id,
+        name: room.name(),
+        balancingStrategy: room.balancingStrategy(),
+        public: room.public(),
+        maxPlayersPerShard: room.maxPlayersPerShard(),
+        minShards: room.minShards(),
+        maxShards: room.maxShards(),
+      })),
+      shards: Object.values(this.shards()).map((shard: any) => ({
+        id: shard.id,
+        roomId: shard.roomId(),
+        worldId: shard.worldId(),
+        url: shard.url(),
+        currentConnections: shard.currentConnections(),
+        maxConnections: shard.maxConnections(),
+        status: shard.status(),
+        lastHeartbeat: shard.lastHeartbeat(),
+      })),
+    };
+  }
+}
+
+export class MainServer extends Server {
+  rooms = [DashboardWorldRoom, DemoRoom];
+}
+
+export class ShardServer extends Shard {
+  constructor(room: Party.Room) {
+    super(room);
+    this.statsInterval = 5000;
+  }
+}

package/examples/node-shard/shared.ts

@@ -0,0 +1,6 @@
+export const AUTH_JWT_SECRET = process.env.AUTH_JWT_SECRET ?? "node-shard-auth-secret-at-least-256-bits";
+export const SHARD_SECRET = process.env.SHARD_SECRET ?? "node-shard-local-secret";
+export const WORLD_PORT = Number(process.env.WORLD_PORT ?? 3002);
+export const ROOM_PORT = Number(process.env.ROOM_PORT ?? 3003);
+export const WORLD_ORIGIN = process.env.WORLD_ORIGIN ?? `http://localhost:${WORLD_PORT}`;
+export const ROOM_ORIGIN = process.env.ROOM_ORIGIN ?? `http://localhost:${ROOM_PORT}`;

package/examples/node-shard/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": ["*.ts", "public/**/*.html"]
+}

package/examples/node-shard/world-server.ts

@@ -0,0 +1,169 @@
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createMemoryNodeRoomStorage, createNodeRoomTransport } from "@signe/room/node";
+import { MainServer } from "./room";
+import { AUTH_JWT_SECRET, ROOM_ORIGIN, SHARD_SECRET, WORLD_ORIGIN, WORLD_PORT } from "./shared";
+
+const root = fileURLToPath(new URL(".", import.meta.url));
+const storage = createMemoryNodeRoomStorage();
+
+const transport = createNodeRoomTransport(MainServer, {
+  partiesPath: "/parties/main",
+  storage,
+  env: {
+    AUTH_JWT_SECRET,
+    SHARD_SECRET,
+  },
+  rooms: {
+    world: MainServer,
+  },
+});
+
+const server = createServer(async (req, res) => {
+  try {
+    if (req.url?.startsWith("/parties/world/")) {
+      await transport.handleNodeRequest(req, res);
+      return;
+    }
+
+    if (req.url?.startsWith("/api/world/")) {
+      await handleWorldApi(req, res);
+      return;
+    }
+
+    if (req.url?.startsWith("/api/room/")) {
+      await handleRoomApi(req, res);
+      return;
+    }
+
+    if (req.url === "/" || req.url === "/index.html" || req.url?.startsWith("/rooms/")) {
+      const html = await readFile(join(root, "public/index.html"), "utf8");
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(html);
+      return;
+    }
+
+    res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end("Not Found");
+  } catch (error) {
+    console.error(error);
+    writeJson(res, 500, { error: "Internal Server Error" });
+  }
+});
+
+server.listen(WORLD_PORT, () => {
+  console.log(`World process: ${WORLD_ORIGIN}`);
+  console.log(`Dashboard:     ${WORLD_ORIGIN}`);
+  console.log(`Room process:  ${ROOM_ORIGIN}`);
+});
+
+async function handleWorldApi(req: IncomingMessage, res: ServerResponse) {
+  const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+  const match = url.pathname.match(/^\/api\/world\/([^/]+)\/([^/]+)$/);
+
+  if (!match) {
+    writeJson(res, 404, { error: "Not Found" });
+    return;
+  }
+
+  const worldId = decodeURIComponent(match[1]);
+  const action = match[2];
+
+  if (req.method === "GET" && action === "dashboard") {
+    await proxyWorld(res, worldId, "/dashboard", { method: "GET" });
+    return;
+  }
+
+  if (req.method === "POST" && action === "connect") {
+    const body = await readJson(req);
+    await proxyWorld(res, worldId, "/connect", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+    return;
+  }
+
+  if (req.method === "POST" && action === "scale") {
+    const body = await readJson(req);
+    await proxyWorld(res, worldId, "/scale-room", {
+      method: "POST",
+      body: JSON.stringify(body),
+    });
+    return;
+  }
+
+  if (req.method === "POST" && action === "shard-status") {
+    const body = await readJson(req);
+    await proxyWorld(res, worldId, "/update-shard", {
+      method: "POST",
+      body: JSON.stringify(body),
+    });
+    return;
+  }
+
+  writeJson(res, 404, { error: "Not Found" });
+}
+
+async function handleRoomApi(req: IncomingMessage, res: ServerResponse) {
+  const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+  const match = url.pathname.match(/^\/api\/room\/([^/]+)\/([^/]+)$/);
+
+  if (!match) {
+    writeJson(res, 404, { error: "Not Found" });
+    return;
+  }
+
+  const roomId = decodeURIComponent(match[1]);
+  const action = match[2];
+
+  if (req.method === "POST" && action === "reset") {
+    const response = await fetch(`${ROOM_ORIGIN}/parties/main/${encodeURIComponent(roomId)}/reset`, {
+      method: "POST",
+    });
+    res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+    res.end(Buffer.from(await response.arrayBuffer()));
+    return;
+  }
+
+  writeJson(res, 404, { error: "Not Found" });
+}
+
+async function proxyWorld(
+  res: ServerResponse,
+  worldId: string,
+  path: string,
+  init: RequestInit
+) {
+  const headers = new Headers(init.headers);
+  headers.set("Content-Type", "application/json");
+  headers.set("x-access-shard", SHARD_SECRET);
+
+  const response = await transport.fetch(`/parties/world/${encodeURIComponent(worldId)}${path}`, {
+    ...init,
+    headers,
+  });
+
+  res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+  res.end(Buffer.from(await response.arrayBuffer()));
+}
+
+async function readJson(req: IncomingMessage) {
+  const chunks: Buffer[] = [];
+
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+
+  const body = Buffer.concat(chunks).toString("utf8");
+  return body ? JSON.parse(body) : {};
+}
+
+function writeJson(res: ServerResponse, status: number, body: unknown) {
+  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+  res.end(JSON.stringify(body));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signe/room",
-  "version": "2.9.4",
+  "version": "3.0.0",
   "description": "PartyKit room primitives with synchronized state, sessions, guards, and HTTP handlers.",
   "main": "./dist/index.js",
   "keywords": [
@@ -16,6 +16,14 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
+    },
+    "./node": {
+      "import": "./dist/node/index.js",
+      "types": "./dist/node/index.d.ts"
+    },
+    "./cloudflare": {
+      "import": "./dist/cloudflare/index.js",
+      "types": "./dist/cloudflare/index.d.ts"
     }
   },
   "license": "MIT",
@@ -23,16 +31,17 @@
     "dset": "^3.1.3",
     "partysocket": "^1.0.1",
     "zod": "^3.23.8",
-    "@signe/sync": "2.9.4"
+    "@signe/sync": "3.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20240603.0"
+    "@cloudflare/workers-types": "^4.20241218.0",
+    "@types/node": "^22.13.9"
   },
   "scripts": {
-    "build": "tsup src/index.ts",
-    "dev": "tsup src/index.ts --watch"
+    "build": "tsup src/index.ts src/node/index.ts src/cloudflare/index.ts",
+    "dev": "tsup src/index.ts src/node/index.ts src/cloudflare/index.ts --watch"
   }
 }