@pluv/io 0.23.0 → 0.24.0

package/src/IORoom.ts

@@ -40,7 +40,7 @@ interface BroadcastParams<TIO extends IORoom<any, any, any, any>> {
     senderId?: string;
 }
 
-interface IORoomListeners<
+export interface IORoomListeners<
     TPlatform extends AbstractPlatform<any>,
     TAuthorize extends IOAuthorize<any, any, InferRoomContextType<TPlatform>>,
     TContext extends JsonObject,
@@ -90,8 +90,8 @@ export class IORoom<
     public readonly id: string;
     public readonly _authorize: TAuthorize | null = null;
 
-    private _doc: AbstractCrdtDoc<any>;
-    private _uninitialize: (() => Promise<void>) | null = null;
+    private _doc: Promise<AbstractCrdtDoc<any>>;
+    private _uninitialize: Promise<() => Promise<void>> | null = null;
 
     private readonly _context: TContext & InferRoomContextType<TPlatform>;
     private readonly _debug: boolean;
@@ -122,18 +122,21 @@ 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, 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),
@@ -143,8 +146,6 @@ export class IORoom<
 
         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);
@@ -152,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 {
@@ -174,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);
     }
@@ -210,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();
@@ -221,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}`);
 
@@ -326,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();
 
@@ -369,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);
@@ -395,77 +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}:`)}`);
-
-        if (!!this._uninitialize) {
-            await this._uninitialize();
-
-            this._uninitialize = null;
-        }
+    private _initialize() {
+        const promise = (async () => {
+            this._logDebug(`${colors.blue(`Initializing room ${this.id}:`)}`);
 
-        const pubSubId = await this._platform.pubSub.subscribe(
-            this.id,
-            async ({ options = {}, ...message }): Promise<void> => {
-                const sender: SendMessageSender = {
-                    sessionId: message.connectionId,
-                    user: message.user,
-                };
+            if (!!this._uninitialize) {
+                const uninitialize = (await this._uninitialize).bind(this);
+                await uninitialize();
 
-                switch (options.type) {
-                    case "self": {
-                        await this._sendSelfMessage(message, sender);
+                this._uninitialize = null;
+            }
 
-                        return;
+            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);
+                        }
                     }
-                    case "sync": {
-                        await this._sendSyncMessage(message, sender);
+                },
+            );
 
-                        return;
-                    }
-                    case "broadcast":
-                    default: {
-                        const sessionIds = options.sessionIds;
+            const doc = await this._getInitialDoc();
+            const uninitialize = async () => {
+                this._platform.pubSub.unsubscribe(pubSubId);
 
-                        await this._sendBroadcastMessage(message, sender, sessionIds);
-                    }
-                }
-            },
-        );
+                const doc = await this._doc;
+                const encodedState = doc.getEncodedState();
 
-        this._uninitialize = async () => {
-            this._platform.pubSub.unsubscribe(pubSubId);
+                doc.destroy();
+                this._doc = Promise.resolve(this._docFactory.getEmpty());
 
-            const encodedState = this._doc.getEncodedState();
+                this._listeners.onDestroy({
+                    context: this._context,
+                    encodedState,
+                    room: this.id,
+                });
 
-            this._doc.destroy();
-            this._doc = this._docFactory.getEmpty();
+                this._uninitialize = null;
+            };
 
-            this._listeners.onDestroy({
-                context: this._context,
-                encodedState,
-                room: this.id,
-            });
+            return { doc, uninitialize };
+        })();
 
-            this._uninitialize = null;
-        };
+        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);
@@ -486,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");
@@ -502,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.");
 
@@ -547,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),
@@ -555,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,
@@ -586,7 +635,9 @@ export class IORoom<
                             await this._sendSelfMessage({ data, type }, { sessionId, user });
                         }),
                     );
-                }
+                };
+
+                await Promise.all([handleBroadcast(), handleSelf(), handleSync()]);
             });
         };
     }
@@ -608,9 +659,13 @@ export class IORoom<
     private async _sendMessage(pluvWs: AbstractWebSocket<any>, message: IOEventMessage<any>): Promise<void> {
         const { data, type } = message;
 
+        if (!(await this._initialized)) return;
+
+        const doc = await this._doc;
+
         this._listeners.onMessage({
             context: this._context,
-            encodedState: this._doc.getEncodedState(),
+            encodedState: doc.getEncodedState(),
             message: { data, type } as InferEventMessage<InferEventsOutput<TEvents>, keyof InferEventsOutput<TEvents>>,
             room: this.id,
             user: message.user,
@@ -675,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(),

package/src/PluvServer.ts

@@ -17,6 +17,7 @@ import type {
     InferRoomContextType,
     WebSocketRegistrationMode,
 } from "./AbstractPlatform";
+import type { IORoomListeners } from "./IORoom";
 import { IORoom } from "./IORoom";
 import { PluvProcedure } from "./PluvProcedure";
 import type { PluvRouterEventConfig } from "./PluvRouter";
@@ -47,9 +48,23 @@ export type PluvServerConfig<
     router?: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
 };
 
-export type GetRoomOptions<TPlatform extends AbstractPlatform> = keyof InferRoomContextType<TPlatform> extends never
-    ? [{ debug?: boolean }] | []
-    : [Id<{ debug?: boolean } & InferRoomContextType<TPlatform>>];
+type BaseCreateRoomOptions<
+    TPlatform extends AbstractPlatform<any>,
+    TAuthorize extends IOAuthorize<any, any, InferPlatformContextType<TPlatform>>,
+    TContext extends JsonObject,
+    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext>,
+> = Partial<IORoomListeners<TPlatform, TAuthorize, TContext, TEvents>> & {
+    debug?: boolean;
+};
+
+export type CreateRoomOptions<
+    TPlatform extends AbstractPlatform<any>,
+    TAuthorize extends IOAuthorize<any, any, InferPlatformContextType<TPlatform>>,
+    TContext extends JsonObject,
+    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext>,
+> = keyof InferRoomContextType<TPlatform> extends never
+    ? [BaseCreateRoomOptions<TPlatform, TAuthorize, TContext, TEvents>] | []
+    : [Id<BaseCreateRoomOptions<TPlatform, TAuthorize, TContext, TEvents> & InferRoomContextType<TPlatform>>];
 
 export class PluvServer<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
@@ -117,12 +132,7 @@ export class PluvServer<
                 const update = (data as any)?.update as Maybe<string>;
 
                 const updates: readonly Maybe<string>[] = [
-                    oldState
-                        ? null
-                        : await this._getInitialStorage?.({
-                              ...context,
-                              room,
-                          }),
+                    oldState ? null : await this._getInitialStorage?.({ ...context, room }),
                     update,
                 ];
 
@@ -169,9 +179,7 @@ export class PluvServer<
             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 {};
-            }
+            if (origin === "$INITIALIZED" && Object.keys(doc.toJson()).length) return {};
 
             const updated = update === null ? doc : doc.applyEncodedState({ update });
             const encodedState = updated.getEncodedState();
@@ -192,7 +200,6 @@ export class PluvServer<
     private readonly _debug: boolean;
     private readonly _getInitialStorage: GetInitialStorageFn<TPlatform> | null = null;
     private readonly _platform: TPlatform;
-    private readonly _rooms = new Map<string, IORoom<TPlatform, TAuthorize, TContext, TEvents>>();
     private readonly _router: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
 
     public get _events() {
@@ -242,41 +249,16 @@ export class PluvServer<
         };
     }
 
-    public async createToken(
-        params: JWTEncodeParams<InferIOAuthorizeUser<InferIOAuthorize<this>>, TPlatform>,
-    ): Promise<string> {
-        if (!this._authorize) {
-            throw new Error("IO does not specify authorize during initialization.");
-        }
-
-        const ioAuthorize =
-            typeof this._authorize === "function" ? this._authorize(params) : (this._authorize as { secret: string });
-
-        const secret = ioAuthorize.secret;
-
-        return await authorize({
-            platform: this._platform,
-            secret,
-        }).encode(params);
-    }
-
-    public getRoom(
+    public createRoom(
         room: string,
-        ...options: GetRoomOptions<TPlatform>
+        ...options: CreateRoomOptions<TPlatform, TAuthorize, TContext, TEvents>
     ): IORoom<TPlatform, TAuthorize, TContext, TEvents> {
-        const { debug, ...platformRoomContext } = options[0] ?? {};
-
-        this._purgeEmptyRooms();
+        const { debug, onDestroy, onMessage, ...platformRoomContext } = options[0] ?? {};
 
         if (!/^[a-z0-9]+[a-z0-9\-_]+[a-z0-9]+$/i.test(room)) {
             throw new Error("Unsupported room name");
         }
 
-        const platform = this._platform;
-        const oldRoom = this._rooms.get(room);
-
-        if (oldRoom) return oldRoom;
-
         const roomContext = {
             ...this._context,
             ...platformRoomContext,
@@ -289,48 +271,45 @@ export class PluvServer<
             debug: debug ?? this._debug,
             onDestroy: async (event) => {
                 this._logDebug(`${colors.blue("Deleting empty room:")} ${room}`);
-                this._rooms.delete(room);
 
+                await Promise.resolve(onDestroy?.(event));
                 await Promise.resolve(this._listeners.onRoomDeleted(event));
                 await this._platform.persistance.deleteStorageState(room);
 
-                if (this._debug) {
-                    const rooms = Array.from(this._rooms.keys());
-
-                    this._logDebug(`${colors.blue("Deleted room:")} ${room}`);
-                    this._logDebug(`${colors.blue("Rooms available:")} ${rooms.join(", ")}`);
-                }
+                this._logDebug(`${colors.blue("Deleted room:")} ${room}`);
             },
             onMessage: async (event) => {
+                await Promise.resolve(onMessage?.(event));
                 await Promise.resolve(this._listeners.onRoomMessage(event));
             },
-            platform,
+            platform: this._platform,
             router: this._router,
         });
 
-        this._rooms.set(room, newRoom);
+        this._logDebug(`${colors.blue("Created room:")} ${room}`);
 
-        if (this._debug) {
-            const rooms = Array.from(this._rooms.keys());
+        return newRoom;
+    }
 
-            this._logDebug(`${colors.blue("Created room:")} ${room}`);
-            this._logDebug(`${colors.blue("Rooms available:")} ${rooms.join(", ")}`);
+    public async createToken(
+        params: JWTEncodeParams<InferIOAuthorizeUser<InferIOAuthorize<this>>, TPlatform>,
+    ): Promise<string> {
+        if (!this._authorize) {
+            throw new Error("IO does not specify authorize during initialization.");
         }
 
-        return newRoom;
+        const ioAuthorize =
+            typeof this._authorize === "function" ? this._authorize(params) : (this._authorize as { secret: string });
+
+        const secret = ioAuthorize.secret;
+
+        return await authorize({
+            platform: this._platform,
+            secret,
+        }).encode(params);
     }
 
     private _logDebug(...data: any[]): void {
         this._debug && console.log(...data);
     }
-
-    private _purgeEmptyRooms(): void {
-        const rooms = Array.from(this._rooms.entries());
-
-        rooms.forEach(([id, room]) => {
-            if (!!room?.getSize()) return;
-
-            this._rooms.delete(id);
-        });
-    }
 }

package/src/index.ts

@@ -33,5 +33,5 @@ export type { PluvProcedureConfig } from "./PluvProcedure";
 export { PluvRouter } from "./PluvRouter";
 export type { MergedRouter, PluvRouterEventConfig } from "./PluvRouter";
 export { PluvServer } from "./PluvServer";
-export type { GetRoomOptions, InferIORoom, PluvServerConfig } from "./PluvServer";
+export type { CreateRoomOptions, InferIORoom, PluvServerConfig } from "./PluvServer";
 export type { WebSocketSerializedState, WebSocketSession } from "./types";

package/src/types.ts

@@ -3,12 +3,10 @@ import type {
     BaseIOAuthorize,
     EventRecord,
     IOAuthorize,
-    IORouterLike,
     Id,
     InferEventMessage,
     InferEventsOutput,
     InferIOAuthorizeUser,
-    InferIOOutput,
     JsonObject,
     Maybe,
     MaybePromise,

package/src/version.generated.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '0.23.0'
+export const version = '0.24.0'