@pluv/io 0.3.9 → 0.4.0

package/src/IORoom.ts

@@ -15,16 +15,20 @@ import type {
     JsonObject,
     Maybe,
     MaybePromise,
+    Spread,
 } from "@pluv/types";
 import colors from "kleur";
 import type { AbstractPlatform, InferWebSocketType } from "./AbstractPlatform";
 import { authorize } from "./authorize";
 import type {
+    EventResolver,
     EventResolverContext,
+    EventResolverObject,
     InferEventConfig,
     SendMessageOptions,
     WebSocketSession,
 } from "./types";
+import { AbstractMessageEvent } from "./AbstractWebSocket";
 
 const PING_TIMEOUT_MS = 30_000;
 
@@ -46,12 +50,20 @@ export type IORoomConfig<
     TAuthorize extends IOAuthorize<any, any> = BaseIOAuthorize,
     TContext extends JsonObject = {},
     TInput extends EventRecord<string, any> = {},
-    TOutput extends EventRecord<string, any> = {}
+    TOutputBroadcast extends EventRecord<string, any> = {},
+    TOutputSelf extends EventRecord<string, any> = {},
+    TOutputSync extends EventRecord<string, any> = {}
 > = Partial<IORoomListeners> & {
     authorize?: TAuthorize;
     context: TContext;
     debug: boolean;
-    events: InferEventConfig<TContext, TInput, TOutput>;
+    events: InferEventConfig<
+        TContext,
+        TInput,
+        TOutputBroadcast,
+        TOutputSelf,
+        TOutputSync
+    >;
     initialStorage?: () => MaybePromise<Maybe<string>>;
     platform: TPlatform;
 };
@@ -70,8 +82,11 @@ export class IORoom<
     TAuthorize extends IOAuthorize<any, any> = BaseIOAuthorize,
     TContext extends JsonObject = {},
     TInput extends EventRecord<string, any> = {},
