@signe/room 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,189 @@
+import { Request as Request$1, WebSocket, DurableObjectState, AnalyticsEngineDataset, DurableObjectStorage, VectorizeIndex, R2Bucket, KVNamespace } from '@cloudflare/workers-types';
+
+declare function action(name: string, bodyValidation?: any): (target: any, propertyKey: string) => void;
+declare function Room$1(options: any): (target: any) => void;
+
+type AssetFetcher = {
+    fetch(path: string): Promise<Response | null>;
+};
+type StandardRequest = globalThis.Request;
+interface Request extends Request$1 {
+}
+type ReturnRequest = StandardRequest | Request$1;
+/** Per-party key-value storage */
+interface Storage extends DurableObjectStorage {
+}
+/** Connection metadata only available when the connection is made */
+type ConnectionContext = {
+    request: Request$1;
+};
+type Stub = {
+    /** @deprecated Use `await socket()` instead */
+    connect: () => WebSocket;
+    socket(pathOrInit?: string | RequestInit): Promise<WebSocket>;
+    socket(path: string, init?: RequestInit): Promise<WebSocket>;
+    fetch(pathOrInit?: string | RequestInit | ReturnRequest): Promise<Response>;
+    fetch(path: string, init?: RequestInit | ReturnRequest): Promise<Response>;
+};
+/** Additional information about other resources in the current project */
+type Context = {
+    /** Access other parties in this project */
+    parties: Record<string, {
+        get(id: string): Stub;
+    }>;
+    /**
+     * A binding to the Cloudflare AI service.
+     */
+    ai: AI;
+    /**
+     * A binding to the Cloudflare Vectorize service.
+     */
+    vectorize: Record<string, VectorizeIndex>;
+    /**
+     * A binding to fetch static assets
+     */
+    assets: AssetFetcher;
+    /**
+     * Custom bindings
+     */
+    bindings: CustomBindings;
+};
+type AI = Record<string, never>;
+type ImmutablePrimitive = undefined | null | boolean | string | number;
+type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>;
+type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
+type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
+type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
+type ImmutableObject<T> = {
+    readonly [K in keyof T]: Immutable<T[K]>;
+};
+type ConnectionState<T> = ImmutableObject<T> | null;
+type ConnectionSetStateFn<T> = (prevState: ConnectionState<T>) => T;
+/** A WebSocket connected to the Room */
+type Connection<TState = unknown> = WebSocket & {
+    /** Connection identifier */
+    id: string;
+    /** @deprecated You can access the socket properties directly on the connection*/
+    socket: WebSocket;
+    uri: string;
+    /**
+     * Arbitrary state associated with this connection.
+     * Read-only, use Connection.setState to update the state.
+     */
+    state: ConnectionState<TState>;
+    setState(state: TState | ConnectionSetStateFn<TState> | null): ConnectionState<TState>;
+    /** @deprecated use Connection.setState instead */
+    serializeAttachment<T = unknown>(attachment: T): void;
+    /** @deprecated use Connection.state instead */
+    deserializeAttachment<T = unknown>(): T | null;
+};
+type CustomBindings = {
+    r2: Record<string, R2Bucket>;
+    kv: Record<string, KVNamespace>;
+};
+/** Room represents a single, self-contained, long-lived session. */
+type Room = {
+    /** Room ID defined in the Party URL, e.g. /parties/:name/:id */
+    id: string;
+    /** Internal ID assigned by the platform. Use Party.id instead. */
+    internalID: string;
+    /** Party name defined in the Party URL, e.g. /parties/:name/:id */
+    name: string;
+    /** Environment variables (--var, partykit.json#vars, or .env) */
+    env: Record<string, unknown>;
+    /** A per-room key-value storage */
+    storage: Storage;
+    /** `blockConcurrencyWhile()` ensures no requests are delivered until */
+    blockConcurrencyWhile: DurableObjectState["blockConcurrencyWhile"];
+    /** Additional information about other resources in the current project */
+    context: Context;
+    /** @deprecated Use `room.getConnections` instead */
+    connections: Map<string, Connection>;
+    /** @deprecated Use `room.context.parties` instead */
+    parties: Context["parties"];
+    /** Send a message to all connected clients, except connection ids listed `without` */
+    broadcast: (msg: string | ArrayBuffer | ArrayBufferView, without?: string[] | undefined) => void;
+    /** Get a connection by connection id */
+    getConnection<TState = unknown>(id: string): Connection<TState> | undefined;
+    /**
+     * Get all connections. Optionally, you can provide a tag to filter returned connections.
+     * Use `Party.Server#getConnectionTags` to tag the connection on connect.
+     */
+    getConnections<TState = unknown>(tag?: string): Iterable<Connection<TState>>;
+    /**
+     * Cloudflare Analytics Engine dataset. Use this to log custom events and metrics.
+     */
+    analytics: AnalyticsEngineDataset;
+};
+type Server$1 = {
+    /**
+     * You can define an `options` field to customise the Party.Server behaviour.
+     */
+    readonly options?: ServerOptions;
+    /**
+     * You can tag a connection to filter them in Party#getConnections.
+     * Each connection supports up to 9 tags, each tag max length is 256 characters.
+     */
+    getConnectionTags?(connection: Connection, context: ConnectionContext): string[] | Promise<string[]>;
+    /**
+     * Called when the server is started, before first `onConnect` or `onRequest`.
+     * Useful for loading data from storage.
+     *
+     * You can use this to load data from storage and perform other asynchronous
+     * initialization, such as retrieving data or configuration from other
+     * services or databases.
+     */
+    onStart?(): void | Promise<void>;
+    /**
+     * Called when a new incoming WebSocket connection is opened.
+     */
+    onConnect?(connection: Connection, ctx: ConnectionContext): void | Promise<void>;
+    /**
+     * Called when a WebSocket connection receives a message from a client, or another connected party.
+     */
+    onMessage?(message: string | ArrayBuffer | ArrayBufferView, sender: Connection): void | Promise<void>;
+    /**
+     * Called when a WebSocket connection is closed by the client.
+     */
+    onClose?(connection: Connection): void | Promise<void>;
+    /**
+     * Called when a WebSocket connection is closed due to a connection error.
+     */
+    onError?(connection: Connection, error: Error): void | Promise<void>;
+    /**
+     * Called when a HTTP request is made to the room URL.
+     */
+    onRequest?(req: Request): Response | Promise<Response>;
+    /**
+     * Called when an alarm is triggered. Use Party.storage.setAlarm to set an alarm.
+     *
+     * Alarms have access to most Party resources such as storage, but not Party.id
+     * and Party.context.parties properties. Attempting to access them will result in a
+     * runtime error.
+     */
+    onAlarm?(): void | Promise<void>;
+};
+type ServerOptions = {
+    /**
+     * Whether the PartyKit platform should remove the server from memory
+     * between HTTP requests and WebSocket messages.
+     *
+     * The default value is `false`.
+     */
+    hibernate?: boolean;
+};
+
+declare class Server implements Server$1 {
+    readonly room: Room;
+    memoryAll: {};
+    subRoom: {};
+    rooms: any[];
+    static onBeforeConnect(request: Request): Promise<Response | Request>;
+    constructor(room: Room);
+    private getUsersProperty;
+    onConnect(conn: Connection, ctx: ConnectionContext): Promise<void>;
+    onMessage(message: string, sender: Connection): Promise<void>;
+    onClose(conn: Connection): Promise<void>;
+}
+
+export { Room$1 as Room, Server, action };

