@pluv/io 0.22.0 → 0.23.0

package/src/PluvServer.ts

@@ -8,6 +8,7 @@ import type {
     InferIOAuthorize,
     InferIOAuthorizeUser,
     JsonObject,
+    Maybe,
 } from "@pluv/types";
 import colors from "kleur";
 import type {
@@ -17,11 +18,13 @@ import type {
     WebSocketRegistrationMode,
 } from "./AbstractPlatform";
 import { IORoom } from "./IORoom";
+import { PluvProcedure } from "./PluvProcedure";
 import type { PluvRouterEventConfig } from "./PluvRouter";
 import { PluvRouter } from "./PluvRouter";
 import type { JWTEncodeParams } from "./authorize";
 import { authorize } from "./authorize";
-import type { IORoomListenerEvent, PluvIOListeners } from "./types";
+import { PING_TIMEOUT_MS } from "./constants";
+import type { GetInitialStorageFn, PluvIOListeners } from "./types";
 import { __PLUV_VERSION } from "./version";
 
 export type InferIORoom<TServer extends PluvServer<any, any, any, any>> =
@@ -34,11 +37,12 @@ export type PluvServerConfig<
     TAuthorize extends IOAuthorize<any, any, InferPlatformContextType<TPlatform>> = BaseIOAuthorize,
     TContext extends JsonObject = {},
     TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
-> = Partial<PluvIOListeners<TPlatform>> & {
+> = Partial<PluvIOListeners<TPlatform, TAuthorize, TContext, TEvents>> & {
     authorize?: TAuthorize;
     context?: TContext;
     crdt?: { doc: (value: any) => AbstractCrdtDocFactory<any> };
     debug?: boolean;
+    getInitialStorage?: GetInitialStorageFn<TPlatform>;
     platform: TPlatform;
     router?: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
 };
@@ -54,16 +58,142 @@ export class PluvServer<
     TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
 > implements IORouterLike<TEvents>
 {
-    private _rooms = new Map<string, IORoom<TPlatform, TAuthorize, TContext, TEvents>>();
+    public _listeners: PluvIOListeners<TPlatform, TAuthorize, TContext, TEvents>;
+
+    public readonly version: string = __PLUV_VERSION as any;
+    public readonly _authorize: TAuthorize | null = null;
+
+    private readonly _baseRouter: 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 {};
+            }
 
-    readonly _authorize: TAuthorize | null = null;
-    readonly _context: TContext = {} as TContext;
-    readonly _crdt: { doc: (value: any) => AbstractCrdtDocFactory<any> };
-    readonly _debug: boolean;
-    readonly _listeners: PluvIOListeners<TPlatform>;
-    readonly _platform: TPlatform;
-    readonly _router: PluvRouter<TPlatform, TAuthorize, TContext, TEvents>;
-    readonly _version: string = __PLUV_VERSION as any;
+            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 } };
+        }),
+    });
+    private readonly _context: TContext = {} as TContext;
+    private readonly _crdt: { doc: (value: any) => AbstractCrdtDocFactory<any> };
+    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() {
         return this._router._events;
@@ -73,13 +203,19 @@ export class PluvServer<
         return this._platform._registrationMode;
     }
 
+    private get _procedure(): PluvProcedure<TPlatform, TAuthorize, TContext, {}, {}> {
+        return new PluvProcedure();
+    }
+
     constructor(options: PluvServerConfig<TPlatform, TAuthorize, TContext, TEvents>) {
         const {
             authorize,
             context,
             crdt = noop,
             debug = false,
+            getInitialStorage,
             onRoomDeleted,
+            onRoomMessage,
             onStorageUpdated,
             platform,
             router = new PluvRouter<TPlatform, TAuthorize, TContext, TEvents>({} as TEvents),
@@ -88,13 +224,20 @@ export class PluvServer<
         this._crdt = crdt;
         this._debug = debug;
         this._platform = platform;
-        this._router = router ?? null;
+        this._router = (router ? this._baseRouter : PluvRouter.merge(this._baseRouter, router)) as PluvRouter<
+            TPlatform,
+            TAuthorize,
+            TContext,
+            TEvents
+        >;
 
         if (authorize) this._authorize = authorize;
         if (context) this._context = context;
+        if (getInitialStorage) this._getInitialStorage = getInitialStorage;
 
         this._listeners = {
             onRoomDeleted: (event) => onRoomDeleted?.(event),
+            onRoomMessage: (event) => onRoomMessage?.(event),
             onStorageUpdated: (event) => onStorageUpdated?.(event),
         };
     }
@@ -144,18 +287,11 @@ export class PluvServer<
             context: roomContext,
             crdt: this._crdt,
             debug: debug ?? this._debug,
-            onDestroy: async ({ encodedState, room }) => {
+            onDestroy: async (event) => {
                 this._logDebug(`${colors.blue("Deleting empty room:")} ${room}`);
-
-                const roomContext = {
-                    room,
-                    encodedState,
-                    ...platformRoomContext,
-                } as IORoomListenerEvent<TPlatform> & InferRoomContextType<TPlatform>;
-
                 this._rooms.delete(room);
 
-                await Promise.resolve(this._listeners.onRoomDeleted(roomContext));
+                await Promise.resolve(this._listeners.onRoomDeleted(event));
                 await this._platform.persistance.deleteStorageState(room);
 
                 if (this._debug) {
@@ -165,6 +301,9 @@ export class PluvServer<
                     this._logDebug(`${colors.blue("Rooms available:")} ${rooms.join(", ")}`);
                 }
             },
+            onMessage: async (event) => {
+                await Promise.resolve(this._listeners.onRoomMessage(event));
+            },
             platform,
             router: this._router,
         });

