@signe/room 2.10.0 → 3.0.1

package/dist/index.d.ts

@@ -1,176 +1,7 @@
-import { Request as Request$2, DurableObjectStorage, WebSocket, DurableObjectState, AnalyticsEngineDataset, VectorizeIndex, R2Bucket, KVNamespace } from '@cloudflare/workers-types';
+import { C as Connection, R as Request$1, a as Room$1, b as ConnectionContext, S as Server$1, c as Storage$1 } from './party-dNs-hqkq.js';
 import { z } from 'zod';
 import * as _signe_reactive from '@signe/reactive';
-
-type AssetFetcher = {
-    fetch(path: string): Promise<Response | null>;
-};
-type StandardRequest = globalThis.Request;
-interface Request$1 extends Request$2 {
-}
-type ReturnRequest = StandardRequest | Request$2;
-/** Per-party key-value storage */
-interface Storage$1 extends DurableObjectStorage {
-}
-/** Connection metadata only available when the connection is made */
-type ConnectionContext = {
-    request: Request$2;
-};
-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$1 = {
-    /** 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$1;
-    /** `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$1): 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;
-};
+import '@cloudflare/workers-types';
 
 type GuardFn = (sender: Connection, value: any | Request$1, room: Room$1) => boolean | Promise<boolean | Response>;
 type RoomGuardFn = (conn: Connection, ctx: ConnectionContext, room: Room$1) => boolean | Promise<boolean | Response>;
@@ -211,6 +42,28 @@ declare function RoomGuard(guards: RoomGuardFn[]): (target: any) => void;
  */
 declare function Guard(guards: GuardFn[]): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 
+type StorageRestoreContext<TSnapshot = any> = {
+    snapshot: TSnapshot;
+    room: Room$1;
+    server: Server;
+    legacy: boolean;
+};
+type UserStorageRestoreContext<TUser = any, TSnapshot = any> = {
+    userSnapshot: TSnapshot;
+    user: TUser | undefined;
+    publicId: string;
+    usersPropName: string;
+    room: Room$1;
+    server: Server;
+    legacy: boolean;
+};
+type SessionData = {
+    publicId: string;
+    state?: any;
+    created?: number;
+    connected?: boolean;
+    disconnectedAt?: number;
+};
 /**
  * @class Server
  * @implements {Party.Server}
@@ -260,6 +113,26 @@ declare class Server implements Server$1 {
       */
     get isHibernate(): boolean;
     get roomStorage(): Storage$1;
+    private stateKey;
+    private sessionKey;
+    private sessionPublicKey;
+    private transferKey;
+    private isInternalStorageKey;
+    private listStorage;
+    private loadStatePath;
+    private saveStatePath;
+    private putStorageEntries;
+    private deleteStorageKeys;
+    private deleteStatePath;
+    private containsDeleteToken;
+    private compactStateStorage;
+    private createUserFromClassType;
+    private restoreUsersStorageSnapshot;
+    private restoreStorageSnapshot;
+    private createStorageMetrics;
+    private getTransferExpiryTime;
+    private getPrivateId;
+    private hasActiveSessionConnection;
     send(conn: Connection, obj: any, subRoom: any): Promise<void>;
     broadcast(obj: any, subRoom: any): void;
     /**
@@ -279,6 +152,14 @@ declare class Server implements Server$1 {
     onStart(): Promise<void>;
     runGarbageCollector(): Promise<void>;
     private garbageCollector;
+    private scheduleSessionGarbageCollector;
+    private getSessionExpiryTime;
+    private shouldRunSessionGarbageCollector;
+    private shouldRunInterval;
+    private repairSessionPublicIndexes;
+    private isTransferExpired;
+    private cleanupExpiredTransfers;
+    private expireDisconnectedSession;
     /**
      * @method createRoom
      * @private
@@ -359,12 +240,12 @@ declare class Server implements Server$1 {
      * console.log(session);
      * ```
      */
-    getSession(privateId: string): Promise<{
-        publicId: string;
-        state?: any;
-        created?: number;
-        connected?: boolean;
-    } | null>;
+    getSession(privateId: string): Promise<SessionData | null>;
+    private getSessionPrivateIds;
+    private saveSessionPrivateIds;
+    private addSessionToPublicIndex;
+    private removeSessionFromPublicIndex;
+    private getSessionEntryByPublicId;
     private saveSession;
     private updateSessionConnection;
     /**
@@ -397,6 +278,7 @@ declare class Server implements Server$1 {
      * ```
      */
     onConnect(conn: Connection, ctx: ConnectionContext): Promise<void>;
+    private isAuthorizedShardRequest;
     /**
      * @method onConnectShard
      * @private
@@ -551,10 +433,12 @@ declare class Server implements Server$1 {
 
 declare class Storage {
     private memory;
-    put(key: any, value: any): Promise<void>;
+    put(key: any, value?: any): Promise<void>;
     get(key: any): Promise<any>;
-    delete(key: any): Promise<void>;
-    list(): Promise<Map<any, any>>;
+    delete(key: any): Promise<number | boolean>;
+    list(options?: {
+        prefix?: string;
+    }): Promise<Map<any, any>>;
 }
 
 declare class MockPartyClient {
@@ -562,7 +446,7 @@ declare class MockPartyClient {
     private events;
     id: string;
     conn: MockConnection;
-    constructor(server: Server, id?: string);
+    constructor(server: Server, sessionId?: string);
     addEventListener(event: any, cb: any): void;
     removeEventListener(event: any, cb: any): void;
     _trigger(event: any, data: any): void;
@@ -591,15 +475,17 @@ declare class MockPartyRoom {
         headers?: Record<string, string>;
     }): Promise<MockPartyClient>;
     broadcast(data: any): void;
-    getConnection(id: string): MockPartyClient;
+    getConnection(id: string): MockConnection;
     getConnections(): MockConnection[];
     clear(): void;
+    deleteConnection(id: string, connection?: MockConnection): void;
 }
 declare class MockConnection {
     client: MockPartyClient;
     server: Server;
     id: string;
-    constructor(client: MockPartyClient);
+    sessionId: string;
+    constructor(client: MockPartyClient, sessionId: string);
     state: any;
     setState(value: any): void;
     send(data: any): void;
@@ -621,21 +507,25 @@ interface ShardOptions {
 declare class Shard {
     private room;
     ws: PartyWebSocket;
-    connectionMap: Map<string, Connection<unknown>>;
+    connectionMap: Map<string, Set<Connection<unknown>>>;
     mainServerStub: any;
     worldUrl: string | null;
     worldId: string;
     lastReportedConnections: number;
     statsInterval: number;
     statsIntervalId: any;
-    constructor(room: Room$1);
+    constructor(room: Room$1, options?: ShardOptions);
+    private getPrivateId;
+    private getEnvString;
+    private getRoomIdFromShardId;
+    private getWorldIdFromShardId;
     onStart(): Promise<void>;
     private startPeriodicStatsUpdates;
     private stopPeriodicStatsUpdates;
     onConnect(conn: Connection, ctx: ConnectionContext): void;
     onMessage(message: string | ArrayBuffer | ArrayBufferView, sender: Connection): void;
     onClose(conn: Connection): void;
-    updateWorldStats(): Promise<boolean>;
+    updateWorldStats(force?: boolean): Promise<boolean>;
     /**
      * @method onRequest
      * @async
@@ -680,6 +570,7 @@ declare class Shard {
 declare function testRoom(Room: any, options?: {
     hibernate?: boolean;
     shard?: boolean;
+    id?: string;
     env?: Record<string, string>;
     parties?: Record<string, (io: any) => any>;
     partyFn?: (io: any) => any;
@@ -849,6 +740,7 @@ declare class RoomConfig {
 declare class ShardInfo {
     id: string;
     roomId: _signe_reactive.WritableSignal<string>;
+    worldId: _signe_reactive.WritableSignal<string>;
     url: _signe_reactive.WritableSignal<string>;
     currentConnections: _signe_reactive.WritableSignal<number>;
     maxConnections: _signe_reactive.WritableSignal<number>;
@@ -865,13 +757,20 @@ declare class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
     constructor(room: Room$1);
     onJoin(user: any, conn: Connection, ctx: ConnectionContext): Promise<void>;
     interceptorPacket(_: any, obj: any, conn: Connection): any;
+    private getWorldId;
+    private scheduleInactiveShardCleanup;
     private cleanupInactiveShards;
-    registerRoom(req: Request$1): Promise<void>;
+    private removeShard;
+    private shouldCompleteDrain;
+    registerRoom(req: Request$1, res?: ServerResponse): Promise<Response>;
     updateShardStats(req: Request$1, res: ServerResponse): Promise<Response>;
     scaleRoom(req: Request$1, res: ServerResponse): Promise<Response>;
     connect(req: Request$1, res: ServerResponse): Promise<Response>;
     private findOptimalShard;
+    private getAvailableShards;
+    private canCreateShard;
     private createShard;
+    private ensureMinShards;
 }
 
 /**
@@ -927,4 +826,4 @@ declare function createRequireSessionGuard(storage: Storage$1): (sender: Connect
  */
 declare const requireSession: (sender: Connection, value: any, room: Room$1) => Promise<boolean>;
 
-export { Action, ClientIo, Guard, MockConnection, Request, type RequestOptions, Room, RoomGuard, type RoomInterceptorPacket, type RoomMethods, type RoomOnJoin, type RoomOnLeave, type RoomOptions, Server, ServerIo, ServerResponse, Shard, type ShardOptions, UnhandledAction, WorldRoom, createRequireSessionGuard, request, requireSession, testRoom, tick };
+export { Action, ClientIo, Guard, MockConnection, Request, type RequestOptions, Room, RoomGuard, type RoomInterceptorPacket, type RoomMethods, type RoomOnJoin, type RoomOnLeave, type RoomOptions, Server, ServerIo, ServerResponse, Shard, type ShardOptions, type StorageRestoreContext, UnhandledAction, type UserStorageRestoreContext, WorldRoom, createRequireSessionGuard, request, requireSession, testRoom, tick };