package/dist/index.js

@@ -0,0 +1,226 @@
+// src/decorators.ts
+function action(name, bodyValidation) {
+  return function(target, propertyKey) {
+    if (!target.constructor._actionMetadata) {
+      target.constructor._actionMetadata = /* @__PURE__ */ new Map();
+    }
+    target.constructor._actionMetadata.set(name, {
+      key: propertyKey,
+      bodyValidation
+    });
+  };
+}
+function Room(options) {
+  return function(target) {
+    target.path = options.path;
+    target.maxUsers = options.maxUsers;
+    target.throttleStorage = options.throttleStorage;
+  };
+}
+
+// src/server.ts
+import { createStatesSnapshot, getByPath, load, syncClass } from "@signe/sync";
+import { dset as dset2 } from "dset";
+import z from "zod";
+
+// src/utils.ts
+import { dset } from "dset";
+function isPromise(value) {
+  return value && value instanceof Promise;
+}
+async function awaitReturn(val) {
+  return isPromise(val) ? await val : val;
+}
+function isClass(obj) {
+  return typeof obj === "function" && obj.prototype && obj.prototype.constructor === obj;
+}
+function throttle(func, wait) {
+  let timeout = null;
+  let lastArgs = null;
+  return function(...args) {
+    if (!timeout) {
+      func(...args);
+      timeout = setTimeout(() => {
+        if (lastArgs) {
+          func(...lastArgs);
+          lastArgs = null;
+        }
+        timeout = null;
+      }, wait);
+    } else {
+      lastArgs = args;
+    }
+  };
+}
+function extractParams(pattern, str) {
+  const regexPattern = pattern.replace(/{(\w+)}/g, "(?<$1>[\\w-]+)");
+  const regex = new RegExp(`^${regexPattern}$`);
+  const match = regex.exec(str);
+  if (match && match.groups) {
+    return match.groups;
+  } else {
+    return null;
+  }
+}
+function dremove(obj, keys) {
+  keys.split && (keys = keys.split("."));
+  var i = 0, l = keys.length, t = { ...obj }, k;
+  while (i < l - 1) {
+    k = keys[i++];
+    if (k === "__proto__" || k === "constructor" || k === "prototype") return;
+    t = t[k];
+    if (typeof t !== "object" || t === null) return;
+  }
+  k = keys[i];
+  if (t && typeof t === "object" && !(k === "__proto__" || k === "constructor" || k === "prototype")) {
+    delete t[k];
+  }
+}
+function buildObject(valuesMap, allMemory) {
+  let memoryObj = {};
+  for (let path of valuesMap.keys()) {
+    const value = valuesMap.get(path);
+    dset(memoryObj, path, value);
+    if (path == "$delete") {
+      dremove(allMemory, value);
+    } else {
+      dset(allMemory, path, value);
+    }
+  }
+  return memoryObj;
+}
+
+// src/server.ts
+var Message = z.object({
+  action: z.string(),
+  value: z.any()
+});
+var Server = class {
+  constructor(room) {
+    this.room = room;
+    this.memoryAll = {};
+    this.subRoom = {};
+    this.rooms = [];
+    for (let room2 of this.rooms) {
+      const params = extractParams(room2.path, this.room.id);
+      if (params) {
+        this.subRoom = new room2(this.room, params);
+        break;
+      }
+    }
+    if (!this.subRoom) {
+      throw new Error("Room not found");
+    }
+    const loadMemory = async () => {
+      const root = await this.room.storage.get(".");
+      const memory = await this.room.storage.list();
+      const tmpObject = root || {};
+      for (let [key, value] of memory) {
+        if (key == ".") {
+          continue;
+        }
+        dset2(tmpObject, key, value);
+      }
+      load(this, tmpObject);
+    };
+    loadMemory();
+    syncClass(this.subRoom, {
+      onSync: throttle((values) => {
+        const packet = buildObject(values, this.memoryAll);
+        this.room.broadcast(
+          JSON.stringify({
+            type: "sync",
+            value: packet
+          })
+        );
+        values.clear();
+      }, 500),
+      onPersist: throttle(async (values) => {
+        for (let path of values) {
+          const instance = path == "." ? this.subRoom : getByPath(this.subRoom, path);
+          const itemValue = createStatesSnapshot(instance);
+          await this.room.storage.put(path, itemValue);
+        }
+        values.clear();
+      }, this.subRoom["throttleStorage"] ?? 2e3)
+    });
+  }
+  static async onBeforeConnect(request) {
+    try {
+      request.headers.set("X-User-ID", "" + Math.random());
+      return request;
+    } catch (e) {
+      return new Response("Unauthorized", { status: 401 });
+    }
+  }
+  getUsersProperty() {
+    const meta = this.subRoom.constructor["_propertyMetadata"];
+    const propId = meta?.get("users");
+    if (propId) {
+      return this.subRoom[propId];
+    }
+    return null;
+  }
+  async onConnect(conn, ctx) {
+    const publicId = "a" + ("" + Math.random()).split(".")[1];
+    let user = null;
+    const signal = this.getUsersProperty();
+    if (signal) {
+      const { classType } = signal.options;
+      user = isClass(classType) ? new classType() : classType(conn, ctx);
+      signal()[publicId] = user;
+    }
+    await awaitReturn(this.subRoom["onJoin"]?.(user, conn, ctx));
+    conn.setState({ publicId });
+    conn.send(
+      JSON.stringify({
+        type: "sync",
+        value: {
+          pId: publicId,
+          ...this.memoryAll
+        }
+      })
+    );
+  }
+  async onMessage(message, sender) {
+    const actions = this.subRoom.constructor["_actionMetadata"];
+    const result = Message.safeParse(JSON.parse(message));
+    if (!result.success) {
+      return;
+    }
+    if (actions) {
+      const signal = this.getUsersProperty();
+      const { publicId } = sender.state;
+      const user = signal?.()[publicId];
+      const actionName = actions.get(result.data.action);
+      if (actionName) {
+        if (actionName.bodyValidation) {
+          const bodyResult = actionName.bodyValidation.safeParse(
+            result.data.value
+          );
+          if (!bodyResult.success) {
+            return;
+          }
+        }
+        await awaitReturn(
+          this.subRoom[actionName.key](user, result.data.value, sender)
+        );
+      }
+    }
+  }
+  async onClose(conn) {
+    const signal = this.getUsersProperty();
+    const { publicId } = conn.state;
+    const user = signal?.()[publicId];
+    await awaitReturn(this.subRoom["onLeave"]?.(user, conn));
+    if (signal) {
+      delete signal()[publicId];
+    }
+  }
+};
+export {
+  Room,
+  Server,
+  action
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/decorators.ts","../src/server.ts","../src/utils.ts"],"sourcesContent":["export function action(name: string, bodyValidation?) {\n  return function (target: any, propertyKey: string) {\n    if (!target.constructor._actionMetadata) {\n      target.constructor._actionMetadata = new Map();\n    }\n    target.constructor._actionMetadata.set(name, {\n      key: propertyKey,\n      bodyValidation,\n    });\n  };\n}\n\nexport function Room(options) {\n  return function (target: any) {\n    target.path = options.path;\n    target.maxUsers = options.maxUsers;\n    target.throttleStorage = options.throttleStorage;\n  };\n}\n","import { createStatesSnapshot, getByPath, load, syncClass } from \"@signe/sync\";\nimport { dset } from \"dset\";\nimport z from \"zod\";\nimport type * as Party from \"./types/party\";\nimport {\n  awaitReturn,\n  buildObject,\n  extractParams,\n  isClass,\n  throttle,\n} from \"./utils\";\n\nconst Message = z.object({\n  action: z.string(),\n  value: z.any(),\n});\n\nexport class Server implements Party.Server {\n  memoryAll = {};\n  subRoom = {};\n  rooms = [];\n\n  static async onBeforeConnect(request: Party.Request) {\n    try {\n      request.headers.set(\"X-User-ID\", \"\" + Math.random());\n      return request;\n    } catch (e) {\n      return new Response(\"Unauthorized\", { status: 401 });\n    }\n  }\n\n  constructor(readonly room: Party.Room) {\n    for (let room of this.rooms) {\n      const params = extractParams(room.path, this.room.id);\n      if (params) {\n        this.subRoom = new room(this.room, params);\n        break;\n      }\n    }\n\n    if (!this.subRoom) {\n      throw new Error(\"Room not found\");\n    }\n\n    const loadMemory = async () => {\n      const root = await this.room.storage.get(\".\");\n      const memory = await this.room.storage.list();\n      const tmpObject: any = root || {};\n      for (let [key, value] of memory) {\n        if (key == \".\") {\n          continue;\n        }\n        dset(tmpObject, key, value);\n      }\n      load(this, tmpObject);\n    };\n\n    loadMemory();\n\n    syncClass(this.subRoom, {\n      onSync: throttle((values) => {\n        const packet = buildObject(values, this.memoryAll);\n        this.room.broadcast(\n          JSON.stringify({\n            type: \"sync\",\n            value: packet,\n          })\n        );\n        values.clear();\n      }, 500),\n      onPersist: throttle(async (values) => {\n        for (let path of values) {\n          const instance =\n            path == \".\" ? this.subRoom : getByPath(this.subRoom, path);\n          const itemValue = createStatesSnapshot(instance);\n          await this.room.storage.put(path, itemValue);\n        }\n        values.clear();\n      }, this.subRoom['throttleStorage'] ?? 2000),\n    });\n  }\n\n  private getUsersProperty() {\n    const meta = this.subRoom.constructor['_propertyMetadata'];\n    const propId = meta?.get(\"users\");\n    if (propId) {\n      return this.subRoom[propId];\n    }\n    return null;\n  }\n\n  async onConnect(conn: Party.Connection, ctx: Party.ConnectionContext) {\n    const publicId = \"a\" + (\"\" + Math.random()).split(\".\")[1];\n    let user = null;\n    const signal = this.getUsersProperty();\n    if (signal) {\n      const { classType } = signal.options;\n      user = isClass(classType) ? new classType() : classType(conn, ctx);\n      signal()[publicId] = user;\n    }\n    await awaitReturn(this.subRoom['onJoin']?.(user, conn, ctx));\n    conn.setState({ publicId });\n    conn.send(\n      JSON.stringify({\n        type: \"sync\",\n        value: {\n          pId: publicId,\n          ...this.memoryAll,\n        },\n      })\n    );\n  }\n\n  async onMessage(message: string, sender: Party.Connection) {\n    const actions = this.subRoom.constructor['_actionMetadata'];\n    const result = Message.safeParse(JSON.parse(message));\n    if (!result.success) {\n      return;\n    }\n    if (actions) {\n      const signal = this.getUsersProperty();\n      const { publicId } = sender.state as any;\n      const user = signal?.()[publicId];\n      const actionName = actions.get(result.data.action);\n      if (actionName) {\n        if (actionName.bodyValidation) {\n          const bodyResult = actionName.bodyValidation.safeParse(\n            result.data.value\n          );\n          if (!bodyResult.success) {\n            return;\n          }\n        }\n        await awaitReturn(\n          this.subRoom[actionName.key](user, result.data.value, sender)\n        );\n      }\n    }\n  }\n\n  async onClose(conn: Party.Connection) {\n    const signal = this.getUsersProperty();\n    const { publicId } = conn.state as any;\n    const user = signal?.()[publicId];\n    await awaitReturn(this.subRoom['onLeave']?.(user, conn));\n    if (signal) {\n      delete signal()[publicId];\n    }\n  }\n}\n","import { dset } from \"dset\";\n\nexport function isPromise(value: any): boolean {\n  return value && value instanceof Promise;\n}\n\nexport async function awaitReturn(val: any) {\n  return isPromise(val) ? await val : val;\n}\n\nexport function isClass(obj: any): boolean {\n  return (\n    typeof obj === \"function\" &&\n    obj.prototype &&\n    obj.prototype.constructor === obj\n  );\n}\n\nexport function throttle<F extends (...args: any[]) => any>(\n  func: F,\n  wait: number\n): (...args: Parameters<F>) => void {\n  let timeout: ReturnType<typeof setTimeout> | null = null;\n  let lastArgs: Parameters<F> | null = null;\n\n  return function (...args: Parameters<F>) {\n    if (!timeout) {\n      func(...args);\n      timeout = setTimeout(() => {\n        if (lastArgs) {\n          func(...lastArgs);\n          lastArgs = null;\n        }\n        timeout = null;\n      }, wait);\n    } else {\n      lastArgs = args;\n    }\n  };\n}\n\nexport function extractParams(\n  pattern: string,\n  str: string\n): { [key: string]: string } | null {\n  const regexPattern = pattern.replace(/{(\\w+)}/g, \"(?<$1>[\\\\w-]+)\");\n\n  const regex = new RegExp(`^${regexPattern}$`);\n  const match = regex.exec(str);\n\n  if (match && match.groups) {\n    return match.groups;\n  } else {\n    return null;\n  }\n}\n\nexport function dremove(obj, keys) {\n  keys.split && (keys = keys.split(\".\"));\n  var i = 0,\n    l = keys.length,\n    t = { ...obj },\n    k;\n\n  while (i < l - 1) {\n    k = keys[i++];\n    if (k === \"__proto__\" || k === \"constructor\" || k === \"prototype\") return; // On évite les clés dangereuses\n    t = t[k];\n    if (typeof t !== \"object\" || t === null) return; // Si l'objet n'existe pas, on arrête\n  }\n\n  k = keys[i];\n  if (\n    t &&\n    typeof t === \"object\" &&\n    !(k === \"__proto__\" || k === \"constructor\" || k === \"prototype\")\n  ) {\n    delete t[k];\n  }\n}\n\nexport function buildObject(valuesMap, allMemory) {\n    let memoryObj = {};\n    for (let path of valuesMap.keys()) {\n      const value = valuesMap.get(path);\n      dset(memoryObj, path, value);\n      if (path == \"$delete\") {\n        dremove(allMemory, value);\n      } else {\n        dset(allMemory, path, value);\n      }\n    }\n    return memoryObj;\n  }"],"mappings":";AAAO,SAAS,OAAO,MAAc,gBAAiB;AACpD,SAAO,SAAU,QAAa,aAAqB;AACjD,QAAI,CAAC,OAAO,YAAY,iBAAiB;AACvC,aAAO,YAAY,kBAAkB,oBAAI,IAAI;AAAA,IAC/C;AACA,WAAO,YAAY,gBAAgB,IAAI,MAAM;AAAA,MAC3C,KAAK;AAAA,MACL;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAEO,SAAS,KAAK,SAAS;AAC5B,SAAO,SAAU,QAAa;AAC5B,WAAO,OAAO,QAAQ;AACtB,WAAO,WAAW,QAAQ;AAC1B,WAAO,kBAAkB,QAAQ;AAAA,EACnC;AACF;;;AClBA,SAAS,sBAAsB,WAAW,MAAM,iBAAiB;AACjE,SAAS,QAAAA,aAAY;AACrB,OAAO,OAAO;;;ACFd,SAAS,YAAY;AAEd,SAAS,UAAU,OAAqB;AAC7C,SAAO,SAAS,iBAAiB;AACnC;AAEA,eAAsB,YAAY,KAAU;AAC1C,SAAO,UAAU,GAAG,IAAI,MAAM,MAAM;AACtC;AAEO,SAAS,QAAQ,KAAmB;AACzC,SACE,OAAO,QAAQ,cACf,IAAI,aACJ,IAAI,UAAU,gBAAgB;AAElC;AAEO,SAAS,SACd,MACA,MACkC;AAClC,MAAI,UAAgD;AACpD,MAAI,WAAiC;AAErC,SAAO,YAAa,MAAqB;AACvC,QAAI,CAAC,SAAS;AACZ,WAAK,GAAG,IAAI;AACZ,gBAAU,WAAW,MAAM;AACzB,YAAI,UAAU;AACZ,eAAK,GAAG,QAAQ;AAChB,qBAAW;AAAA,QACb;AACA,kBAAU;AAAA,MACZ,GAAG,IAAI;AAAA,IACT,OAAO;AACL,iBAAW;AAAA,IACb;AAAA,EACF;AACF;AAEO,SAAS,cACd,SACA,KACkC;AAClC,QAAM,eAAe,QAAQ,QAAQ,YAAY,gBAAgB;AAEjE,QAAM,QAAQ,IAAI,OAAO,IAAI,YAAY,GAAG;AAC5C,QAAM,QAAQ,MAAM,KAAK,GAAG;AAE5B,MAAI,SAAS,MAAM,QAAQ;AACzB,WAAO,MAAM;AAAA,EACf,OAAO;AACL,WAAO;AAAA,EACT;AACF;AAEO,SAAS,QAAQ,KAAK,MAAM;AACjC,OAAK,UAAU,OAAO,KAAK,MAAM,GAAG;AACpC,MAAI,IAAI,GACN,IAAI,KAAK,QACT,IAAI,EAAE,GAAG,IAAI,GACb;AAEF,SAAO,IAAI,IAAI,GAAG;AAChB,QAAI,KAAK,GAAG;AACZ,QAAI,MAAM,eAAe,MAAM,iBAAiB,MAAM,YAAa;AACnE,QAAI,EAAE,CAAC;AACP,QAAI,OAAO,MAAM,YAAY,MAAM,KAAM;AAAA,EAC3C;AAEA,MAAI,KAAK,CAAC;AACV,MACE,KACA,OAAO,MAAM,YACb,EAAE,MAAM,eAAe,MAAM,iBAAiB,MAAM,cACpD;AACA,WAAO,EAAE,CAAC;AAAA,EACZ;AACF;AAEO,SAAS,YAAY,WAAW,WAAW;AAC9C,MAAI,YAAY,CAAC;AACjB,WAAS,QAAQ,UAAU,KAAK,GAAG;AACjC,UAAM,QAAQ,UAAU,IAAI,IAAI;AAChC,SAAK,WAAW,MAAM,KAAK;AAC3B,QAAI,QAAQ,WAAW;AACrB,cAAQ,WAAW,KAAK;AAAA,IAC1B,OAAO;AACL,WAAK,WAAW,MAAM,KAAK;AAAA,IAC7B;AAAA,EACF;AACA,SAAO;AACT;;;ADjFF,IAAM,UAAU,EAAE,OAAO;AAAA,EACvB,QAAQ,EAAE,OAAO;AAAA,EACjB,OAAO,EAAE,IAAI;AACf,CAAC;AAEM,IAAM,SAAN,MAAqC;AAAA,EAc1C,YAAqB,MAAkB;AAAlB;AAbrB,qBAAY,CAAC;AACb,mBAAU,CAAC;AACX,iBAAQ,CAAC;AAYP,aAASC,SAAQ,KAAK,OAAO;AAC3B,YAAM,SAAS,cAAcA,MAAK,MAAM,KAAK,KAAK,EAAE;AACpD,UAAI,QAAQ;AACV,aAAK,UAAU,IAAIA,MAAK,KAAK,MAAM,MAAM;AACzC;AAAA,MACF;AAAA,IACF;AAEA,QAAI,CAAC,KAAK,SAAS;AACjB,YAAM,IAAI,MAAM,gBAAgB;AAAA,IAClC;AAEA,UAAM,aAAa,YAAY;AAC7B,YAAM,OAAO,MAAM,KAAK,KAAK,QAAQ,IAAI,GAAG;AAC5C,YAAM,SAAS,MAAM,KAAK,KAAK,QAAQ,KAAK;AAC5C,YAAM,YAAiB,QAAQ,CAAC;AAChC,eAAS,CAAC,KAAK,KAAK,KAAK,QAAQ;AAC/B,YAAI,OAAO,KAAK;AACd;AAAA,QACF;AACA,QAAAC,MAAK,WAAW,KAAK,KAAK;AAAA,MAC5B;AACA,WAAK,MAAM,SAAS;AAAA,IACtB;AAEA,eAAW;AAEX,cAAU,KAAK,SAAS;AAAA,MACtB,QAAQ,SAAS,CAAC,WAAW;AAC3B,cAAM,SAAS,YAAY,QAAQ,KAAK,SAAS;AACjD,aAAK,KAAK;AAAA,UACR,KAAK,UAAU;AAAA,YACb,MAAM;AAAA,YACN,OAAO;AAAA,UACT,CAAC;AAAA,QACH;AACA,eAAO,MAAM;AAAA,MACf,GAAG,GAAG;AAAA,MACN,WAAW,SAAS,OAAO,WAAW;AACpC,iBAAS,QAAQ,QAAQ;AACvB,gBAAM,WACJ,QAAQ,MAAM,KAAK,UAAU,UAAU,KAAK,SAAS,IAAI;AAC3D,gBAAM,YAAY,qBAAqB,QAAQ;AAC/C,gBAAM,KAAK,KAAK,QAAQ,IAAI,MAAM,SAAS;AAAA,QAC7C;AACA,eAAO,MAAM;AAAA,MACf,GAAG,KAAK,QAAQ,iBAAiB,KAAK,GAAI;AAAA,IAC5C,CAAC;AAAA,EACH;AAAA,EA1DA,aAAa,gBAAgB,SAAwB;AACnD,QAAI;AACF,cAAQ,QAAQ,IAAI,aAAa,KAAK,KAAK,OAAO,CAAC;AACnD,aAAO;AAAA,IACT,SAAS,GAAG;AACV,aAAO,IAAI,SAAS,gBAAgB,EAAE,QAAQ,IAAI,CAAC;AAAA,IACrD;AAAA,EACF;AAAA,EAqDQ,mBAAmB;AACzB,UAAM,OAAO,KAAK,QAAQ,YAAY,mBAAmB;AACzD,UAAM,SAAS,MAAM,IAAI,OAAO;AAChC,QAAI,QAAQ;AACV,aAAO,KAAK,QAAQ,MAAM;AAAA,IAC5B;AACA,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,UAAU,MAAwB,KAA8B;AACpE,UAAM,WAAW,OAAO,KAAK,KAAK,OAAO,GAAG,MAAM,GAAG,EAAE,CAAC;AACxD,QAAI,OAAO;AACX,UAAM,SAAS,KAAK,iBAAiB;AACrC,QAAI,QAAQ;AACV,YAAM,EAAE,UAAU,IAAI,OAAO;AAC7B,aAAO,QAAQ,SAAS,IAAI,IAAI,UAAU,IAAI,UAAU,MAAM,GAAG;AACjE,aAAO,EAAE,QAAQ,IAAI;AAAA,IACvB;AACA,UAAM,YAAY,KAAK,QAAQ,QAAQ,IAAI,MAAM,MAAM,GAAG,CAAC;AAC3D,SAAK,SAAS,EAAE,SAAS,CAAC;AAC1B,SAAK;AAAA,MACH,KAAK,UAAU;AAAA,QACb,MAAM;AAAA,QACN,OAAO;AAAA,UACL,KAAK;AAAA,UACL,GAAG,KAAK;AAAA,QACV;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EAEA,MAAM,UAAU,SAAiB,QAA0B;AACzD,UAAM,UAAU,KAAK,QAAQ,YAAY,iBAAiB;AAC1D,UAAM,SAAS,QAAQ,UAAU,KAAK,MAAM,OAAO,CAAC;AACpD,QAAI,CAAC,OAAO,SAAS;AACnB;AAAA,IACF;AACA,QAAI,SAAS;AACX,YAAM,SAAS,KAAK,iBAAiB;AACrC,YAAM,EAAE,SAAS,IAAI,OAAO;AAC5B,YAAM,OAAO,SAAS,EAAE,QAAQ;AAChC,YAAM,aAAa,QAAQ,IAAI,OAAO,KAAK,MAAM;AACjD,UAAI,YAAY;AACd,YAAI,WAAW,gBAAgB;AAC7B,gBAAM,aAAa,WAAW,eAAe;AAAA,YAC3C,OAAO,KAAK;AAAA,UACd;AACA,cAAI,CAAC,WAAW,SAAS;AACvB;AAAA,UACF;AAAA,QACF;AACA,cAAM;AAAA,UACJ,KAAK,QAAQ,WAAW,GAAG,EAAE,MAAM,OAAO,KAAK,OAAO,MAAM;AAAA,QAC9D;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,QAAQ,MAAwB;AACpC,UAAM,SAAS,KAAK,iBAAiB;AACrC,UAAM,EAAE,SAAS,IAAI,KAAK;AAC1B,UAAM,OAAO,SAAS,EAAE,QAAQ;AAChC,UAAM,YAAY,KAAK,QAAQ,SAAS,IAAI,MAAM,IAAI,CAAC;AACvD,QAAI,QAAQ;AACV,aAAO,OAAO,EAAE,QAAQ;AAAA,IAC1B;AAAA,EACF;AACF;","names":["dset","room","dset"]}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@signe/room",
+  "version": "0.0.1",
+  "description": "",
+  "main": "./dist/index.js",
+  "keywords": [],
+  "author": "Samuel Ronce",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "license": "MIT",
+  "dependencies": {
+    "dset": "^3.1.3",
+    "partysocket": "^1.0.1",
+    "zod": "^3.23.8",
+    "@signe/sync": "0.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20240603.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts",
+    "dev": "tsup src/index.ts --watch"
+  }
+}

