@pluv/io 0.22.0 → 0.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/io",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "@pluv/io server-side websocket manager",
   "author": "leedavidcs",
   "license": "MIT",
@@ -21,16 +21,16 @@
     "jose": "^5.6.3",
     "kleur": "^4.1.5",
     "wonka": "^6.3.4",
-    "@pluv/crdt": "^0.22.0",
-    "@pluv/types": "^0.22.0"
+    "@pluv/crdt": "^0.24.0",
+    "@pluv/types": "^0.24.0"
   },
   "devDependencies": {
     "eslint": "^8.57.0",
     "genversion": "^3.2.0",
     "tsup": "^8.2.4",
     "typescript": "^5.5.4",
-    "@pluv/tsconfig": "^0.22.0",
-    "eslint-config-pluv": "^0.22.0"
+    "@pluv/tsconfig": "^0.24.0",
+    "eslint-config-pluv": "^0.24.0"
   },
   "scripts": {
     "build": "pnpm run version && tsup src/index.ts --format esm,cjs --dts",

package/src/AbstractPlatform.ts

@@ -39,16 +39,16 @@ export abstract class AbstractPlatform<
     TPlatformContext extends Record<string, any> = {},
     TRoomContext extends Record<string, any> = {},
 > {
-    private _initialized: boolean = false;
-
-    readonly _ioContext: TPlatformContext | undefined;
-    readonly _roomContext: TRoomContext | undefined;
+    protected readonly _ioContext: TPlatformContext | undefined;
+    protected readonly _roomContext: TRoomContext | undefined;
 
-    abstract readonly _registrationMode: WebSocketRegistrationMode;
+    private _initialized: boolean = false;
 
     public persistance: AbstractPersistance;
     public pubSub: AbstractPubSub;
 
+    public abstract readonly _registrationMode: WebSocketRegistrationMode;
+
     constructor(config: AbstractPlatformConfig<TPlatformContext, TRoomContext> = {}) {
         const { context, persistance, pubSub } = config;
 

package/src/IORoom.ts

@@ -5,9 +5,11 @@ import type {
     BaseIOEventRecord,
     EventMessage,
     IOAuthorize,
+    IOEventMessage,
     IOLike,
     Id,
     InferEventMessage,
+    InferEventsOutput,
     InferIOAuthorize,
     InferIOAuthorizeUser,
     InferIOInput,
@@ -16,12 +18,7 @@ import type {
     Maybe,
 } from "@pluv/types";
 import colors from "kleur";
-import type {
-    AbstractPlatform,
-    InferPlatformWebSocketSource,
-    InferPlatformWebSocketType,
-    InferRoomContextType,
-} from "./AbstractPlatform";
+import type { AbstractPlatform, InferPlatformWebSocketSource, InferRoomContextType } from "./AbstractPlatform";
 import { AbstractCloseEvent, AbstractErrorEvent, AbstractMessageEvent, AbstractWebSocket } from "./AbstractWebSocket";
 import type { PluvRouter, PluvRouterEventConfig } from "./PluvRouter";
 import { authorize } from "./authorize";
@@ -29,7 +26,7 @@ import { PING_TIMEOUT_MS } from "./constants";
 import type {
     EventResolverContext,
     IORoomListenerEvent,
-    SendMessageOptions,
+    IORoomMessageEvent,
     WebSocketSession,
     WebSocketType,
 } from "./types";
@@ -43,8 +40,14 @@ interface BroadcastParams<TIO extends IORoom<any, any, any, any>> {
     senderId?: string;
 }
 
-interface IORoomListeners<TPlatform extends AbstractPlatform> {
-    onDestroy: (event: IORoomListenerEvent<TPlatform>) => void;
+export interface IORoomListeners<
+    TPlatform extends AbstractPlatform<any>,
+    TAuthorize extends IOAuthorize<any, any, InferRoomContextType<TPlatform>>,
+    TContext extends JsonObject,
+    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext>,
+> {
+    onDestroy: (event: IORoomListenerEvent<TPlatform, TAuthorize, TContext, TEvents>) => void;
+    onMessage: (event: IORoomMessageEvent<TPlatform, TAuthorize, TContext, TEvents>) => void;
 }
 
 export type BroadcastProxy<TIO extends IORoom<any, any, any, any>> = (<TEvent extends keyof InferIOInput<TIO>>(
@@ -59,7 +62,7 @@ export type IORoomConfig<
     TAuthorize extends IOAuthorize<any, any, InferRoomContextType<TPlatform>> = BaseIOAuthorize,
     TContext extends JsonObject = {},
     TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
-> = Partial<IORoomListeners<TPlatform>> & {
+> = Partial<IORoomListeners<TPlatform, TAuthorize, TContext, TEvents>> & {
     authorize?: TAuthorize;
     context: TContext & InferRoomContextType<TPlatform>;
     crdt?: { doc: (value: any) => AbstractCrdtDocFactory<any> };
@@ -84,20 +87,19 @@ export class IORoom<
     TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
 > implements IOLike<TAuthorize, TEvents>
 {
+    public readonly id: string;
+    public readonly _authorize: TAuthorize | null = null;
+
+    private _doc: Promise<AbstractCrdtDoc<any>>;
+    private _uninitialize: Promise<() => Promise<void>> | null = null;
+
     private readonly _context: TContext & InferRoomContextType<TPlatform>;
     private readonly _debug: boolean;
     private readonly _docFactory: AbstractCrdtDocFactory<any>;
+    private readonly _listeners: IORoomListeners<TPlatform, TAuthorize, TContext, TEvents>;
     private readonly _platform: TPlatform;
-
-    private _doc: AbstractCrdtDoc<any>;
-    private _listeners: IORoomListeners<TPlatform>;
-    private _sessions = new Map<string, AbstractWebSocket>();
-    private _uninitialize: (() => Promise<void>) | null = null;
-
-    readonly _authorize: TAuthorize | null = null;
-    readonly _router: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
-
-    readonly id: string;
+    private readonly _router: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
+    private readonly _sessions = new Map<string, AbstractWebSocket>();
 
     public get _events() {
         return this._router._events;
@@ -120,28 +122,30 @@ export class IORoom<
         }) as BroadcastProxy<this>;
     }
 
+    private get _initialized(): Promise<boolean> {
+        return Promise.resolve(!!this._uninitialize?.then((result) => !!result));
+    }
+
     constructor(id: string, config: IORoomConfig<TPlatform, TAuthorize, TContext, TEvents>) {
-        const { authorize, context, crdt = noop, debug, onDestroy, platform, router } = config;
+        const { authorize, context, crdt = noop, debug, onDestroy, onMessage, platform, router } = config;
+
+        this.id = id;
 
         this._context = context;
         this._debug = debug;
         this._docFactory = crdt.doc(() => ({}));
-        this._doc = this._docFactory.getEmpty();
         this._router = router;
         this._platform = platform.initialize({ context });
 
-        this.id = id;
-
         this._listeners = {
             onDestroy: (event) => onDestroy?.(event),
+            onMessage: (event) => onMessage?.(event),
         };
 
         if (authorize) this._authorize = authorize;
 
         const webSockets = this._platform.getWebSockets() as readonly InferPlatformWebSocketSource<TPlatform>[];
 
-        if (!webSockets.length) return;
-
         webSockets.forEach((webSocket) => {
             const deserialized = this._platform.getSerializedState(webSocket);
             const sessionId = this._platform.getSessionId(webSocket);
@@ -149,8 +153,15 @@ export class IORoom<
             if (!deserialized) return;
             if (typeof sessionId !== "string") return;
 
-            this._sessions.set(sessionId, this._platform.convertWebSocket(webSocket, { room: this.id }));
+            const pluvWs = this._platform.convertWebSocket(webSocket, { room: this.id });
+
+            this._sessions.set(sessionId, pluvWs);
         });
+
+        const { doc, uninitialize } = this._initialize();
+
+        this._doc = doc;
+        this._uninitialize = uninitialize;
     }
 
     public getSize(): number {
@@ -171,32 +182,32 @@ export class IORoom<
         }, 0);
     }
 
-    public onClose(webSocket: WebSocketType<TPlatform>): (event: AbstractCloseEvent) => void {
+    public onClose(webSocket: WebSocketType<TPlatform>): (event: AbstractCloseEvent) => Promise<void> {
         this._ensureDetached();
 
         const wsSession = this._getAbstractWs(webSocket);
 
-        if (!wsSession) return (): void => undefined;
+        if (!wsSession) return async () => undefined;
 
         return this._onClose(wsSession);
     }
 
-    public onError(webSocket: WebSocketType<TPlatform>): (event: AbstractErrorEvent) => void {
+    public onError(webSocket: WebSocketType<TPlatform>): (event: AbstractErrorEvent) => Promise<void> {
         this._ensureDetached();
 
         const wsSession = this._getAbstractWs(webSocket);
 
-        if (!wsSession) return (): void => undefined;
+        if (!wsSession) return async () => undefined;
 
         return this._onClose(wsSession);
     }
 
-    public onMessage(webSocket: WebSocketType<TPlatform>): (event: AbstractMessageEvent) => void {
+    public onMessage(webSocket: WebSocketType<TPlatform>): (event: AbstractMessageEvent) => Promise<void> {
         this._ensureDetached();
 
         const wsSession = this._getAbstractWs(webSocket);
 
-        if (!wsSession) return (): void => undefined;
+        if (!wsSession) return async () => undefined;
 
         return this._onMessage(wsSession);
     }
@@ -207,7 +218,15 @@ export class IORoom<
     ): Promise<void> {
         const { token } = options;
 
-        if (!this._uninitialize) await this._initialize();
+        const sessionId = this._platform.getSessionId(webSocket);
+        const sessionExists = typeof sessionId === "string" && this._sessions.has(sessionId);
+
+        if (sessionExists) return;
+        if (!(await this._initialized)) {
+            this._initialize();
+
+            await this._initialized;
+        }
 
         const user = await this._getAuthorizedUser(token);
         const ioAuthorize = this._getIOAuthorize();
@@ -218,7 +237,7 @@ export class IORoom<
             !!user &&
             (await this._getSessions().then((sessions) => sessions.some((session) => session.user?.id === user.id)));
 
-        const pluvWs = await this._platform.convertWebSocket(webSocket, { room: this.id });
+        const pluvWs = this._platform.convertWebSocket(webSocket, { room: this.id });
 
         this._logDebug(`${colors.blue(`Registering connection for room ${this.id}:`)} ${pluvWs.sessionId}`);
 
@@ -323,14 +342,6 @@ export class IORoom<
         return sessions.find((pluvWs) => pluvWs.webSocket === webSocket) ?? null;
     }
 
-    private async _getSession(webSocket: WebSocketType<TPlatform>): Promise<WebSocketSession<TAuthorize>> {
-        const pluvWs = this._getAbstractWs(webSocket);
-
-        if (!pluvWs) throw new Error("Session could not be found");
-
-        return await pluvWs.getSession<TAuthorize>();
-    }
-
     private async _getAuthorizedUser(token: Maybe<string>): Promise<InferIOAuthorizeUser<InferIOAuthorize<this>>> {
         const ioAuthorize = this._getIOAuthorize();
 
@@ -366,6 +377,15 @@ export class IORoom<
         }
     }
 
+    private async _getInitialDoc(): Promise<AbstractCrdtDoc<any>> {
+        const doc = this._docFactory.getEmpty();
+        const encodedState = await this._platform.persistance.getStorageState(this.id);
+
+        if (typeof encodedState === "string") doc.applyEncodedState({ update: encodedState });
+
+        return doc;
+    }
+
     private _getIOAuthorize() {
         if (typeof this._authorize === "function") {
             return this._authorize(this._context);
@@ -392,58 +412,97 @@ export class IORoom<
         return procedure.config.input ? procedure.config.input.parse(message.data) : message.data;
     }
 
+    private async _getSession(webSocket: WebSocketType<TPlatform>): Promise<WebSocketSession<TAuthorize>> {
+        const pluvWs = this._getAbstractWs(webSocket);
+
+        if (!pluvWs) throw new Error("Session could not be found");
+
+        return await pluvWs.getSession<TAuthorize>();
+    }
+
     private async _getSessions() {
         const promises = Array.from(this._sessions.values()).map(async (pluvWs) => await pluvWs.getSession());
 
         return await Promise.all(promises);
     }
 
-    private async _initialize(): Promise<void> {
-        this._logDebug(`${colors.blue(`Initializing room ${this.id}:`)}`);
+    private _initialize() {
+        const promise = (async () => {
+            this._logDebug(`${colors.blue(`Initializing room ${this.id}:`)}`);
 
-        if (!!this._uninitialize) {
-            await this._uninitialize();
+            if (!!this._uninitialize) {
+                const uninitialize = (await this._uninitialize).bind(this);
+                await uninitialize();
 
-            this._uninitialize = null;
-        }
+                this._uninitialize = null;
+            }
 
-        const pubSubId = await this._platform.pubSub.subscribe(
-            this.id,
-            async ({ options = {}, ...message }): Promise<void> => {
-                const sessionId = message.connectionId;
-                const user = message.user;
+            const pubSubId = await this._platform.pubSub.subscribe(
+                this.id,
+                async ({ options = {}, ...message }): Promise<void> => {
+                    const sender: SendMessageSender = {
+                        sessionId: message.connectionId,
+                        user: message.user,
+                    };
+
+                    switch (options.type) {
+                        case "self": {
+                            await this._sendSelfMessage(message, sender);
+
+                            return;
+                        }
+                        case "sync": {
+                            await this._sendSyncMessage(message, sender);
+
+                            return;
+                        }
+                        case "broadcast":
+                        default: {
+                            const sessionIds = options.sessionIds;
+
+                            await this._sendBroadcastMessage(message, sender, sessionIds);
+                        }
+                    }
+                },
+            );
 
-                await this._sendMessage(message, { sessionId, user }, options);
-            },
-        );
+            const doc = await this._getInitialDoc();
+            const uninitialize = async () => {
+                this._platform.pubSub.unsubscribe(pubSubId);
 
-        this._uninitialize = async () => {
-            this._platform.pubSub.unsubscribe(pubSubId);
+                const doc = await this._doc;
+                const encodedState = doc.getEncodedState();
 
-            const encodedState = this._doc.getEncodedState();
+                doc.destroy();
+                this._doc = Promise.resolve(this._docFactory.getEmpty());
 
-            this._doc.destroy();
-            this._doc = this._docFactory.getEmpty();
+                this._listeners.onDestroy({
+                    context: this._context,
+                    encodedState,
+                    room: this.id,
+                });
 
-            this._listeners.onDestroy({
-                ...this._context,
-                encodedState,
-                room: this.id,
-            });
+                this._uninitialize = null;
+            };
 
-            this._uninitialize = null;
-        };
+            return { doc, uninitialize };
+        })();
+
+        this._doc = promise.then((result) => result.doc);
+        this._uninitialize = promise.then((result) => result.uninitialize);
+
+        return { doc: this._doc, uninitialize: this._uninitialize };
     }
 
     private _logDebug(...data: any[]): void {
         this._debug && console.log(...data);
     }
 
-    private _onClose(webSocket: AbstractWebSocket): () => void {
-        return (): void => {
-            if (!this._uninitialize) return;
+    private _onClose(webSocket: AbstractWebSocket): () => Promise<void> {
+        return async (): Promise<void> => {
+            if (!(await this._initialized)) return;
 
-            webSocket.state.quit = true;
+            webSocket.state = { ...webSocket.state, quit: true };
 
             this._logDebug(`${colors.blue(`Unregistering connection for room ${this.id}:`)} ${webSocket.sessionId}`);
             this._sessions.delete(webSocket.sessionId);
@@ -464,13 +523,18 @@ export class IORoom<
 
                 if (size) return;
 
-                this._uninitialize?.();
+                if (this._uninitialize) {
+                    const uninitialize = (await this._uninitialize).bind(this);
+                    await uninitialize();
+                }
             });
         };
     }
 
-    private _onMessage(webSocket: AbstractWebSocket): (event: AbstractMessageEvent) => void {
+    private _onMessage(webSocket: AbstractWebSocket): (event: AbstractMessageEvent) => Promise<void> {
         return async (event: AbstractMessageEvent): Promise<void> => {
+            if (!(await this._initialized)) return;
+
             const pluvWs = this._getAbstractWs(webSocket as WebSocketType<TPlatform>);
 
             if (!pluvWs) throw new Error("Could not get session");
@@ -480,16 +544,15 @@ export class IORoom<
                 this._getSessions(),
             ]);
 
+            const doc = await this._doc;
             const baseContext: EventResolverContext<TPlatform, TAuthorize, TContext> = {
                 context: this._context,
-                doc: this._doc,
+                doc,
                 room: this.id,
                 session,
                 sessions,
             };
 
-            if (!this._uninitialize) return;
-
             if (pluvWs.state.quit) {
                 pluvWs.close(1011, "WebSocket broken.");
 
@@ -525,7 +588,7 @@ export class IORoom<
                 TContext & InferRoomContextType<TPlatform>
             > = { ...baseContext, context: { ...this._context } };
 
-            Promise.all([
+            await Promise.all([
                 procedure.config.broadcast?.(inputs, extendedContext),
                 procedure.config.self?.(inputs, extendedContext),
                 procedure.config.sync?.(inputs, baseContext),
@@ -533,25 +596,33 @@ export class IORoom<
                 const sessionId = session.id;
                 const user = session.user;
 
-                if (broadcast) {
-                    Object.entries(broadcast).forEach(([type, data]: any) => {
-                        this._broadcast({
-                            message: { data, type },
-                            senderId: sessionId,
-                        });
-                    });
-                }
+                const handleBroadcast = async () => {
+                    if (!broadcast) return;
+
+                    await Promise.all(
+                        Object.entries(broadcast).map(async ([type, data]: any) => {
+                            await this._broadcast({
+                                message: { data, type },
+                                senderId: sessionId,
+                            });
+                        }),
+                    );
+                };
+
+                const handleSelf = async () => {
+                    if (!self) return;
 
-                if (self) {
                     await Promise.all(
                         Object.entries(self).map(async ([type, data]) => {
                             await this._sendSelfMessage({ data, type }, { sessionId, user });
                         }),
                     );
-                }
+                };
 
-                if (sync) {
-                    this._platform.pubSub.publish(this.id, {
+                const handleSync = async () => {
+                    if (!sync) return;
+
+                    await this._platform.pubSub.publish(this.id, {
                         connectionId: session.id,
                         options: { type: "sync" },
                         room: this.id,
@@ -564,7 +635,9 @@ export class IORoom<
                             await this._sendSelfMessage({ data, type }, { sessionId, user });
                         }),
                     );
-                }
+                };
+
+                await Promise.all([handleBroadcast(), handleSelf(), handleSync()]);
             });
         };
     }
@@ -583,29 +656,22 @@ export class IORoom<
         }
     }
 
-    private async _sendMessage(
-        message: EventMessage<string, any>,
-        sender: SendMessageSender | null,
-        options: SendMessageOptions = {},
-    ): Promise<void> {
-        switch (options.type) {
-            case "self": {
-                await this._sendSelfMessage(message, sender);
+    private async _sendMessage(pluvWs: AbstractWebSocket<any>, message: IOEventMessage<any>): Promise<void> {
+        const { data, type } = message;
 
-                return;
-            }
-            case "sync": {
-                await this._sendSyncMessage(message, sender);
+        if (!(await this._initialized)) return;
 
-                return;
-            }
-            case "broadcast":
-            default: {
-                const sessionIds = options.sessionIds;
+        const doc = await this._doc;
 
-                await this._sendBroadcastMessage(message, sender, sessionIds);
-            }
-        }
+        this._listeners.onMessage({
+            context: this._context,
+            encodedState: doc.getEncodedState(),
+            message: { data, type } as InferEventMessage<InferEventsOutput<TEvents>, keyof InferEventsOutput<TEvents>>,
+            room: this.id,
+            user: message.user,
+        });
+
+        await Promise.resolve(pluvWs.sendMessage(message));
     }
 
     private async _sendBroadcastMessage(
@@ -628,7 +694,7 @@ export class IORoom<
             const session = await pluvWs.getSession();
             const user = session.user ?? null;
 
-            pluvWs.sendMessage({ connectionId, data, room, type, user });
+            this._sendMessage(pluvWs, { connectionId, data, room, type, user });
         });
 
         await Promise.all(promises);
@@ -650,7 +716,7 @@ export class IORoom<
         const session = await pluvWs.getSession();
         const user = session.user ?? null;
 
-        pluvWs.sendMessage({
+        this._sendMessage(pluvWs, {
             connectionId: senderId,
             room: this.id,
             user,
@@ -664,9 +730,10 @@ export class IORoom<
     ): Promise<void> {
         if (!sender) return;
 
+        const doc = await this._doc;
         const context: EventResolverContext<TPlatform, TAuthorize, TContext> = {
             context: this._context,
-            doc: this._doc,
+            doc,
             room: this.id,
             session: null,
             sessions: await this._getSessions(),