@pluv/io 2.1.0 → 2.2.1

package/src/PluvServer.ts

@@ -7,6 +7,7 @@ import type {
     InferIOAuthorizeUser,
     JsonObject,
     Maybe,
+    NonNilProps,
 } from "@pluv/types";
 import colors from "kleur";
 import type {
@@ -50,12 +51,12 @@ export type PluvServerConfig<
 > = Partial<PluvIOListeners<TPlatform, TAuthorize, TContext, TEvents>> & {
     authorize?: TAuthorize;
     context?: PluvContext<TPlatform, TContext>;
-    crdt?: { doc: (value: any) => AbstractCrdtDocFactory<any> };
+    crdt?: { doc: (value: any) => AbstractCrdtDocFactory<any, any> };
     debug?: boolean;
     getInitialStorage?: GetInitialStorageFn<TContext>;
     limits: PluvIOLimits;
     io: PluvIO<TPlatform, TAuthorize, TContext>;
-    platform: TPlatform;
+    platform: () => TPlatform;
     router?: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
 };
 
@@ -95,249 +96,268 @@ export class PluvServer<
 {
     public readonly version: string = __PLUV_VERSION as any;
 
-    private readonly _authorize: TAuthorize = null as TAuthorize;
-    private readonly _baseRouter: PluvRouter<TPlatform, TAuthorize, TContext, {}> = new PluvRouter({
-        $getOthers: this._procedure.sync((data, { room, session, sessions }) => {
-            const currentTime = Date.now();
+    private readonly _config: NonNilProps<
+        PluvServerConfig<TPlatform, TAuthorize, TContext, TEvents>
+    >;
 
-            const others = sessions
-                .filter((wsSession) => {
-                    if (wsSession.id === session?.id) return false;
-                    if (wsSession.quit) return false;
-                    if (currentTime - wsSession.timers.ping > PING_TIMEOUT_MS) return false;
+    public get fetch(): (...args: any[]) => Promise<any> {
+        const platform = this._config.platform();
 
-                    return true;
-                })
-                .reduce<{
-                    [connectionId: string]: {
-                        connectionId: string;
-                        room: string | null;
-                        user: JsonObject | null;
-                    };
-                }>(
-                    (acc, { id, presence, timers, user }) => ({
-                        ...acc,
-                        [id]: {
-                            connectionId: id,
+        return ((...args: any[]): Promise<any> => {
+            if (!platform._fetch)
+                throw new Error(`\`${platform._name}\` does not support \`fetch\``);
+
+            return platform._fetch(...args);
+        }) as NonNullable<typeof platform._fetch>;
+    }
+
+    /**
+     * @ignore
+     * @readonly
+     * @deprecated Internal use only. Changes to this will never be marked as breaking.
+     */
+    public get _defs() {
+        return {
+            authorize: this._config.authorize,
+            context: this._config.context,
+            events: this._router._defs.events,
+            platform: this._config.platform(),
+        } as {
+            authorize: TAuthorize;
+            context: TContext;
+            events: TEvents;
+            platform: TPlatform;
+        };
+    }
+
+    private get _baseRouter(): PluvRouter<TPlatform, TAuthorize, TContext, {}> {
+        const listeners = this._getListeners();
+
+        return new PluvRouter({
+            $getOthers: this._procedure.sync((data, { room, session, sessions }) => {
+                const currentTime = Date.now();
+
+                const others = sessions
+                    .filter((wsSession) => {
+                        if (wsSession.id === session?.id) return false;
+                        if (wsSession.quit) return false;
+                        if (currentTime - wsSession.timers.ping > PING_TIMEOUT_MS) return false;
+
+                        return true;
+                    })
+                    .reduce<{
+                        [connectionId: string]: {
+                            connectionId: string;
+                            room: string | null;
+                            user: JsonObject | null;
+                        };
+                    }>(
+                        (acc, { id, presence, timers, user }) => ({
+                            ...acc,
+                            [id]: {
+                                connectionId: id,
+                                presence,
+                                room,
+                                timers: { presence: timers.presence },
+                                user,
+                            },
+                        }),
+                        {},
+                    );
+
+                return { $othersReceived: { others } };
+            }),
+            $initializeSession: this._procedure
+                .broadcast((data, { session }) => {
+                    const presence = (data as any)?.presence;
+                    const timers = session.timers;
+
+                    if (!session) return {};
+
+                    session.presence = presence;
+
+                    return {
+                        $userJoined: {
+                            connectionId: session.id,
+                            user: session.user,
                             presence,
-                            room,
                             timers: { presence: timers.presence },
-                            user,
                         },
-                    }),
-                    {},
-                );
+                    };
+                })
+                .self(async (data, { context, doc, platform, room, session }) => {
+                    const oldState = await platform.persistence.getStorageState(room);
+                    /**
+                     * !HACK
+                     * @description This is the frontend's initialStorage. We only want to
+                     * apply this if the server's storage is empty (i.e. no initial storage
+                     * has been applied)
+                     */
+                    const update = (data as any)?.update as Maybe<string>;
+
+                    if (!oldState) {
+                        const loadedState = await this._config.getInitialStorage?.({
+                            context,
+                            room,
+                        });
 
-            return { $othersReceived: { others } };
-        }),
-        $initializeSession: this._procedure
-            .broadcast((data, { session }) => {
-                const presence = (data as any)?.presence;
-                const timers = session.timers;
+                        if (!!loadedState) {
+                            doc.applyEncodedState({ update: loadedState }).getEncodedState();
+                        }
+                    }
 
-                if (!session) return {};
+                    /**
+                     * @description Storage was already initialized. Don't overwrite the current
+                     * storage state with the incoming initial storage. Return what the current state
+                     * is without changes.
+                     * @date May 7, 2025
+                     */
+                    if (!doc.isEmpty()) {
+                        const encodedState = doc.getEncodedState();
+
+                        return {
+                            $storageReceived: { changeKind: "unchanged", state: encodedState },
+                        };
+                    }
 
-                session.presence = presence;
+                    /**
+                     * @description Storage was never initialized, and there is an incoming
+                     * initialStorage from the client. Apply the initialStorage and persist the state
+                     * as an update.
+                     * @date May 7, 2025
+                     */
+                    if (!!update) {
+                        const encodedState = doc.applyEncodedState({ update }).getEncodedState();
+                        const storageSize = new TextEncoder().encode(encodedState).length;
+
+                        if (
+                            !!this._config.limits.storageMaxSize &&
+                            storageSize > this._config.limits.storageMaxSize
+                        ) {
+                            throw new Error("Storage has exceeded the size limit");
+                        }
+
+                        await platform.persistence
+                            .setStorageState(room, encodedState)
+                            .catch((error) => {
+                                this._logDebug(error);
+                            });
+
+                        listeners.onStorageUpdated({
+                            context,
+                            encodedState,
+                            platform,
+                            room,
+                            user: session?.user,
+                            webSocket: session?.webSocket.webSocket,
+                        });
 
-                return {
-                    $userJoined: {
-                        connectionId: session.id,
-                        user: session.user,
-                        presence,
-                        timers: { presence: timers.presence },
-                    },
-                };
-            })
-            .self(async (data, { context, doc, room, session }) => {
-                const oldState = await this._platform.persistence.getStorageState(room);
-                /**
-                 * !HACK
-                 * @description This is the frontend's initialStorage. We only want to
-                 * apply this if the server's storage is empty (i.e. no initial storage
-                 * has been applied)
-                 */
-                const update = (data as any)?.update as Maybe<string>;
-
-                if (!oldState) {
-                    const loadedState = await this._getInitialStorage?.({ context, room });
-
-                    if (!!loadedState) {
-                        doc.applyEncodedState({ update: loadedState }).getEncodedState();
+                        return {
+                            $storageReceived: { changeKind: "initialized", state: encodedState },
+                        };
                     }
-                }
 
-                /**
-                 * @description Storage was already initialized. Don't overwrite the current
-                 * storage state with the incoming initial storage. Return what the current state
-                 * is without changes.
-                 * @date May 7, 2025
-                 */
-                if (!doc.isEmpty()) {
                     const encodedState = doc.getEncodedState();
 
-                    return { $storageReceived: { changeKind: "unchanged", state: encodedState } };
-                }
+                    return { $storageReceived: { changeKind: "empty", state: encodedState } };
+                }),
+            $ping: this._procedure.self((data, { platform, session }) => {
+                if (!session) return {};
 
-                /**
-                 * @description Storage was never initialized, and there is an incoming
-                 * initialStorage from the client. Apply the initialStorage and persist the state
-                 * as an update.
-                 * @date May 7, 2025
-                 */
-                if (!!update) {
-                    const encodedState = doc.applyEncodedState({ update }).getEncodedState();
-                    const storageSize = new TextEncoder().encode(encodedState).length;
-
-                    if (
-                        !!this._limits.storageMaxSize &&
-                        storageSize > this._limits.storageMaxSize
-                    ) {
-                        throw new Error("Storage has exceeded the size limit");
-                    }
+                const currentTime = new Date().getTime();
+                const prevState = session.webSocket.state;
 
-                    await this._platform.persistence
-                        .setStorageState(room, encodedState)
-                        .catch((error) => {
-                            this._logDebug(error);
-                        });
+                platform.setSerializedState(session.webSocket, {
+                    ...prevState,
+                    timers: {
+                        ...prevState.timers,
+                        ping: currentTime,
+                    },
+                });
 
-                    this._getListeners().onStorageUpdated({
-                        context,
-                        encodedState,
-                        room,
-                        user: session?.user,
-                        webSocket: session?.webSocket.webSocket,
-                    });
+                return { $pong: {} };
+            }),
+            $updatePresence: this._procedure.broadcast((data, context) => {
+                const presence = (data as any)?.presence;
+                const { session } = context;
 
-                    return { $storageReceived: { changeKind: "initialized", state: encodedState } };
+                if (!session) return {};
+
+                const cleanedPatch = pickBy(
+                    presence ?? {},
+                    (value) => typeof value !== "undefined",
+                );
+                const updated = Object.assign(Object.create(null), session.presence, cleanedPatch);
+                const bytes = new TextEncoder().encode(JSON.stringify(updated)).length;
+
+                if (
+                    !!this._config.limits.presenceMaxSize &&
+                    bytes > this._config.limits.presenceMaxSize
+                ) {
+                    throw new Error(
+                        `Large presence. Presence must be at most 512 bytes. Current size: ${bytes.toLocaleString()}`,
+                    );
                 }
 
-                const encodedState = doc.getEncodedState();
+                context.presence = updated;
 
-                return { $storageReceived: { changeKind: "empty", state: encodedState } };
+                return {
+                    $presenceUpdated: {
+                        presence: updated,
+                        timers: { presence: session.timers.presence },
+                    },
+                };
             }),
-        $ping: this._procedure.self((data, { session }) => {
-            if (!session) return {};
-
-            const currentTime = new Date().getTime();
-            const prevState = session.webSocket.state;
-
-            this._platform.setSerializedState(session.webSocket, {
-                ...prevState,
-                timers: {
-                    ...prevState.timers,
-                    ping: currentTime,
-                },
-            });
-
-            return { $pong: {} };
-        }),
-        $updatePresence: this._procedure.broadcast((data, context) => {
-            const presence = (data as any)?.presence;
-            const { session } = context;
-
-            if (!session) return {};
-
-            const cleanedPatch = pickBy(presence ?? {}, (value) => typeof value !== "undefined");
-            const updated = Object.assign(Object.create(null), session.presence, cleanedPatch);
-            const bytes = new TextEncoder().encode(JSON.stringify(updated)).length;
-
-            if (!!this._limits.presenceMaxSize && bytes > this._limits.presenceMaxSize) {
-                throw new Error(
-                    `Large presence. Presence must be at most 512 bytes. Current size: ${bytes.toLocaleString()}`,
-                );
-            }
-
-            context.presence = updated;
-
-            return {
-                $presenceUpdated: {
-                    presence: updated,
-                    timers: { presence: session.timers.presence },
-                },
-            };
-        }),
-        $updateStorage: this._procedure.broadcast((data, { context, doc, room }) => {
-            const origin = (data as any)?.origin as Maybe<string>;
-            const update: string | null = (data as any)?.update ?? null;
-
-            if (origin === "$initialized" && Object.keys(doc.toJson()).length) return {};
-
-            const updated = update === null ? doc : doc.applyEncodedState({ update });
-            const encodedState = updated.getEncodedState();
-            const storageSize = new TextEncoder().encode(encodedState).length;
-
-            if (!!this._limits.storageMaxSize && storageSize > this._limits.storageMaxSize) {
-                throw new Error("Storage has exceeded the size limit");
-            }
-
-            this._platform.persistence.setStorageState(room, encodedState).then(() => {
-                this._getListeners().onStorageUpdated({
-                    context,
-                    encodedState,
-                    room,
-                });
-            });
+            $updateStorage: this._procedure.broadcast((data, { context, doc, platform, room }) => {
+                const origin = (data as any)?.origin as Maybe<string>;
+                const update: string | null = (data as any)?.update ?? null;
 
-            return { $storageUpdated: { state: encodedState } };
-        }),
-    });
-    private readonly _context: PluvContext<TPlatform, TContext> = {} as PluvContext<
-        TPlatform,
-        TContext
-    >;
-    private readonly _crdt: { doc: (value: any) => AbstractCrdtDocFactory<any> };
-    private readonly _debug: boolean;
-    private readonly _getInitialStorage: GetInitialStorageFn<TContext> | null = null;
-    private readonly _io: PluvIO<TPlatform, TAuthorize, TContext>;
-    private readonly _limits: PluvIOLimits;
-    private readonly _platform: TPlatform;
-    private readonly _router: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
+                if (origin === "$initialized" && Object.keys(doc.toJson()).length) return {};
 
-    public get fetch(): (...args: any[]) => Promise<any> {
-        return ((...args: any[]): Promise<any> => {
-            if (!this._platform._fetch)
-                throw new Error(`\`${this._platform._name}\` does not support \`fetch\``);
+                const updated = update === null ? doc : doc.applyEncodedState({ update });
+                const encodedState = updated.getEncodedState();
+                const storageSize = new TextEncoder().encode(encodedState).length;
 
-            return this._platform._fetch(...args);
-        }) as NonNullable<typeof this._platform._fetch>;
-    }
+                if (
+                    !!this._config.limits.storageMaxSize &&
+                    storageSize > this._config.limits.storageMaxSize
+                ) {
+                    throw new Error("Storage has exceeded the size limit");
+                }
 
-    /**
-     * @ignore
-     * @readonly
-     * @deprecated Internal use only. Changes to this will never be marked as breaking.
-     */
-    public get _defs() {
-        return {
-            authorize: this._authorize,
-            context: this._context,
-            events: this._router._defs.events,
-            platform: this._platform,
-        } as {
-            authorize: TAuthorize;
-            context: TContext;
-            events: TEvents;
-            platform: TPlatform;
-        };
+                platform.persistence.setStorageState(room, encodedState).then(() => {
+                    listeners.onStorageUpdated({
+                        context,
+                        encodedState,
+                        platform,
+                        room,
+                    });
+                });
+
+                return { $storageUpdated: { state: encodedState } };
+            }),
+        });
     }
 
     private get _procedure(): PluvProcedure<TPlatform, TAuthorize, TContext, {}, {}> {
         return new PluvProcedure();
     }
 
+    private get _router(): PluvRouter<TPlatform, TAuthorize, TContext, TEvents> {
+        return (
+            this._config.router
+                ? PluvRouter.merge(this._baseRouter, this._config.router)
+                : this._baseRouter
+        ) as PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
+    }
+
     constructor(options: PluvServerConfig<TPlatform, TAuthorize, TContext, TEvents>) {
-        const {
-            authorize,
-            context,
-            crdt = noop,
-            debug = false,
-            getInitialStorage,
-            io,
-            limits,
-            platform,
-            router = new PluvRouter<TPlatform, TAuthorize, TContext, TEvents>({} as TEvents),
-        } = options;
+        this._config = {
+            crdt: noop,
+            debug: false,
+            router: new PluvRouter<TPlatform, TAuthorize, TContext, TEvents>({} as TEvents),
+            ...options,
+        } as NonNilProps<PluvServerConfig<TPlatform, TAuthorize, TContext, TEvents>>;
 
         const {
             onRoomDeleted,
@@ -347,21 +367,6 @@ export class PluvServer<
             onUserDisconnected,
         } = options as Partial<BasePluvIOListeners<TPlatform, TAuthorize, TContext, TEvents>>;
 
-        platform.validateConfig(options);
-
-        this._crdt = crdt;
-        this._debug = debug;
-        this._io = io;
-        this._limits = limits;
-        this._platform = platform;
-        this._router = (
-            router ? PluvRouter.merge(this._baseRouter, router) : this._baseRouter
-        ) as PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
-
-        if (authorize) this._authorize = authorize;
-        if (context) this._context = context;
-        if (getInitialStorage) this._getInitialStorage = getInitialStorage;
-
         (this as any)._listeners = {
             onRoomDeleted: (event) => onRoomDeleted?.(event),
             onRoomMessage: (event) => onRoomMessage?.(event),
@@ -378,8 +383,12 @@ export class PluvServer<
         const { _meta, debug, onDestroy, onMessage, ...platformRoomContext } = (options[0] ??
             {}) as CreateRoomOptions<TPlatform, TAuthorize, TContext, TEvents>[0] & { _meta?: any };
 
-        if (this._platform._config.handleMode !== "io") {
-            throw new Error(`\`createRoom\` is unsupported for \`${this._platform._name}\``);
+        const platform = this._config.platform();
+
+        platform.validateConfig(this._config);
+
+        if (platform._config.handleMode !== "io") {
+            throw new Error(`\`createRoom\` is unsupported for \`${platform._name}\``);
         }
 
         if (!/^[a-z0-9](?:[a-z0-9-_]*[a-z0-9])?$/i.test(room))
@@ -387,34 +396,38 @@ export class PluvServer<
 
         const roomContext = platformRoomContext as InferRoomContextType<TPlatform>;
         const context: TContext =
-            typeof this._context === "function" ? this._context(roomContext) : this._context;
+            typeof this._config.context === "function"
+                ? this._config.context(roomContext)
+                : this._config.context;
+        const listeners = this._getListeners();
+        const logDebug = this._logDebug.bind(this);
 
         const newRoom = new IORoom<TPlatform, TAuthorize, TContext, TEvents>(room, {
             ...(!!_meta ? { _meta } : {}),
-            authorize: this._authorize ?? undefined,
+            authorize: this._config.authorize ?? undefined,
             context,
-            crdt: this._crdt,
-            debug: debug ?? this._debug,
-            onDestroy: async (event) => {
-                this._logDebug(`${colors.blue("Deleting empty room:")} ${room}`);
+            crdt: this._config.crdt,
+            debug: debug ?? this._config.debug,
+            async onDestroy(event) {
+                logDebug(`${colors.blue("Deleting empty room:")} ${room}`);
 
                 await Promise.resolve(onDestroy?.(event));
-                await Promise.resolve(this._getListeners().onRoomDeleted(event));
-                await this._platform.persistence.deleteStorageState(room);
+                await Promise.resolve(listeners.onRoomDeleted(event));
+                await event.platform.persistence.deleteStorageState(room);
 
-                this._logDebug(`${colors.blue("Deleted room:")} ${room}`);
+                logDebug(`${colors.blue("Deleted room:")} ${room}`);
             },
-            onMessage: async (event) => {
+            async onMessage(event) {
                 await Promise.resolve(onMessage?.(event));
-                await Promise.resolve(this._getListeners().onRoomMessage(event));
+                await Promise.resolve(listeners.onRoomMessage(event));
             },
-            onUserConnected: async (event) => {
-                await Promise.resolve(this._getListeners().onUserConnected(event));
+            async onUserConnected(event) {
+                await Promise.resolve(listeners.onUserConnected(event));
             },
-            onUserDisconnected: async (event) => {
-                await Promise.resolve(this._getListeners().onUserDisconnected(event));
+            async onUserDisconnected(event) {
+                await Promise.resolve(listeners.onUserDisconnected(event));
             },
-            platform: this._platform,
+            platform,
             roomContext,
             router: this._router,
         });
@@ -427,7 +440,7 @@ export class PluvServer<
     public async createToken(
         params: JWTEncodeParams<InferIOAuthorizeUser<InferIOAuthorize<this>>, TPlatform>,
     ): Promise<string> {
-        return await this._io.createToken(params);
+        return await this._config.io.createToken(params);
     }
 
     private _getListeners(): BasePluvIOListeners<TPlatform, TAuthorize, TContext, TEvents> {
@@ -435,6 +448,6 @@ export class PluvServer<
     }
 
     private _logDebug(...data: any[]): void {
-        if (this._debug) console.log(...data);
+        if (this._config.debug) console.log(...data);
     }
 }

package/src/createIO.ts

@@ -13,7 +13,7 @@ export type CreateIOParams<
     crdt?: CrdtLibraryType;
     debug?: boolean;
     limits?: PluvIOLimits;
-    platform: TPlatform;
+    platform: () => TPlatform;
 };
 
 export const createIO = <