package/src/createIO.ts

@@ -2,19 +2,18 @@ import type { AbstractCrdtDocFactory } from "@pluv/crdt";
 import type { BaseUser, IOAuthorize, JsonObject } from "@pluv/types";
 import type { AbstractPlatform, InferPlatformContextType } from "./AbstractPlatform";
 import { PluvIO } from "./PluvIO";
-import type { GetInitialStorageFn, PluvIOListeners } from "./types";
+import type { GetInitialStorageFn } from "./types";
 
 export type CreateIOParams<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
     TContext extends JsonObject = {},
     TAuthorizeUser extends BaseUser = BaseUser,
     TAuthorizeRequired extends boolean = false,
-> = Partial<PluvIOListeners<TPlatform>> & {
+> = {
     authorize?: IOAuthorize<TAuthorizeUser, TAuthorizeRequired, InferPlatformContextType<TPlatform>>;
     context?: TContext;
     crdt?: { doc: (value: any) => AbstractCrdtDocFactory<any> };
     debug?: boolean;
-    getInitialStorage?: GetInitialStorageFn<TPlatform>;
     platform: TPlatform;
 };
 
@@ -30,7 +29,7 @@ export const createIO = <
     IOAuthorize<TAuthorizeUser, TAuthorizeRequired, InferPlatformContextType<TPlatform>>,
     TContext
 > => {
-    const { authorize, context, crdt, debug, getInitialStorage, onRoomDeleted, onStorageUpdated, platform } = params;
+    const { authorize, context, crdt, debug, platform } = params;
 
     return new PluvIO<
         TPlatform,
@@ -41,9 +40,6 @@ export const createIO = <
         context,
         crdt,
         debug,
-        getInitialStorage,
-        onRoomDeleted,
-        onStorageUpdated,
         platform,
     });
 };

package/src/types.ts

@@ -3,8 +3,12 @@ import type {
     BaseIOAuthorize,
     EventRecord,
     IOAuthorize,
+    IORouterLike,
     Id,
+    InferEventMessage,
+    InferEventsOutput,
     InferIOAuthorizeUser,
+    InferIOOutput,
     JsonObject,
     Maybe,
     MaybePromise,
@@ -16,6 +20,7 @@ import type {
     InferRoomContextType,
 } from "./AbstractPlatform";
 import type { AbstractWebSocket } from "./AbstractWebSocket";
+import type { PluvRouterEventConfig } from "./PluvRouter";
 
 declare global {
     var console: {
@@ -101,15 +106,37 @@ export type GetInitialStorageFn<TPlatform extends AbstractPlatform> = (
     event: GetInitialStorageEvent<TPlatform>,
 ) => MaybePromise<Maybe<string>>;
 
-export interface PluvIOListeners<TPlatform extends AbstractPlatform> {
-    onRoomDeleted: (event: IORoomListenerEvent<TPlatform>) => void;
-    onStorageUpdated: (event: IORoomListenerEvent<TPlatform>) => void;
+export interface PluvIOListeners<
+    TPlatform extends AbstractPlatform<any>,
+    TAuthorize extends IOAuthorize<any, any, InferRoomContextType<TPlatform>>,
+    TContext extends JsonObject,
+    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext>,
+> {
+    onRoomDeleted: (event: IORoomListenerEvent<TPlatform, TAuthorize, TContext, TEvents>) => void;
+    onRoomMessage: (event: IORoomMessageEvent<TPlatform, TAuthorize, TContext, TEvents>) => void;
+    onStorageUpdated: (event: IORoomListenerEvent<TPlatform, TAuthorize, TContext, TEvents>) => void;
 }
 
-export type IORoomListenerEvent<TPlatform extends AbstractPlatform> = {
-    room: string;
+export type IORoomListenerEvent<
+    TPlatform extends AbstractPlatform<any>,
+    TAuthorize extends IOAuthorize<any, any, InferRoomContextType<TPlatform>>,
+    TContext extends JsonObject,
+    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext>,
+> = {
+    context: TContext & InferRoomContextType<TPlatform>;
     encodedState: string | null;
-} & InferRoomContextType<TPlatform>;
+    room: string;
+};
+
+export type IORoomMessageEvent<
+    TPlatform extends AbstractPlatform<any>,
+    TAuthorize extends IOAuthorize<any, any, InferRoomContextType<TPlatform>>,
+    TContext extends JsonObject,
+    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext>,
+> = IORoomListenerEvent<TPlatform, TAuthorize, TContext, TEvents> & {
+    message: InferEventMessage<InferEventsOutput<TEvents>, keyof InferEventsOutput<TEvents>>;
+    user?: InferIOAuthorizeUser<TAuthorize>;
+};
 
 export type WebSocketType<TPlatform extends AbstractPlatform> =
     | InferPlatformWebSocketType<TPlatform>

package/src/version.generated.ts

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