package/readme.md

@@ -0,0 +1,54 @@
+# Example
+
+```ts
+import { signal } from "@signe/reactive";
+import { Room, Server, action } from "@signe/room";
+import { id, sync, users } from "@signe/sync";
+
+export class Player {
+  @id() id = signal("");
+  @sync() x = signal(0);
+  @sync() y = signal(0);
+  @sync() color = signal("#000000");
+
+  constructor() {
+    const randomColor = Math.floor(Math.random() * 16777215).toString(16);
+    this.color.set("#" + randomColor);
+  }
+}
+
+export class RoomSchema {
+  @sync() count = signal(0);
+  @users(Player) players = signal({});
+}
+
+@Room({
+  path: "chess-{id}",
+  maxUsers: 2,
+})
+export class MyRoom extends RoomSchema {
+  static onAuth() {}
+
+  constructor(readonly room, readonly params: { id: string }) {
+    super();
+  }
+
+  onCreate() {}
+
+  @action("move")
+  move(player: Player, data: any) {
+    player.x.set(data.x);
+    player.y.set(data.y);
+  }
+
+  onJoin(player: Player) {
+    console.log(player.id(), "joined");
+  }
+
+  onLeave() {}
+}
+
+export default class MyServer extends Server {
+  rooms = [MyRoom];
+}
+```

