@pluv/io 0.22.0 → 0.23.0

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;
+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>
 {
-    private readonly _context: TContext & InferRoomContextType<TPlatform>;
-    private readonly _debug: boolean;
-    private readonly _docFactory: AbstractCrdtDocFactory<any>;
-    private readonly _platform: TPlatform;
+    public readonly id: string;
+    public readonly _authorize: TAuthorize | null = null;
 
     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 _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 readonly _router: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
+    private readonly _sessions = new Map<string, AbstractWebSocket>();
 
     public get _events() {
         return this._router._events;
@@ -121,7 +123,7 @@ export class IORoom<
     }
 
     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._context = context;
         this._debug = debug;
@@ -134,6 +136,7 @@ export class IORoom<
 
         this._listeners = {
             onDestroy: (event) => onDestroy?.(event),
+            onMessage: (event) => onMessage?.(event),
         };
 
         if (authorize) this._authorize = authorize;
@@ -410,10 +413,29 @@ export class IORoom<
         const pubSubId = await this._platform.pubSub.subscribe(
             this.id,
             async ({ options = {}, ...message }): Promise<void> => {
-                const sessionId = message.connectionId;
-                const user = message.user;
-
-                await this._sendMessage(message, { sessionId, user }, options);
+                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);
+                    }
+                }
             },
         );
 
@@ -426,7 +448,7 @@ export class IORoom<
             this._doc = this._docFactory.getEmpty();
 
             this._listeners.onDestroy({
-                ...this._context,
+                context: this._context,
                 encodedState,
                 room: this.id,
             });