-    TOutput extends EventRecord<string, any> = {}
-> implements IOLike<TAuthorize, TInput, TOutput>
+    TOutputBroadcast extends EventRecord<string, any> = {},
+    TOutputSelf extends EventRecord<string, any> = {},
+    TOutputSync extends EventRecord<string, any> = {}
+> implements
+        IOLike<TAuthorize, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>
 {
     private readonly _context: TContext;
     private readonly _debug: boolean;
@@ -84,13 +99,27 @@ export class IORoom<
     private _uninitialize: (() => Promise<void>) | null = null;
 
     readonly _authorize: TAuthorize | null = null;
-    readonly _events: InferEventConfig<TContext, TInput, TOutput>;
+    readonly _events: InferEventConfig<
+        TContext,
+        TInput,
+        TOutputBroadcast,
+        TOutputSelf,
+        TOutputSync
+    >;
 
     readonly id: string;
 
     constructor(
         id: string,
-        config: IORoomConfig<TPlatform, TAuthorize, TContext, TInput, TOutput>
+        config: IORoomConfig<
+            TPlatform,
+            TAuthorize,
+            TContext,
+            TInput,
+            TOutputBroadcast,
+            TOutputSelf,
+            TOutputSync
+        >
     ) {
         const {
             authorize,
@@ -210,120 +239,14 @@ export class IORoom<
             user ?? {}
         );
 
-        this._emitRegistered(session);
-        this._emitStorageReceived(session);
-        this._emitUserJoined(session);
-
-        const context: EventResolverContext<TContext> = {
-            context: this._context,
-            doc: this._doc,
-            room: this.id,
-            session,
-            sessions: this._sessions,
-        };
-
-        pluvWs.addEventListener("message", (event) => {
-            if (!this._uninitialize) return;
-
-            if (session.quit) {
-                session.webSocket.close(1011, "WebSocket broken.");
-
-                return;
-            }
-
-            const message = this._parseMessage(event);
-
-            if (!message) return;
-
-            const eventConfig = this._getEventConfig(message);
-
-            if (!eventConfig) return;
-
-            this._resolveMessage(message, context).then((output) => {
-                if (!output) return;
-
-                const eventType = eventConfig.options?.type ?? "broadcast";
-
-                switch (eventType) {
-                    case "self": {
-                        Object.entries(output).forEach(([type, data]) => {
-                            this._sendSelfMessage({ data, type }, session);
-                        });
-
-                        return;
-                    }
-                    case "sync": {
-                        this._platform.pubSub.publish(this.id, {
-                            connectionId: session.id,
-                            options: eventConfig.options,
-                            room: this.id,
-                            user: session.user,
-                            ...message,
-                        });
-
-                        Object.entries(output).forEach(([type, data]) => {
-                            this._sendSelfMessage({ data, type }, session);
-                        });
-
-                        return;
-                    }
-                    case "broadcast":
-                    default: {
-                        Object.entries(output).forEach(([type, data]: any) => {
-                            this._broadcast({
-                                message: { data, type },
-                                senderId: session.id,
-                            });
-                        });
-                    }
-                }
-            });
-        });
-
-        const closeHandler = () => {
-            if (!this._uninitialize) return;
-
-            session.quit = true;
-
-            this._logDebug(
-                `${colors.blue(
-                    `(Unregistering connection for room ${this.id}:`
-                )} ${sessionId}`
-            );
-            this._sessions.delete(session.id);
-
-            this._platform.persistance
-                .deleteUser(this.id, session.id)
-                .finally(() => {
-                    this._broadcast({
-                        message: {
-                            type: "$EXIT",
-                            data: { sessionId: session.id },
-                        },
-                        senderId: session.id,
-                    });
-
-                    uninitializeWs();
+        const onClose = this._onClose(session, uninitializeWs).bind(this);
+        const onMessage = this._onMessage(session).bind(this);
 
-                    const size = this.getSize();
-
-                    this._logDebug(
-                        `${colors.blue(
-                            `Unregistered connection for room ${this.id}:`
-                        )} ${sessionId}`
-                    );
-                    this._logDebug(
-                        `${colors.blue(`Room ${this.id} size:`)} ${size}`
-                    );
+        pluvWs.addEventListener("close", onClose);
+        pluvWs.addEventListener("error", onClose);
+        pluvWs.addEventListener("message", onMessage);
 
-                    if (size) return;
-
-                    this._uninitialize?.();
-                });
-        };
-
-        pluvWs.addEventListener("close", closeHandler);
-        pluvWs.addEventListener("error", closeHandler);
+        this._emitRegistered(session);
 
         this._logDebug(
             `${colors.blue(
@@ -384,42 +307,6 @@ export class IORoom<
         );
     }
 
-    private _emitStorageReceived(session: WebSocketSession): void {
-        this._platform.persistance
-            .getStorageState(this.id)
-            .then(async (_state) => {
-                const state =
-                    _state ??
-                    (await this._initialStorage?.()) ??
-                    this._doc.encodeStateAsUpdate();
-
-                this._sendSelfMessage(
-                    {
-                        type: "$STORAGE_RECEIVED",
-                        data: { state },
-                    },
-                    session
-                );
-            });
-    }
-
-    private _emitUserJoined(session: WebSocketSession): void {
-        const user = session.user as any;
-
-        if (!user) return;
-
-        this._broadcast({
-            message: {
-                type: "$USER_JOINED",
-                data: {
-                    connectionId: session.id,
-                    user,
-                },
-            },
-            senderId: session.id,
-        });
-    }
-
     private async _getAuthorizedUser(
         token: string | undefined
     ): Promise<InferIOAuthorizeUser<InferIOAuthorize<this>> | null> {
@@ -461,10 +348,66 @@ export class IORoom<
 
     private _getEventConfig(
         message: EventMessage<string, any>
-    ): InferEventConfig<TContext, TInput, TOutput>[keyof TInput] | null {
+    ):
+        | InferEventConfig<
+              TContext,
+              TInput,
+              TOutputBroadcast,
+              TOutputSelf,
+              TOutputSync
+          >[keyof TInput]
+        | null {
         return this._events[message.type as keyof TInput] ?? null;
     }
 
+    private _getEventInputs(
+        message: EventMessage<string, any>
+    ): TInput[string] {
+        const eventConfig = this._getEventConfig(message);
+
+        if (!eventConfig) return message.data;
+
+        /**
+         * !HACK
+         * @description If the config doesn't specify validation, we
+         * assume no input is to be expected, but pass through all values
+         * regardless. Leave this up to the implementer of the event.
+         * @author leedavidcs
+         * @date September 25, 2022
+         */
+        return eventConfig.input
+            ? (eventConfig.input.parse(message.data) as TInput[string])
+            : message.data;
+    }
+
+    private _getEventResolverObject(
+        message: EventMessage<string, any>
+    ): EventResolverObject<
+        TContext,
+        TInput[string],
+        TOutputBroadcast,
+        TOutputSelf,
+        TOutputSync
+    > {
+        const eventConfig = this._getEventConfig(message);
+
+        if (!eventConfig) return {};
+
+        const resolver:
+            | EventResolver<TContext, TInput[string], TOutputBroadcast>
+            | EventResolverObject<
+                  TContext,
+                  TInput[string],
+                  TOutputBroadcast,
+                  TOutputSelf,
+                  TOutputSync
+              > = eventConfig.resolver;
+
+        return typeof resolver === "function"
+            ? { broadcast: resolver }
+            : { ...resolver };
+    }
+
     private async _initialize(): Promise<void> {
         this._logDebug(`${colors.blue(`Initializing room ${this.id}:`)}`);
 
@@ -504,6 +447,130 @@ export class IORoom<
         this._debug && console.log(...data);
     }
 
+    private _onClose(
+        session: WebSocketSession,
+        callback?: () => void
+    ): () => void {
+        return (): void => {
+            if (!this._uninitialize) return;
+
+            session.quit = true;
+
+            this._logDebug(
+                `${colors.blue(
+                    `(Unregistering connection for room ${this.id}:`
+                )} ${session.id}`
+            );
+            this._sessions.delete(session.id);
+
+            this._platform.persistance
+                .deleteUser(this.id, session.id)
+                .finally(() => {
+                    this._broadcast({
+                        message: {
+                            type: "$EXIT",
+                            data: { sessionId: session.id },
+                        },
+                        senderId: session.id,
+                    });
+
+                    callback?.();
+
+                    const size = this.getSize();
+
+                    this._logDebug(
+                        `${colors.blue(
+                            `Unregistered connection for room ${this.id}:`
+                        )} ${session.id}`
+                    );
+                    this._logDebug(
+                        `${colors.blue(`Room ${this.id} size:`)} ${size}`
+                    );
+
+                    if (size) return;
+
+                    this._uninitialize?.();
+                });
+        };
+    }
+
+    private _onMessage(
+        session: WebSocketSession
+    ): (event: AbstractMessageEvent) => void {
+        return (event: AbstractMessageEvent): void => {
+            const context: EventResolverContext<TContext> = {
+                context: this._context,
+                doc: this._doc,
+                room: this.id,
+                session,
+                sessions: this._sessions,
+            };
+
+            if (!this._uninitialize) return;
+
+            if (session.quit) {
+                session.webSocket.close(1011, "WebSocket broken.");
+
+                return;
+            }
+
+            const message = this._parseMessage(event);
+
+            if (!message) return;
+
+            const resolver = this._getEventResolverObject(message);
+
+            let inputs: TInput[string];
+
+            try {
+                inputs = this._getEventInputs(message);
+            } catch (error) {
+                session?.webSocket.handleError({
+                    error,
+                    message: "Invalid input",
+                    session,
+                });
+
+                return;
+            }
+
+            Promise.all([
+                resolver.broadcast?.(inputs, context),
+                resolver.self?.(inputs, context),
+                resolver.sync?.(inputs, context),
+            ]).then(([broadcast, self, sync]) => {
+                if (broadcast) {
+                    Object.entries(broadcast).forEach(([type, data]: any) => {
+                        this._broadcast({
+                            message: { data, type },
+                            senderId: session.id,
+                        });
+                    });
+                }
+
+                if (self) {
+                    Object.entries(self).forEach(([type, data]) => {
+                        this._sendSelfMessage({ data, type }, session);
+                    });
+                }
+
+                if (sync) {
+                    this._platform.pubSub.publish(this.id, {
+                        connectionId: session.id,
+                        options: { type: "sync" },
+                        room: this.id,
+                        user: session.user,
+                        ...message,
+                    });
+
+                    Object.entries(sync).forEach(([type, data]) => {
+                        this._sendSelfMessage({ data, type }, session);
+                    });
+                }
+            });
+        };
+    }
+
     private _parseMessage(message: {
         data: string | ArrayBuffer;
     }): EventMessage<string, any> | null {
@@ -520,47 +587,6 @@ export class IORoom<
         }
     }
 
-    private async _resolveMessage(
-        message: EventMessage<string, any>,
-        context: EventResolverContext<TContext>
-    ): Promise<TOutput | null> {
-        const { session } = context;
-
-        const eventConfig = this._getEventConfig(message);
-
-        if (!eventConfig) return null;
-
-        let input: TInput[string];
-
-        /**
-         * !HACK
-         * @description If the config doesn't specify validation, we
-         * assume no input is to be expected, but pass through all values
-         * regardless. Leave this up to the implementer of the event.
-         * @author leedavidcs
-         * @date September 25, 2022
-         */
-        try {
-            input = eventConfig.input
-                ? (eventConfig.input.parse(message.data) as TInput[string])
-                : message.data;
-        } catch (error) {
-            session?.webSocket.handleError({
-                error,
-                message: "Invalid input",
-                session,
-            });
-
-            return null;
-        }
-
-        const output = await eventConfig.resolver(input, context);
-
-        if (!output) return null;
-
-        return output;
-    }
-
     private _sendMessage(
         message: EventMessage<string, any>,
         sender: SendMessageSender | null,
@@ -638,13 +664,27 @@ export class IORoom<
 
         if (!senderId) return;
 
-        this._resolveMessage(message, {
+        const context: EventResolverContext<TContext> = {
             context: this._context,
             doc: this._doc,
             room: this.id,
             session: null,
             sessions: this._sessions,
-        }).then((output) => {
+        };
+
+        const resolver = this._getEventResolverObject(message).sync;
+
+        if (!resolver) return;
+
+        let inputs: TInput[string];
+
+        try {
+            inputs = this._getEventInputs(message);
+        } catch {
+            return;
+        }
+
+        Promise.resolve(resolver(inputs, context)).then((output) => {
             if (!output) return;
 
             Object.keys(output).forEach((type: string) => {