package/src/decorators.ts

@@ -0,0 +1,19 @@
+export function action(name: string, bodyValidation?) {
+  return function (target: any, propertyKey: string) {
+    if (!target.constructor._actionMetadata) {
+      target.constructor._actionMetadata = new Map();
+    }
+    target.constructor._actionMetadata.set(name, {
+      key: propertyKey,
+      bodyValidation,
+    });
+  };
+}
+
+export function Room(options) {
+  return function (target: any) {
+    target.path = options.path;
+    target.maxUsers = options.maxUsers;
+    target.throttleStorage = options.throttleStorage;
+  };
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './decorators';
+export { Server } from './server';
+

package/src/server.ts

@@ -0,0 +1,150 @@
+import { createStatesSnapshot, getByPath, load, syncClass } from "@signe/sync";
+import { dset } from "dset";
+import z from "zod";
+import type * as Party from "./types/party";
+import {
+  awaitReturn,
+  buildObject,
+  extractParams,
+  isClass,
+  throttle,
+} from "./utils";
+
+const Message = z.object({
+  action: z.string(),
+  value: z.any(),
+});
+
+export class Server implements Party.Server {
+  memoryAll = {};
+  subRoom = {};
+  rooms = [];
+
+  static async onBeforeConnect(request: Party.Request) {
+    try {
+      request.headers.set("X-User-ID", "" + Math.random());
+      return request;
+    } catch (e) {
+      return new Response("Unauthorized", { status: 401 });
+    }
+  }
+
+  constructor(readonly room: Party.Room) {
+    for (let room of this.rooms) {
+      const params = extractParams(room.path, this.room.id);
+      if (params) {
+        this.subRoom = new room(this.room, params);
+        break;
+      }
+    }
+
+    if (!this.subRoom) {
+      throw new Error("Room not found");
+    }
+
+    const loadMemory = async () => {
+      const root = await this.room.storage.get(".");
+      const memory = await this.room.storage.list();
+      const tmpObject: any = root || {};
+      for (let [key, value] of memory) {
+        if (key == ".") {
+          continue;
+        }
+        dset(tmpObject, key, value);
+      }
+      load(this, tmpObject);
+    };
+
+    loadMemory();
+
+    syncClass(this.subRoom, {
+      onSync: throttle((values) => {
+        const packet = buildObject(values, this.memoryAll);
+        this.room.broadcast(
+          JSON.stringify({
+            type: "sync",
+            value: packet,
+          })
+        );
+        values.clear();
+      }, 500),
+      onPersist: throttle(async (values) => {
+        for (let path of values) {
+          const instance =
+            path == "." ? this.subRoom : getByPath(this.subRoom, path);
+          const itemValue = createStatesSnapshot(instance);
+          await this.room.storage.put(path, itemValue);
+        }
+        values.clear();
+      }, this.subRoom['throttleStorage'] ?? 2000),
+    });
+  }
+
+  private getUsersProperty() {
+    const meta = this.subRoom.constructor['_propertyMetadata'];
+    const propId = meta?.get("users");
+    if (propId) {
+      return this.subRoom[propId];
+    }
+    return null;
+  }
+
+  async onConnect(conn: Party.Connection, ctx: Party.ConnectionContext) {
+    const publicId = "a" + ("" + Math.random()).split(".")[1];
+    let user = null;
+    const signal = this.getUsersProperty();
+    if (signal) {
+      const { classType } = signal.options;
+      user = isClass(classType) ? new classType() : classType(conn, ctx);
+      signal()[publicId] = user;
+    }
+    await awaitReturn(this.subRoom['onJoin']?.(user, conn, ctx));
+    conn.setState({ publicId });
+    conn.send(
+      JSON.stringify({
+        type: "sync",
+        value: {
+          pId: publicId,
+          ...this.memoryAll,
+        },
+      })
+    );
+  }
+
+  async onMessage(message: string, sender: Party.Connection) {
+    const actions = this.subRoom.constructor['_actionMetadata'];
+    const result = Message.safeParse(JSON.parse(message));
+    if (!result.success) {
+      return;
+    }
+    if (actions) {
+      const signal = this.getUsersProperty();
+      const { publicId } = sender.state as any;
+      const user = signal?.()[publicId];
+      const actionName = actions.get(result.data.action);
+      if (actionName) {
+        if (actionName.bodyValidation) {
+          const bodyResult = actionName.bodyValidation.safeParse(
+            result.data.value
+          );
+          if (!bodyResult.success) {
+            return;
+          }
+        }
+        await awaitReturn(
+          this.subRoom[actionName.key](user, result.data.value, sender)
+        );
+      }
+    }
+  }
+
+  async onClose(conn: Party.Connection) {
+    const signal = this.getUsersProperty();
+    const { publicId } = conn.state as any;
+    const user = signal?.()[publicId];
+    await awaitReturn(this.subRoom['onLeave']?.(user, conn));
+    if (signal) {
+      delete signal()[publicId];
+    }
+  }
+}

package/src/storage.ts

@@ -0,0 +1,15 @@
+export class Storage {
+  private memory = new Map();
+  async put(key, value) {
+    this.memory.set(key, value);
+  }
+  async get(key) {
+    return this.memory.get(key);
+  }
+  async delete(key) {
+    this.memory.delete(key);
+  }
+  async list() {
+    return this.memory;
+  }
+}

package/src/types/party.ts

@@ -0,0 +1,531 @@
+import type {
+    AnalyticsEngineDataset,
+    ExecutionContext as CFExecutionContext,
+    Request as CFRequest,
+    DurableObjectState,
+    DurableObjectStorage,
+    KVNamespace,
+    R2Bucket,
+    ScheduledController,
+    VectorizeIndex,
+    WebSocket
+} from "@cloudflare/workers-types";
+  
+  export type StaticAssetsManifestType = {
+    devServer: string;
+    browserTTL: number | null | undefined;
+    edgeTTL: number | null | undefined;
+    singlePageApp: boolean | undefined;
+    assets: Record<string, string>;
+    assetInfo?: Record<
+      string,
+      {
+        fileSize: number;
+        fileHash: string;
+        fileName: string;
+      }
+    >;
+  };
+  
+  type AssetFetcher = {
+    fetch(path: string): Promise<Response | null>;
+  };
+  
+  type StandardRequest = globalThis.Request;
+  
+  // Types with PartyKit* prefix are used in module workers, i.e.
+  // `export default {} satisfies PartyKitServer;`
+  
+  // Types with Party.* prefix are used in class workers, i.e.
+  // `export default class Room implements Party.Server {}`
+  
+  // Extend type so that when language server (e.g. vscode) autocompletes,
+  // it will import this type instead of the underlying type directly.
+  export interface Request extends CFRequest {}
+  
+  // Because when you construct a `new Request()` in a user script,
+  // it's assumed to be a standards-based Fetch API Response, unless overridden.
+  // This is fine by us, let user return whichever request type
+  type ReturnRequest = StandardRequest | CFRequest;
+  
+  /** Per-party key-value storage */
+  export interface Storage extends DurableObjectStorage {}
+  
+  /** Connection metadata only available when the connection is made */
+  export type ConnectionContext = { request: CFRequest };
+  
+  export type Stub = {
+    /** @deprecated Use `await socket()` instead */
+    connect: () => WebSocket;
+    socket(pathOrInit?: string | RequestInit): Promise<WebSocket>;
+    socket(path: string, init?: RequestInit): Promise<WebSocket>;
+    fetch(pathOrInit?: string | RequestInit | ReturnRequest): Promise<Response>;
+    fetch(path: string, init?: RequestInit | ReturnRequest): Promise<Response>;
+  };
+  
+  /** Additional information about other resources in the current project */
+  export type Context = {
+    /** Access other parties in this project */
+    parties: Record<
+      string,
+      {
+        get(id: string): Stub;
+      }
+    >;
+    /**
+     * A binding to the Cloudflare AI service.
+     */
+    ai: AI;
+    /**
+     * A binding to the Cloudflare Vectorize service.
+     */
+    vectorize: Record<string, VectorizeIndex>;
+  
+    /**
+     * A binding to fetch static assets
+     */
+    assets: AssetFetcher;
+  
+    /**
+     * Custom bindings
+     */
+    bindings: CustomBindings;
+  };
+  
+  export type AI = Record<string, never>;
+  
+  export type FetchLobby = {
+    env: Record<string, unknown>;
+    ai: AI;
+    parties: Context["parties"];
+    vectorize: Context["vectorize"];
+    analytics: AnalyticsEngineDataset;
+    assets: AssetFetcher;
+    bindings: CustomBindings;
+  };
+  
+  export type CronLobby = {
+    env: Record<string, unknown>;
+    ai: AI;
+    parties: Context["parties"];
+    vectorize: Context["vectorize"];
+    analytics: AnalyticsEngineDataset;
+    assets: AssetFetcher;
+    bindings: CustomBindings;
+  };
+  
+  export type Lobby = {
+    id: string;
+    env: Record<string, unknown>;
+    ai: AI;
+    parties: Context["parties"];
+    vectorize: Context["vectorize"];
+    analytics: AnalyticsEngineDataset;
+    assets: AssetFetcher;
+    bindings: CustomBindings;
+  };
+  
+  export type ExecutionContext = CFExecutionContext;
+  
+  // https://stackoverflow.com/a/58993872
+  type ImmutablePrimitive = undefined | null | boolean | string | number;
+  type Immutable<T> = T extends ImmutablePrimitive
+    ? T
+    : T extends Array<infer U>
+      ? ImmutableArray<U>
+      : T extends Map<infer K, infer V>
+        ? ImmutableMap<K, V>
+        : T extends Set<infer M>
+          ? ImmutableSet<M>
+          : ImmutableObject<T>;
+  type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
+  type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
+  type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
+  type ImmutableObject<T> = { readonly [K in keyof T]: Immutable<T[K]> };
+  
+  export type ConnectionState<T> = ImmutableObject<T> | null;
+  export type ConnectionSetStateFn<T> = (prevState: ConnectionState<T>) => T;
+  
+  /** A WebSocket connected to the Room */
+  export type Connection<TState = unknown> = WebSocket & {
+    /** Connection identifier */
+    id: string;
+  
+    /** @deprecated You can access the socket properties directly on the connection*/
+    socket: WebSocket;
+    // We would have been able to use Websocket::url
+    // but it's not available in the Workers runtime
+    // (rather, url is `null` when using WebSocketPair)
+    // It's also set as readonly, so we can't set it ourselves.
+    // Instead, we'll use the `uri` property.
+    uri: string;
+  
+    /**
+     * Arbitrary state associated with this connection.
+     * Read-only, use Connection.setState to update the state.
+     */
+    state: ConnectionState<TState>;
+  
+    setState(
+      state: TState | ConnectionSetStateFn<TState> | null
+    ): ConnectionState<TState>;
+  
+    /** @deprecated use Connection.setState instead */
+    serializeAttachment<T = unknown>(attachment: T): void;
+  
+    /** @deprecated use Connection.state instead */
+    deserializeAttachment<T = unknown>(): T | null;
+  };
+  
+  type CustomBindings = {
+    r2: Record<string, R2Bucket>;
+    kv: Record<string, KVNamespace>;
+  };
+  
+  /** Room represents a single, self-contained, long-lived session. */
+  export type Room = {
+    /** Room ID defined in the Party URL, e.g. /parties/:name/:id */
+    id: string;
+  
+    /** Internal ID assigned by the platform. Use Party.id instead. */
+    internalID: string;
+  
+    /** Party name defined in the Party URL, e.g. /parties/:name/:id */
+    name: string;
+  
+    /** Environment variables (--var, partykit.json#vars, or .env) */
+    env: Record<string, unknown>;
+  
+    /** A per-room key-value storage */
+    storage: Storage;
+  
+    /** `blockConcurrencyWhile()` ensures no requests are delivered until */
+    blockConcurrencyWhile: DurableObjectState["blockConcurrencyWhile"];
+  
+    /** Additional information about other resources in the current project */
+    context: Context;
+  
+    /** @deprecated Use `room.getConnections` instead */
+    connections: Map<string, Connection>;
+  
+    /** @deprecated Use `room.context.parties` instead */
+    parties: Context["parties"];
+  
+    /** Send a message to all connected clients, except connection ids listed `without` */
+    broadcast: (
+      msg: string | ArrayBuffer | ArrayBufferView,
+      without?: string[] | undefined
+    ) => void;
+  
+    /** Get a connection by connection id */
+    getConnection<TState = unknown>(id: string): Connection<TState> | undefined;
+  
+    /**
+     * Get all connections. Optionally, you can provide a tag to filter returned connections.
+     * Use `Party.Server#getConnectionTags` to tag the connection on connect.
+     */
+    getConnections<TState = unknown>(tag?: string): Iterable<Connection<TState>>;
+  
+    /**
+     * Cloudflare Analytics Engine dataset. Use this to log custom events and metrics.
+     */
+    analytics: AnalyticsEngineDataset;
+  };
+  
+  /** @deprecated Use `Party.Room` instead */
+  export type Party = Room;
+  
+  /* Party.Server defines what happens when someone connects to and sends messages or HTTP requests to your party
+   *
+   * @example
+   * export default class Room implements Party.Server {
+   *   constructor(readonly room: Party) {}
+   *   onConnect(connection: Party.Connection) {
+   *     this.room.broadcast("Someone connected with id " + connection.id);
+   *   }
+   * }
+   */
+  export type Server = {
+    /**
+     * You can define an `options` field to customise the Party.Server behaviour.
+     */
+    readonly options?: ServerOptions;
+  
+    /**
+     * You can tag a connection to filter them in Party#getConnections.
+     * Each connection supports up to 9 tags, each tag max length is 256 characters.
+     */
+    getConnectionTags?(
+      connection: Connection,
+      context: ConnectionContext
+    ): string[] | Promise<string[]>;
+  
+    /**
+     * Called when the server is started, before first `onConnect` or `onRequest`.
+     * Useful for loading data from storage.
+     *
+     * You can use this to load data from storage and perform other asynchronous
+     * initialization, such as retrieving data or configuration from other
+     * services or databases.
+     */
+    onStart?(): void | Promise<void>;
+  
+    /**
+     * Called when a new incoming WebSocket connection is opened.
+     */
+    onConnect?(
+      connection: Connection,
+      ctx: ConnectionContext
+    ): void | Promise<void>;
+  
+    /**
+     * Called when a WebSocket connection receives a message from a client, or another connected party.
+     */
+    onMessage?(
+      message: string | ArrayBuffer | ArrayBufferView,
+      sender: Connection
+    ): void | Promise<void>;
+  
+    /**
+     * Called when a WebSocket connection is closed by the client.
+     */
+    onClose?(connection: Connection): void | Promise<void>;
+  
+    /**
+     * Called when a WebSocket connection is closed due to a connection error.
+     */
+    onError?(connection: Connection, error: Error): void | Promise<void>;
+  
+    /**
+     * Called when a HTTP request is made to the room URL.
+     */
+    onRequest?(req: Request): Response | Promise<Response>;
+  
+    /**
+     * Called when an alarm is triggered. Use Party.storage.setAlarm to set an alarm.
+     *
+     * Alarms have access to most Party resources such as storage, but not Party.id
+     * and Party.context.parties properties. Attempting to access them will result in a
+     * runtime error.
+     */
+    onAlarm?(): void | Promise<void>;
+  };
+  
+  export type FetchSocket = WebSocket & {
+    request: Request;
+  };
+  
+  export type Cron = ScheduledController & {
+    name: string;
+  };
+  
+  type ServerConstructor = {
+    new (room: Room): Server;
+  };
+  
+  /**
+   * Party.Worker allows you to customise the behaviour of the Edge worker that routes
+   * connections to your party.
+   *
+   * The Party.Worker methods can be defined as static methods on the Party.Server constructor.
+   * @example
+   * export default class Room implements Party.Server {
+   *   static onBeforeConnect(req: Party.Request) {
+   *     return new Response("Access denied", { status: 403 })
+   *   }
+   *   constructor(readonly room: Room) {}
+   * }
+   *
+   * Room satisfies Party.Worker;
+   */
+  
+  export type Worker = ServerConstructor & {
+    /**
+     * Runs on any HTTP request that does not match a Party URL or a static asset.
+     * Useful for running lightweight HTTP endpoints that don't need access to the Party
+     * state.
+     **/
+    onFetch?(
+      req: Request,
+      lobby: FetchLobby,
+      ctx: ExecutionContext
+    ): Response | undefined | null | Promise<Response | null | undefined>;
+  
+    /**
+     * Runs on any WebSocket connection that does not match a Party URL or a static asset.
+     * Useful for running lightweight WebSocket endpoints that don't need access to the Party
+     * state.
+     */
+    onSocket?(
+      socket: FetchSocket,
+      lobby: FetchLobby,
+      ctx: ExecutionContext
+    ): void | Promise<void>;
+  
+    /**
+     * Runs before any HTTP request is made to the party. You can modify the request
+     * before it is forwarded to the party, or return a Response to short-circuit it.
+     */
+    onBeforeRequest?(
+      req: Request,
+      lobby: Lobby,
+      ctx: ExecutionContext
+    ): Request | Response | Promise<Request | Response>;
+  
+    /**
+     * Runs before any WebSocket connection is made to the party. You can modify the request
+     * before opening a connection, or return a Response to prevent the connection.
+     */
+    onBeforeConnect?(
+      req: Request,
+      lobby: Lobby,
+      ctx: ExecutionContext
+    ): Request | Response | Promise<Request | Response>;
+  
+    /**
+     * Runs on a schedule. You can use this to perform periodic tasks, such as
+     * sending a heartbeat to a third-party service.
+     */
+    onCron?(
+      controller: Cron,
+      lobby: CronLobby,
+      ctx: ExecutionContext
+    ): Response | Promise<Response>;
+  };
+  
+  /**
+   * PartyKitServer is allows you to customise the behaviour of your Party.
+   *
+   * @note If you're starting a new project, we recommend using the newer
+   * Party.Server API instead.
+   *
+   * @example
+   * export default {
+   *   onConnect(connection, room) {
+   *     room.broadcast("Someone connected with id " + connection.id);
+   *   }
+   * }
+   */
+  export type PartyKitServer = {
+    /** @deprecated Use `onFetch` instead */
+    unstable_onFetch?: (
+      req: Request,
+      lobby: FetchLobby,
+      ctx: ExecutionContext
+    ) => Response | null | undefined | Promise<Response | null | undefined>;
+    onFetch?: (
+      req: Request,
+      lobby: FetchLobby,
+      ctx: ExecutionContext
+    ) => Response | null | undefined | Promise<Response | null | undefined>;
+    onSocket?(
+      socket: FetchSocket,
+      lobby: FetchLobby,
+      ctx: ExecutionContext
+    ): void | Promise<void>;
+    onBeforeRequest?: (
+      req: Request,
+      lobby: Lobby,
+      ctx: ExecutionContext
+    ) => ReturnRequest | Response | Promise<ReturnRequest | Response>;
+  
+    onCron?: (
+      controller: Cron,
+      lobby: CronLobby,
+      ctx: ExecutionContext
+    ) => void | Promise<void>;
+  
+    onRequest?: (req: Request, room: Room) => Response | Promise<Response>;
+    onAlarm?: (room: Omit<Room, "id" | "parties">) => void | Promise<void>;
+    onConnect?: (
+      connection: Connection,
+      room: Room,
+      ctx: ConnectionContext
+    ) => void | Promise<void>;
+    onBeforeConnect?: (
+      req: Request,
+      lobby: Lobby,
+      ctx: ExecutionContext
+    ) => ReturnRequest | Response | Promise<ReturnRequest | Response>;
+  
+    /**
+     * PartyKitServer may opt into being hibernated between WebSocket
+     * messages, which enables a single server to handle more connections.
+     */
+    onMessage?: (
+      message: string | ArrayBuffer | ArrayBufferView,
+      connection: Connection,
+      room: Room
+    ) => void | Promise<void>;
+    onClose?: (connection: Connection, room: Room) => void | Promise<void>;
+    onError?: (
+      connection: Connection,
+      err: Error,
+      room: Room
+    ) => void | Promise<void>;
+  };
+  
+  export type ServerOptions = {
+    /**
+     * Whether the PartyKit platform should remove the server from memory
+     * between HTTP requests and WebSocket messages.
+     *
+     * The default value is `false`.
+     */
+    hibernate?: boolean;
+  };
+  
+  //
+  // ---
+  // DEPRECATIONS
+  // ---
+  //
+  
+  /** @deprecated Use Party.Request instead */
+  export type PartyRequest = Request;
+  
+  /** @deprecated Use Party.Storage instead */
+  export type PartyStorage = Storage;
+  
+  /** @deprecated Use Party.Storage instead */
+  export type PartyKitStorage = Storage;
+  
+  /** @deprecated Use Party.ConnectionContext instead */
+  export type PartyConnectionContext = ConnectionContext;
+  
+  /** @deprecated Use Party.ConnectionContext instead */
+  export type PartyKitContext = ConnectionContext;
+  
+  /** @deprecated Use Party.Stub instead */
+  export type PartyStub = Stub;
+  
+  /** Additional information about other resources in the current project */
+  /** @deprecated Use Party.Context instead */
+  export type PartyContext = Context;
+  
+  /** @deprecated Use Party.FetchLobby instead */
+  export type PartyFetchLobby = FetchLobby;
+  
+  /** @deprecated Use Party.Lobby instead */
+  export type PartyLobby = Lobby;
+  
+  /** @deprecated Use Party.ExecutionContext instead */
+  export type PartyExecutionContext = ExecutionContext;
+  
+  /** @deprecated Use Party.Connection instead */
+  export type PartyConnection = Connection;
+  
+  /** @deprecated Use Party.Server instead */
+  export type PartyServer = Server;
+  
+  /** @deprecated Use Party.Worker instead */
+  export type PartyWorker = Worker;
+  
+  /** @deprecated Use `Room` instead */
+  export type PartyKitRoom = Room;
+  
+  /** @deprecated Use `Party.Connection` instead */
+  export type PartyKitConnection = Connection;
+  
+  /** @deprecated Use `Party.ServerOptions` instead */
+  export type PartyServerOptions = ServerOptions;

package/src/utils.ts

@@ -0,0 +1,94 @@
+import { dset } from "dset";
+
+export function isPromise(value: any): boolean {
+  return value && value instanceof Promise;
+}
+
+export async function awaitReturn(val: any) {
+  return isPromise(val) ? await val : val;
+}
+
+export function isClass(obj: any): boolean {
+  return (
+    typeof obj === "function" &&
+    obj.prototype &&
+    obj.prototype.constructor === obj
+  );
+}
+
+export function throttle<F extends (...args: any[]) => any>(
+  func: F,
+  wait: number
+): (...args: Parameters<F>) => void {
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+  let lastArgs: Parameters<F> | null = null;
+
+  return function (...args: Parameters<F>) {
+    if (!timeout) {
+      func(...args);
+      timeout = setTimeout(() => {
+        if (lastArgs) {
+          func(...lastArgs);
+          lastArgs = null;
+        }
+        timeout = null;
+      }, wait);
+    } else {
+      lastArgs = args;
+    }
+  };
+}
+
+export function extractParams(
+  pattern: string,
+  str: string
+): { [key: string]: string } | null {
+  const regexPattern = pattern.replace(/{(\w+)}/g, "(?<$1>[\\w-]+)");
+
+  const regex = new RegExp(`^${regexPattern}$`);
+  const match = regex.exec(str);
+
+  if (match && match.groups) {
+    return match.groups;
+  } else {
+    return null;
+  }
+}
+
+export function dremove(obj, keys) {
+  keys.split && (keys = keys.split("."));
+  var i = 0,
+    l = keys.length,
+    t = { ...obj },
+    k;
+
+  while (i < l - 1) {
+    k = keys[i++];
+    if (k === "__proto__" || k === "constructor" || k === "prototype") return; // On évite les clés dangereuses
+    t = t[k];
+    if (typeof t !== "object" || t === null) return; // Si l'objet n'existe pas, on arrête
+  }
+
+  k = keys[i];
+  if (
+    t &&
+    typeof t === "object" &&
+    !(k === "__proto__" || k === "constructor" || k === "prototype")
+  ) {
+    delete t[k];
+  }
+}
+
+export function buildObject(valuesMap, allMemory) {
+    let memoryObj = {};
+    for (let path of valuesMap.keys()) {
+      const value = valuesMap.get(path);
+      dset(memoryObj, path, value);
+      if (path == "$delete") {
+        dremove(allMemory, value);
+      } else {
+        dset(allMemory, path, value);
+      }
+    }
+    return memoryObj;
+  }