@@ -583,29 +605,18 @@ 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);
-
-                return;
-            }
-            case "sync": {
-                await this._sendSyncMessage(message, sender);
+    private async _sendMessage(pluvWs: AbstractWebSocket<any>, message: IOEventMessage<any>): Promise<void> {
+        const { data, type } = message;
 
-                return;
-            }
-            case "broadcast":
-            default: {
-                const sessionIds = options.sessionIds;
+        this._listeners.onMessage({
+            context: this._context,
+            encodedState: this._doc.getEncodedState(),
+            message: { data, type } as InferEventMessage<InferEventsOutput<TEvents>, keyof InferEventsOutput<TEvents>>,
+            room: this.id,
+            user: message.user,
+        });
 
-                await this._sendBroadcastMessage(message, sender, sessionIds);
-            }
-        }
+        await Promise.resolve(pluvWs.sendMessage(message));
     }
 
     private async _sendBroadcastMessage(
@@ -628,7 +639,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 +661,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,

package/src/PluvIO.ts

@@ -1,14 +1,6 @@
 import type { AbstractCrdtDocFactory } from "@pluv/crdt";
 import { noop } from "@pluv/crdt";
-import type {
-    BaseIOAuthorize,
-    IOAuthorize,
-    IOLike,
-    InferIOAuthorize,
-    InferIOAuthorizeUser,
-    JsonObject,
-    Maybe,
-} from "@pluv/types";
+import type { BaseIOAuthorize, IOAuthorize, InferIOAuthorizeUser, JsonObject } from "@pluv/types";
 import type { AbstractPlatform, InferPlatformContextType, WebSocketRegistrationMode } from "./AbstractPlatform";
 import { PluvProcedure } from "./PluvProcedure";
 import type { MergedRouter, PluvRouterEventConfig } from "./PluvRouter";
@@ -16,7 +8,6 @@ import { PluvRouter } from "./PluvRouter";
 import { PluvServer } from "./PluvServer";
 import type { JWTEncodeParams } from "./authorize";
 import { authorize } from "./authorize";
-import { PING_TIMEOUT_MS } from "./constants";
 import type { GetInitialStorageFn, PluvIOListeners } from "./types";
 import { __PLUV_VERSION } from "./version";
 
@@ -24,187 +15,43 @@ export type PluvIOConfig<
     TPlatform extends AbstractPlatform<any>,
     TAuthorize extends IOAuthorize<any, any, InferPlatformContextType<TPlatform>>,
     TContext extends JsonObject,
-> = Partial<PluvIOListeners<TPlatform>> & {
+> = {
     authorize?: TAuthorize;
     context?: TContext;
     crdt?: { doc: (value: any) => AbstractCrdtDocFactory<any> };
     debug?: boolean;
-    getInitialStorage?: GetInitialStorageFn<TPlatform>;
     platform: TPlatform;
 };
 
-export interface ServerConfig<
+export type ServerConfig<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
     TAuthorize extends IOAuthorize<any, any, InferPlatformContextType<TPlatform>> = BaseIOAuthorize,
     TContext extends JsonObject = {},
     TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
-> {
+> = Partial<PluvIOListeners<TPlatform, TAuthorize, TContext, TEvents>> & {
+    getInitialStorage?: GetInitialStorageFn<TPlatform>;
     router?: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
-}
+};
 
 export class PluvIO<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
     TAuthorize extends IOAuthorize<any, any, InferPlatformContextType<TPlatform>> = BaseIOAuthorize,
     TContext extends JsonObject = {},
-> implements IOLike<TAuthorize, {}>
-{
-    private _router: PluvRouter<TPlatform, TAuthorize, TContext, {}> = new PluvRouter({
-        $GET_OTHERS: this.procedure.sync((data, { room, session, sessions }) => {
-            const currentTime = new Date().getTime();
-
-            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;
-                    };
-                }>(
-                    (acc, { id, presence, user }) => ({
-                        ...acc,
-                        [id]: {
-                            connectionId: id,
-                            presence,
-                            room,
-                            user,
-                        },
-                    }),
-                    {},
-                );
-
-            return { $OTHERS_RECEIVED: { others } };
-        }),
-        $INITIALIZE_SESSION: this.procedure
-            .broadcast((data, { session }) => {
-                const presence = (data as any)?.presence;
-
-                if (!session) return {};
-
-                session.presence = presence;
-
-                return {
-                    $USER_JOINED: {
-                        connectionId: session.id,
-                        user: session.user,
-                        presence,
-                    },
-                };
-            })
-            .self(async (data, { context, doc, room }) => {
-                const oldState = await this._platform.persistance.getStorageState(room);
-                const update = (data as any)?.update as Maybe<string>;
-
-                const updates: readonly Maybe<string>[] = [
-                    oldState
-                        ? null
-                        : await this._getInitialStorage?.({
-                              ...context,
-                              room,
-                          }),
-                    update,
-                ];
-
-                if (updates.some((_update) => !!_update)) {
-                    const encodedState = doc.batchApplyEncodedState(updates).getEncodedState();
-
-                    await this._platform.persistance.setStorageState(room, encodedState);
-
-                    this._listeners.onStorageUpdated({ ...context, encodedState, room });
-                }
-
-                const state = (await this._platform.persistance.getStorageState(room)) ?? doc.getEncodedState();
-
-                return { $STORAGE_RECEIVED: { state } };
-            }),
-        $PING: this.procedure.self((data, { session }) => {
-            if (!session) return {};
-
-            const currentTime = new Date().getTime();
-            const prevState = session.webSocket.state;
-
-            session.webSocket.state = {
-                ...prevState,
-                timers: {
-                    ...prevState.timers,
-                    ping: currentTime,
-                },
-            };
-
-            return { $PONG: {} };
-        }),
-        $UPDATE_PRESENCE: this.procedure.broadcast((data, { session }) => {
-            const presence = (data as any)?.presence;
-
-            if (!session) return {};
-
-            const updated = Object.assign(Object.create(null), session.presence, presence);
-
-            session.webSocket.presence = updated;
-
-            return { $PRESENCE_UPDATED: { presence: updated } };
-        }),
-        $UPDATE_STORAGE: 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();
-
-            this._platform.persistance.setStorageState(room, encodedState).then(() => {
-                this._listeners.onStorageUpdated({
-                    ...context,
-                    encodedState,
-                    room,
-                });
-            });
-
-            return { $STORAGE_UPDATED: { state: encodedState } };
-        }),
-    });
-
-    readonly _authorize: TAuthorize | null = null;
-    readonly _context: TContext = {} as TContext;
-    readonly _crdt: { doc: (value: any) => AbstractCrdtDocFactory<any> };
-    readonly _debug: boolean;
-    readonly _getInitialStorage: GetInitialStorageFn<TPlatform> | null = null;
-    readonly _listeners: PluvIOListeners<TPlatform>;
-    readonly _platform: TPlatform;
-    readonly _version: string = __PLUV_VERSION as any;
-
-    public get _events() {
-        return this._router._events;
-    }
+> {
+    public readonly version: string = __PLUV_VERSION as any;
+    public readonly _authorize: TAuthorize | null = null;
 
-    public get _registrationMode(): WebSocketRegistrationMode {
-        return this._platform._registrationMode;
-    }
+    private readonly _context: TContext = {} as TContext;
+    private readonly _crdt: { doc: (value: any) => AbstractCrdtDocFactory<any> };
+    private readonly _debug: boolean;
+    private readonly _platform: TPlatform;
 
     public get procedure(): PluvProcedure<TPlatform, TAuthorize, TContext, {}, {}> {
         return new PluvProcedure();
     }
 
     constructor(options: PluvIOConfig<TPlatform, TAuthorize, TContext>) {
-        const {
-            authorize,
-            context,
-            crdt = noop,
-            debug = false,
-            getInitialStorage,
-            onRoomDeleted,
-            onStorageUpdated,
-            platform,
-        } = options;
+        const { authorize, context, crdt = noop, debug = false, platform } = options;
 
         this._crdt = crdt;
         this._debug = debug;
@@ -212,17 +59,9 @@ export class PluvIO<
 
         if (authorize) this._authorize = authorize;
         if (context) this._context = context;
-        if (getInitialStorage) this._getInitialStorage = getInitialStorage;
-
-        this._listeners = {
-            onRoomDeleted: (event) => onRoomDeleted?.(event),
-            onStorageUpdated: (event) => onStorageUpdated?.(event),
-        };
     }
 
-    public async createToken(
-        params: JWTEncodeParams<InferIOAuthorizeUser<InferIOAuthorize<this>>, TPlatform>,
-    ): Promise<string> {
+    public async createToken(params: JWTEncodeParams<InferIOAuthorizeUser<TAuthorize>, TPlatform>): Promise<string> {
         if (!this._authorize) throw new Error("IO does not specify authorize during initialization.");
 
         const ioAuthorize =
@@ -251,21 +90,13 @@ export class PluvIO<
     public server<TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext>>(
         config: ServerConfig<TPlatform, TAuthorize, TContext, TEvents> = {},
     ): PluvServer<TPlatform, TAuthorize, TContext, TEvents> {
-        const router = (config.router ? this.mergeRouters(this._router, config.router) : this._router) as PluvRouter<
-            TPlatform,
-            TAuthorize,
-            TContext,
-            TEvents
-        >;
-
         return new PluvServer<TPlatform, TAuthorize, TContext, TEvents>({
-            ...this._listeners,
+            ...config,
             authorize: this._authorize ?? undefined,
             context: this._context,
             crdt: this._crdt,
             debug: this._debug,
             platform: this._platform,
-            router,
         });
     }
 }

package/src/PluvRouter.ts

@@ -6,9 +6,7 @@ export type PluvRouterEventConfig<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
     TAuthorize extends IOAuthorize<any, any, InferRoomContextType<TPlatform>> = BaseIOAuthorize,
     TContext extends JsonObject = {},
-> = {
-    [P: string]: Pick<PluvProcedure<TPlatform, TAuthorize, TContext, any, any>, "config">;
-};
+> = { [P: string]: Pick<PluvProcedure<TPlatform, TAuthorize, TContext, any, any>, "config"> };
 
 export type MergedRouter<
     TRouters extends PluvRouter<TPlatform, TAuthorize, TContext, any>[] = [],