@pluv/io 0.17.2 → 0.18.0

package/src/IORoom.ts

@@ -4,7 +4,6 @@ import type {
     BaseIOAuthorize,
     BaseIOEventRecord,
     EventMessage,
-    EventRecord,
     IOAuthorize,
     IOLike,
     Id,
@@ -24,62 +23,44 @@ import type {
     InferPlatformWebSocketType,
 } from "./AbstractPlatform";
 import { AbstractMessageEvent } from "./AbstractWebSocket";
+import type { PluvRouter, PluvRouterEventConfig } from "./PluvRouter";
 import { authorize } from "./authorize";
-import type {
-    EventResolver,
-    EventResolverContext,
-    EventResolverObject,
-    InferEventConfig,
-    SendMessageOptions,
-    WebSocketSession,
-} from "./types";
+import type { EventResolverContext, IORoomListenerEvent, SendMessageOptions, WebSocketSession } from "./types";
 
 const PING_TIMEOUT_MS = 30_000;
 
-type BroadcastMessage<TIO extends IORoom<any, any, any, any, any>> =
+type BroadcastMessage<TIO extends IORoom<any, any, any, any>> =
     | InferEventMessage<InferIOInput<TIO>>
     | InferEventMessage<BaseIOEventRecord<InferIOAuthorize<TIO>>>;
 
-interface BroadcastParams<TIO extends IORoom<any, any, any, any, any>> {
+interface BroadcastParams<TIO extends IORoom<any, any, any, any>> {
     message: BroadcastMessage<TIO>;
     senderId?: string;
 }
 
-export type IORoomListenerEvent<TPlatform extends AbstractPlatform> = {
-    room: string;
-    encodedState: string;
-} & InferPlatformRoomContextType<TPlatform>;
-
 interface IORoomListeners<TPlatform extends AbstractPlatform> {
     onDestroy: (event: IORoomListenerEvent<TPlatform>) => void;
 }
 
+export type BroadcastProxy<TIO extends IORoom<any, any, any, any>> = (<TEvent extends keyof InferIOInput<TIO>>(
+    event: TEvent,
+    data: Id<InferIOInput<TIO>[TEvent]>,
+) => Promise<void>) & {
+    [event in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>>[event]) => Promise<void>;
+};
+
 export type IORoomConfig<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
-    TAuthorize extends IOAuthorize<
-        any,
-        any,
-        InferPlatformRoomContextType<TPlatform>
-    > = BaseIOAuthorize,
+    TAuthorize extends IOAuthorize<any, any, InferPlatformRoomContextType<TPlatform>> = BaseIOAuthorize,
     TContext extends JsonObject = {},
-    TInput extends EventRecord<string, any> = {},
-    TOutputBroadcast extends EventRecord<string, any> = {},
-    TOutputSelf extends EventRecord<string, any> = {},
-    TOutputSync extends EventRecord<string, any> = {},
+    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
 > = Partial<IORoomListeners<TPlatform>> & {
     authorize?: TAuthorize;
     context: TContext & InferPlatformRoomContextType<TPlatform>;
     crdt?: { doc: (value: any) => AbstractCrdtDocFactory<any> };
     debug: boolean;
-    events: InferEventConfig<
-        TPlatform,
-        TContext,
-        TInput,
-        TOutputBroadcast,
-        TOutputSelf,
-        TOutputSync
-    >;
     platform: TPlatform;
+    router: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
 };
 
 interface SendMessageSender {
@@ -94,69 +75,55 @@ export type WebsocketRegisterOptions<TPlatform extends AbstractPlatform> = {
 
 export class IORoom<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
-    TAuthorize extends IOAuthorize<
-        any,
-        any,
-        InferPlatformRoomContextType<TPlatform>
-    > = BaseIOAuthorize,
+    TAuthorize extends IOAuthorize<any, any, InferPlatformRoomContextType<TPlatform>> = BaseIOAuthorize,
     TContext extends Record<string, any> = {},
-    TInput extends EventRecord<string, any> = {},
-    TOutputBroadcast extends EventRecord<string, any> = {},
-    TOutputSelf extends EventRecord<string, any> = {},
-    TOutputSync extends EventRecord<string, any> = {},
-> implements
-        IOLike<TAuthorize, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>
+    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
+> implements IOLike<TAuthorize, TEvents>
 {
-    private readonly _context: TContext &
-        InferPlatformRoomContextType<TPlatform>;
+    private readonly _context: TContext & InferPlatformRoomContextType<TPlatform>;
     private readonly _debug: boolean;
     private readonly _docFactory: AbstractCrdtDocFactory<any>;
     private readonly _platform: TPlatform;
 
     private _doc: AbstractCrdtDoc<any>;
     private _listeners: IORoomListeners<TPlatform>;
-    private _sessions = new Map<string, WebSocketSession>();
+    private _sessions = new Map<string, WebSocketSession<TAuthorize>>();
     private _uninitialize: (() => Promise<void>) | null = null;
 
     readonly _authorize: TAuthorize | null = null;
-    readonly _events: InferEventConfig<
-        TPlatform,
-        TContext,
-        TInput,
-        TOutputBroadcast,
-        TOutputSelf,
-        TOutputSync
-    >;
+    readonly _router: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
 
     readonly id: string;
 
-    constructor(
-        id: string,
-        config: IORoomConfig<
-            TPlatform,
-            TAuthorize,
-            TContext,
-            TInput,
-            TOutputBroadcast,
-            TOutputSelf,
-            TOutputSync
-        >,
-    ) {
-        const {
-            authorize,
-            context,
-            crdt = noop,
-            debug,
-            events,
-            onDestroy,
-            platform,
-        } = config;
+    public get _events() {
+        return this._router._events;
+    }
+
+    public get broadcast(): BroadcastProxy<this> {
+        const _broadcast = <TEvent extends keyof InferIOInput<this>>(
+            event: TEvent,
+            data: Id<InferIOInput<this>[TEvent]>,
+        ): Promise<void> => {
+            const message = { type: event, data } as BroadcastMessage<this>;
+
+            return Promise.resolve(this._broadcast({ message }));
+        };
+
+        return new Proxy(_broadcast, {
+            get(fn, prop) {
+                return (data: any) => fn(prop as any, data);
+            },
+        }) as BroadcastProxy<this>;
+    }
+
+    constructor(id: string, config: IORoomConfig<TPlatform, TAuthorize, TContext, TEvents>) {
+        const { authorize, context, crdt = noop, debug, onDestroy, platform, router } = config;
 
         this._context = context;
         this._debug = debug;
         this._docFactory = crdt.doc(() => ({}));
         this._doc = this._docFactory.getEmpty();
-        this._events = events;
+        this._router = router;
         this._platform = platform;
 
         this.id = id;
@@ -168,15 +135,6 @@ export class IORoom<
         if (authorize) this._authorize = authorize;
     }
 
-    public broadcast<TEvent extends keyof InferIOInput<this>>(
-        event: TEvent,
-        data: Id<InferIOInput<this>[TEvent]>,
-    ): Promise<void> {
-        const message = { type: event, data } as BroadcastMessage<this>;
-
-        return Promise.resolve(this._broadcast({ message }));
-    }
-
     public getSize(): number {
         const currentTime = new Date().getTime();
 
@@ -189,9 +147,7 @@ export class IORoom<
         return Array.from(this._sessions.values()).reduce((count, session) => {
             if (session.quit) return count;
 
-            return currentTime - session.timers.ping > PING_TIMEOUT_MS
-                ? count
-                : count + 1;
+            return currentTime - session.timers.ping > PING_TIMEOUT_MS ? count : count + 1;
         }, 0);
     }
 
@@ -200,9 +156,8 @@ export class IORoom<
         options: WebsocketRegisterOptions<TPlatform>,
     ): Promise<void> {
         const { token, ..._platformEventContext } = options;
-        const platformEventContext =
-            _platformEventContext as InferPlatformRoomContextType<TPlatform> &
-                InferPlatformEventContextType<TPlatform>;
+        const platformEventContext = _platformEventContext as InferPlatformRoomContextType<TPlatform> &
+            InferPlatformEventContextType<TPlatform>;
 
         if (!this._uninitialize) await this._initialize();
 
@@ -215,11 +170,7 @@ export class IORoom<
             userId: user?.id ?? null,
         });
 
-        this._logDebug(
-            `${colors.blue(
-                `Registering connection for room ${this.id}:`,
-            )} ${sessionId}`,
-        );
+        this._logDebug(`${colors.blue(`Registering connection for room ${this.id}:`)} ${sessionId}`);
 
         const uninitializeWs = await pluvWs.initialize();
         const ioAuthorize = this._getIOAuthorize(options);
@@ -227,17 +178,10 @@ export class IORoom<
         const isUnauthorized = !!ioAuthorize?.required && !user;
         // There is an attempt for multiple of the same identities. Probably malicious.
         const isTokenInUse =
-            !!user &&
-            Array.from(this._sessions.values()).some(
-                (session) => session.user?.id === user.id,
-            );
+            !!user && Array.from(this._sessions.values()).some((session) => session.user?.id === user.id);
 
         if (isUnauthorized || isTokenInUse) {
-            this._logDebug(
-                `${colors.blue(
-                    "Authorization failed for connection:",
-                )} ${sessionId}`,
-            );
+            this._logDebug(`${colors.blue("Authorization failed for connection:")} ${sessionId}`);
 
             pluvWs.handleError({ error: new Error("Not authorized") });
             pluvWs.close(3000, "WebSocket unauthorized.");
@@ -246,7 +190,7 @@ export class IORoom<
         }
 
         const currentTime = new Date().getTime();
-        const session: WebSocketSession = {
+        const session: WebSocketSession<TAuthorize> = {
             id: sessionId,
             presence: null,
             quit: false,
@@ -260,16 +204,10 @@ export class IORoom<
 
         this._sessions.set(session.id, session);
 
-        await this._platform.persistance.addUser(
-            this.id,
-            sessionId,
-            user ?? {},
-        );
+        await this._platform.persistance.addUser(this.id, sessionId, user ?? {});
 
         const onClose = this._onClose(session, uninitializeWs).bind(this);
-        const onMessage = this._onMessage(session, platformEventContext).bind(
-            this,
-        );
+        const onMessage = this._onMessage(session, platformEventContext).bind(this);
 
         pluvWs.addEventListener("close", onClose);
         pluvWs.addEventListener("error", onClose);
@@ -277,11 +215,7 @@ export class IORoom<
 
         this._emitRegistered(session);
 
-        this._logDebug(
-            `${colors.blue(
-                `Registered connection for room ${this.id}:`,
-            )} ${sessionId}`,
-        );
+        this._logDebug(`${colors.blue(`Registered connection for room ${this.id}:`)} ${sessionId}`);
 
         const size = this.getSize();
 
@@ -295,9 +229,7 @@ export class IORoom<
         const sender = senderId ? this._sessions.get(senderId) : null;
 
         const quitters = Array.from(this._sessions.values()).filter(
-            (session) =>
-                session.quit ||
-                currentTime - session.timers.ping > PING_TIMEOUT_MS,
+            (session) => session.quit || currentTime - session.timers.ping > PING_TIMEOUT_MS,
         );
 
         quitters.forEach((session) => {
@@ -314,7 +246,7 @@ export class IORoom<
         });
     }
 
-    private _emitQuitters(quitters: readonly WebSocketSession[]): void {
+    private _emitQuitters(quitters: readonly WebSocketSession<TAuthorize>[]): void {
         quitters.forEach((quitter) => {
             this._broadcast({
                 message: {
@@ -326,7 +258,7 @@ export class IORoom<
         });
     }
 
-    private _emitRegistered(session: WebSocketSession): void {
+    private _emitRegistered(session: WebSocketSession<TAuthorize>): void {
         this._sendSelfMessage(
             {
                 type: "$REGISTERED",
@@ -351,11 +283,11 @@ export class IORoom<
     private async _getAuthorizedUser(
         token: Maybe<string>,
         context: InferPlatformRoomContextType<TPlatform>,
-    ): Promise<InferIOAuthorizeUser<InferIOAuthorize<this>> | null> {
+    ): Promise<InferIOAuthorizeUser<InferIOAuthorize<this>>> {
         const ioAuthorize = this._getIOAuthorize(context);
 
-        if (!ioAuthorize) return null;
-        if (!token) return null;
+        if (!ioAuthorize) return null as InferIOAuthorizeUser<InferIOAuthorize<this>>;
+        if (!token) return null as InferIOAuthorizeUser<InferIOAuthorize<this>>;
 
         const payload = await authorize({
             platform: this._platform,
@@ -366,99 +298,38 @@ export class IORoom<
             this._logDebug(colors.blue("Could not decode token:"));
             this._logDebug(token);
 
-            return null;
+            return null as InferIOAuthorizeUser<InferIOAuthorize<this>>;
         }
 
         if (payload.room !== this.id) {
-            this._logDebug(
-                colors.blue(`Token is not authorized for room ${this.id}:`),
-            );
+            this._logDebug(colors.blue(`Token is not authorized for room ${this.id}:`));
             this._logDebug(colors.blue("Received:"), payload.room);
             this._logDebug(token);
 
-            return null;
+            return null as InferIOAuthorizeUser<InferIOAuthorize<this>>;
         }
 
         try {
             return ioAuthorize.user.parse(payload.user) ?? null;
         } catch {
-            this._logDebug(
-                `${colors.blue("Token fails validation:")} ${token}`,
-            );
+            this._logDebug(`${colors.blue("Token fails validation:")} ${token}`);
 
-            return null;
+            return null as InferIOAuthorizeUser<InferIOAuthorize<this>>;
         }
     }
 
-    private _getEventConfig(
+    private _getProcedure(
         message: EventMessage<string, any>,
-    ):
-        | InferEventConfig<
-              TPlatform,
-              TContext,
-              TInput,
-              TOutputBroadcast,
-              TOutputSelf,
-              TOutputSync
-          >[keyof TInput]
-        | null {
-        return this._events[message.type as keyof TInput] ?? null;
+    ): (typeof this._router)["_events"][keyof (typeof this._router)["_events"]] | null {
+        return this._router._events[message.type as keyof (typeof this._router)["_events"]] ?? null;
     }
 
-    private _getEventInputs(
-        message: EventMessage<string, any>,
-    ): TInput[string] {
-        const eventConfig = this._getEventConfig(message);
-
-        if (!eventConfig) return message.data;
+    private _getProcedureInputs(message: EventMessage<string, any>): InferIOInput<this>[keyof TEvents] {
+        const procedure = this._getProcedure(message);
 
-        /**
-         * !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;
-    }
+        if (!procedure) return message.data;
 
-    private _getEventResolverObject(
-        message: EventMessage<string, any>,
-    ): EventResolverObject<
-        TPlatform,
-        TContext,
-        TInput[string],
-        TOutputBroadcast,
-        TOutputSelf,
-        TOutputSync
-    > {
-        const eventConfig = this._getEventConfig(message);
-
-        if (!eventConfig) return {};
-
-        const resolver:
-            | EventResolver<
-                  TContext &
-                      InferPlatformRoomContextType<TPlatform> &
-                      InferPlatformEventContextType<TPlatform>,
-                  TInput[string],
-                  TOutputBroadcast
-              >
-            | EventResolverObject<
-                  TPlatform,
-                  TContext,
-                  TInput[string],
-                  TOutputBroadcast,
-                  TOutputSelf,
-                  TOutputSync
-              > = eventConfig.resolver;
-
-        return typeof resolver === "function"
-            ? { broadcast: resolver }
-            : { ...resolver };
+        return procedure.config.input ? procedure.config.input.parse(message.data) : message.data;
     }
 
     private async _initialize(): Promise<void> {
@@ -470,17 +341,14 @@ export class IORoom<
             this._uninitialize = null;
         }
 
-        const pubSubId = await this._platform.pubSub.subscribe(
-            this.id,
-            ({ options = {}, ...message }) => {
-                const session = {
-                    id: message.connectionId,
-                    user: message.user,
-                };
+        const pubSubId = await this._platform.pubSub.subscribe(this.id, ({ options = {}, ...message }) => {
+            const session = {
+                id: message.connectionId,
+                user: message.user,
+            };
 
-                this._sendMessage(message, session, options);
-            },
-        );
+            this._sendMessage(message, session, options);
+        });
 
         this._uninitialize = async () => {
             this._platform.pubSub.unsubscribe(pubSubId);
@@ -504,59 +372,44 @@ export class IORoom<
         this._debug && console.log(...data);
     }
 
-    private _onClose(
-        session: WebSocketSession,
-        callback?: () => void,
-    ): () => void {
+    private _onClose(session: WebSocketSession<TAuthorize>, 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._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,
-                    });
+            this._platform.persistance.deleteUser(this.id, session.id).finally(() => {
+                this._broadcast({
+                    message: {
+                        type: "$EXIT",
+                        data: { sessionId: session.id },
+                    },
+                    senderId: session.id,
+                });
 
-                    callback?.();
+                callback?.();
 
-                    const size = this.getSize();
+                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}`,
-                    );
+                this._logDebug(`${colors.blue(`Unregistered connection for room ${this.id}:`)} ${session.id}`);
+                this._logDebug(`${colors.blue(`Room ${this.id} size:`)} ${size}`);
 
-                    if (size) return;
+                if (size) return;
 
-                    this._uninitialize?.();
-                });
+                this._uninitialize?.();
+            });
         };
     }
 
     private _onMessage(
-        session: WebSocketSession,
+        session: WebSocketSession<TAuthorize>,
         platformEventContext: InferPlatformEventContextType<TPlatform>,
     ): (event: AbstractMessageEvent) => void {
         return (event: AbstractMessageEvent): void => {
-            const baseContext: EventResolverContext<TContext> = {
+            const baseContext: EventResolverContext<TPlatform, TAuthorize, TContext> = {
                 context: this._context,
                 doc: this._doc,
                 room: this.id,
@@ -576,12 +429,14 @@ export class IORoom<
 
             if (!message) return;
 
-            const resolver = this._getEventResolverObject(message);
+            const procedure = this._getProcedure(message);
+
+            if (!procedure) return;
 
-            let inputs: TInput[string];
+            let inputs: InferIOInput<this>[keyof TEvents];
 
             try {
-                inputs = this._getEventInputs(message);
+                inputs = this._getProcedureInputs(message);
             } catch (error) {
                 session?.webSocket.handleError({
                     error,
@@ -593,18 +448,18 @@ export class IORoom<
             }
 
             const extendedContext: EventResolverContext<
-                TContext &
-                    InferPlatformRoomContextType<TPlatform> &
-                    InferPlatformEventContextType<TPlatform>
+                TPlatform,
+                TAuthorize,
+                TContext & InferPlatformRoomContextType<TPlatform> & InferPlatformEventContextType<TPlatform>
             > = {
                 ...baseContext,
                 context: { ...this._context, ...platformEventContext },
             };
 
             Promise.all([
-                resolver.broadcast?.(inputs, extendedContext),
-                resolver.self?.(inputs, extendedContext),
-                resolver.sync?.(inputs, baseContext),
+                procedure.config.broadcast?.(inputs, extendedContext),
+                procedure.config.self?.(inputs, extendedContext),
+                procedure.config.sync?.(inputs, baseContext),
             ]).then(([broadcast, self, sync]) => {
                 if (broadcast) {
                     Object.entries(broadcast).forEach(([type, data]: any) => {
@@ -638,9 +493,7 @@ export class IORoom<
         };
     }
 
-    private _parseMessage(message: {
-        data: string | ArrayBuffer;
-    }): EventMessage<string, any> | null {
+    private _parseMessage(message: { data: string | ArrayBuffer }): EventMessage<string, any> | null {
         try {
             const parsed = this._platform.parseData(message.data);
 
@@ -691,7 +544,7 @@ export class IORoom<
                 const _session = this._sessions.get(id);
 
                 return _session ? dict.set(id, _session) : dict;
-            }, new Map<string, WebSocketSession>()) ?? this._sessions;
+            }, new Map<string, WebSocketSession<TAuthorize>>()) ?? this._sessions;
 
         Array.from(sessions.values()).forEach((_session) => {
             _session.webSocket.sendMessage({
@@ -703,10 +556,7 @@ export class IORoom<
         });
     }
 
-    private _sendSelfMessage(
-        message: EventMessage<string, any>,
-        sender: SendMessageSender | null,
-    ): void {
+    private _sendSelfMessage(message: EventMessage<string, any>, sender: SendMessageSender | null): void {
         const senderId = sender?.id;
 
         if (!senderId) return;
@@ -723,15 +573,12 @@ export class IORoom<
         });
     }
 
-    private _sendSyncMessage(
-        message: EventMessage<string, any>,
-        sender: SendMessageSender | null,
-    ): void {
+    private _sendSyncMessage(message: EventMessage<string, any>, sender: SendMessageSender | null): void {
         const senderId = sender?.id;
 
         if (!senderId) return;
 
-        const context: EventResolverContext<TContext> = {
+        const context: EventResolverContext<TPlatform, TAuthorize, TContext> = {
             context: this._context,
             doc: this._doc,
             room: this.id,
@@ -739,14 +586,14 @@ export class IORoom<
             sessions: this._sessions,
         };
 
-        const resolver = this._getEventResolverObject(message).sync;
+        const resolver = this._getProcedure(message)?.config.sync;
 
         if (!resolver) return;
 
-        let inputs: TInput[string];
+        let inputs: InferIOInput<this>[keyof TEvents];
 
         try {
-            inputs = this._getEventInputs(message);
+            inputs = this._getProcedureInputs(message);
         } catch {
             return;
         }

package/src/Persistance.ts

@@ -5,13 +5,8 @@ export class Persistance extends AbstractPersistance {
     private _storages = new Map<string, string>();
     private _users = new Map<string, Map<string, JsonObject | null>>();
 
-    public addUser(
-        room: string,
-        connectionId: string,
-        user: JsonObject | null,
-    ): Promise<void> {
-        const users =
-            this._users.get(room) ?? new Map<string, JsonObject | null>();
+    public addUser(room: string, connectionId: string, user: JsonObject | null): Promise<void> {
+        const users = this._users.get(room) ?? new Map<string, JsonObject | null>();
 
         this._users.set(room, users);
         users.set(connectionId, user);
@@ -56,10 +51,7 @@ export class Persistance extends AbstractPersistance {
         return Promise.resolve(storage);
     }
 
-    public getUser(
-        room: string,
-        connectionId: string,
-    ): Promise<JsonObject | null> {
+    public getUser(room: string, connectionId: string): Promise<JsonObject | null> {
         const user = this._users.get(room)?.get(connectionId);
 
         return Promise.resolve(user ?? null);