@pluv/io 0.3.8 → 0.4.0

package/src/PluvIO.ts

@@ -1,22 +1,24 @@
 import type {
+    BaseIOAuthorize,
     EventRecord,
+    IOAuthorize,
+    IOLike,
     InferIOAuthorize,
     InferIOAuthorizeUser,
     InferIOInput,
-    InferIOOutput,
-    IOAuthorize,
-    IOLike,
+    InferIOOutputBroadcast,
+    InferIOOutputSelf,
+    InferIOOutputSync,
     JsonObject,
-    Spread,
-    BaseIOAuthorize,
-    MaybePromise,
     Maybe,
+    MaybePromise,
+    Spread,
 } from "@pluv/types";
 import colors from "kleur";
 import type { AbstractPlatform } from "./AbstractPlatform";
+import { IORoom } from "./IORoom";
 import type { JWTEncodeParams } from "./authorize";
 import { authorize } from "./authorize";
-import { IORoom } from "./IORoom";
 import type { EventConfig, InferEventConfig } from "./types";
 
 export type InferIOContext<TIO extends PluvIO<any, any, any, any, any>> =
@@ -50,12 +52,20 @@ export type PluvIOConfig<
     TAuthorize extends IOAuthorize<any, any> | null = null,
     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<PluvIOListeners> & {
     authorize?: TAuthorize;
     context?: TContext;
     debug?: boolean;
-    events?: InferEventConfig<TContext, TInput, TOutput>;
+    events?: InferEventConfig<
+        TContext,
+        TInput,
+        TOutputBroadcast,
+        TOutputSelf,
+        TOutputSync
+    >;
     initialStorage?: (room: string) => MaybePromise<Maybe<string>>;
     platform: TPlatform;
 };
@@ -69,8 +79,11 @@ export class PluvIO<
     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 _context: TContext = {} as TContext;
     private _initialStorage:
@@ -79,50 +92,112 @@ export class PluvIO<
     private _listeners: PluvIOListeners;
     private _rooms = new Map<
         string,
-        IORoom<TPlatform, TAuthorize, TContext, TInput, TOutput>
+        IORoom<
+            TPlatform,
+            TAuthorize,
+            TContext,
+            TInput,
+            TOutputBroadcast,
+            TOutputSelf,
+            TOutputSync
+        >
     >();
 
     readonly _authorize: TAuthorize | null = null;
     readonly _debug: boolean;
-    readonly _events: InferEventConfig<TContext, TInput, TOutput> = {
-        $PING: {
-            resolver: (data, { session }) => {
-                if (!session) return {};
+    readonly _events: InferEventConfig<
+        TContext,
+        TInput,
+        TOutputBroadcast,
+        TOutputSelf,
+        TOutputSync
+    > = {
+        $GET_OTHERS: {
+            resolver: {
+                sync: (data, { room, session, sessions }) => {
+                    const others = Array.from(sessions.entries())
+                        .filter(([, wsSession]) => wsSession.id !== session?.id)
+                        .reduce<{
+                            [connectionId: string]: {
+                                connectionId: string;
+                                room: string | null;
+                                user: InferIOAuthorizeUser<TAuthorize>;
+                            };
+                        }>(
+                            (acc, [connectionId, { presence, user }]) => ({
+                                ...acc,
+                                [connectionId]: {
+                                    connectionId,
+                                    presence,
+                                    room,
+                                    user: user as InferIOAuthorizeUser<TAuthorize>,
+                                },
+                            }),
+                            {}
+                        );
+
+                    return { $OTHERS_RECEIVED: { others } };
+                },
+            },
+        },
+        $INITIALIZE_SESSION: {
+            resolver: {
+                broadcast: ({ presence }, { session }) => {
+                    if (!session) return {};
+
+                    session.presence = presence;
+
+                    return {
+                        $USER_JOINED: {
+                            connectionId: session.id,
+                            user: session.user,
+                            presence,
+                        },
+                    };
+                },
+                self: async ({ update }, { doc, room }) => {
+                    const oldState =
+                        await this._platform.persistance.getStorageState(room);
+
+                    const updates: readonly Maybe<string>[] = [
+                        oldState ? null : await this._initialStorage?.(room),
+                        update,
+                    ];
+
+                    if (updates.some((_update) => !!_update)) {
+                        const state = updates
+                            .reduce((_doc, _up) => _doc.applyUpdate(_up), doc)
+                            .encodeStateAsUpdate();
+
+                        await this._platform.persistance.setStorageState(
+                            room,
+                            state
+                        );
 
-                const currentTime = new Date().getTime();
+                        this._listeners.onStorageUpdated(room, state);
+                    }
 
-                session.timers.ping = currentTime;
+                    const state =
+                        (await this._platform.persistance.getStorageState(
+                            room
+                        )) ?? doc.encodeStateAsUpdate();
 
-                return { $PONG: {} };
+                    return { $STORAGE_RECEIVED: { state } };
+                },
             },
-            options: { type: "self" },
         },
-        $GET_OTHERS: {
-            resolver: (data, { room, session, sessions }) => {
-                const others = Array.from(sessions.entries())
-                    .filter(([, wsSession]) => wsSession.id !== session?.id)
-                    .reduce<{
-                        [connectionId: string]: {
-                            connectionId: string;
-                            room: string | null;
-                            user: InferIOAuthorizeUser<TAuthorize>;
-                        };
-                    }>(
-                        (acc, [connectionId, { presence, user }]) => ({
-                            ...acc,
-                            [connectionId]: {
-                                connectionId,
-                                presence,
-                                room,
-                                user: user as InferIOAuthorizeUser<TAuthorize>,
-                            },
-                        }),
-                        {}
-                    );
+        $PING: {
+            resolver: {
+                self: (data, { session }) => {
+                    if (!session) return {};
+
+                    const currentTime = new Date().getTime();
+
+                    session.timers.ping = currentTime;
 
-                return { $OTHERS_RECEIVED: { others } };
+                    return { $PONG: {} };
+                },
             },
-            options: { type: "sync" },
         },
         $UPDATE_PRESENCE: {
             resolver: ({ presence }, { session }) => {
@@ -158,11 +233,25 @@ export class PluvIO<
                 return { $STORAGE_UPDATED: { state } };
             },
         },
-    } as InferEventConfig<TContext, TInput, TOutput>;
+    } as InferEventConfig<
+        TContext,
+        TInput,
+        TOutputBroadcast,
+        TOutputSelf,
+        TOutputSync
+    >;
     readonly _platform: TPlatform;
 
     constructor(
-        options: PluvIOConfig<TPlatform, TAuthorize, TContext, TInput, TOutput>
+        options: PluvIOConfig<
+            TPlatform,
+            TAuthorize,
+            TContext,
+            TInput,
+            TOutputBroadcast,
+            TOutputSelf,
+            TOutputSync
+        >
     ) {
         const {
             authorize,
@@ -211,16 +300,26 @@ export class PluvIO<
     public event<
         TEvent extends string,
         TData extends JsonObject = {},
-        TResult extends EventRecord<string, any> = {}
+        TResultBroadcast extends EventRecord<string, any> = {},
+        TResultSelf extends EventRecord<string, any> = {},
+        TResultSync extends EventRecord<string, any> = {}
     >(
         event: TEvent,
-        config: EventConfig<TContext, TData, TResult>
+        config: EventConfig<
+            TContext,
+            TData,
+            TResultBroadcast,
+            TResultSelf,
+            TResultSync
+        >
     ): PluvIO<
         TPlatform,
         TAuthorize,
         TContext,
         Spread<[TInput, EventRecord<TEvent, TData>]>,
-        Spread<[TOutput, TResult]>
+        Spread<[TOutputBroadcast, TResultBroadcast]>,
+        Spread<[TOutputSelf, TResultSelf]>,
+        Spread<[TOutputSync, TResultSync]>
     > {
         if (event.startsWith("$")) {
             throw new Error('Event name must not start with "$".');
@@ -231,7 +330,11 @@ export class PluvIO<
         } as InferEventConfig<
             TContext,
             EventRecord<TEvent, TData>,
-            TResult extends EventRecord<string, any> ? TResult : {}
+            TResultBroadcast extends EventRecord<string, any>
+                ? TResultBroadcast
+                : {},
+            TResultSelf extends EventRecord<string, any> ? TResultSelf : {},
+            TResultSync extends EventRecord<string, any> ? TResultSync : {}
         >;
 
         /**
@@ -259,7 +362,15 @@ export class PluvIO<
     public getRoom(
         room: string,
         options: GetRoomOptions = {}
-    ): IORoom<TPlatform, TAuthorize, TContext, TInput, TOutput> {
+    ): IORoom<
+        TPlatform,
+        TAuthorize,
+        TContext,
+        TInput,
+        TOutputBroadcast,
+        TOutputSelf,
+        TOutputSync
+    > {
         const { debug } = options;
 
         this._purgeEmptyRooms();
@@ -278,7 +389,9 @@ export class PluvIO<
             TAuthorize,
             TContext,
             TInput,
-            TOutput
+            TOutputBroadcast,
+            TOutputSelf,
+            TOutputSync
         >(room, {
             authorize: this._authorize ?? undefined,
             context: this._context,
@@ -291,6 +404,7 @@ export class PluvIO<
                 );
 
                 this._rooms.delete(room);
+                this._listeners.onRoomDeleted(room, encodedState);
 
                 if (this._debug) {
                     const rooms = Array.from(this._rooms.keys());
@@ -300,12 +414,6 @@ export class PluvIO<
                         `${colors.blue("Rooms available:")} ${rooms.join(", ")}`
                     );
                 }
-
-                this._platform.persistance.getSize(room).then((size) => {
-                    if (size) return;
-
-                    this._listeners.onRoomDeleted(room, encodedState);
-                });
             },
             platform,
         });
@@ -332,7 +440,9 @@ export class PluvIO<
         InferIOAuthorize<TIO1>,
         InferIOContext<TIO1>,
         Spread<[InferIOInput<TIO1>, InferIOInput<TIO2>]>,
-        Spread<[InferIOOutput<TIO1>, InferIOOutput<TIO2>]>
+        Spread<[InferIOOutputBroadcast<TIO1>, InferIOOutputBroadcast<TIO2>]>,
+        Spread<[InferIOOutputSelf<TIO1>, InferIOOutputSelf<TIO2>]>,
+        Spread<[InferIOOutputSync<TIO1>, InferIOOutputSync<TIO2>]>
     > {
         const authorize = (first._authorize ??
             undefined) as InferIOAuthorize<TIO1>;

package/src/types.ts

@@ -25,11 +25,20 @@ declare global {
 export interface EventConfig<
     TContext extends JsonObject = {},
     TData extends JsonObject = {},
-    TResult extends EventRecord<string, any> = {}
+    TResultBroadcast extends EventRecord<string, any> = {},
+    TResultSelf extends EventRecord<string, any> = {},
+    TResultSync extends EventRecord<string, any> = {}
 > {
     input?: InputZodLike<TData>;
-    options?: SendMessageOptions;
-    resolver: EventResolver<TContext, TData, TResult>;
+    resolver:
+        | EventResolver<TContext, TData, TResultBroadcast>
+        | EventResolverObject<
+              TContext,
+              TData,
+              TResultBroadcast,
+              TResultSelf,
+              TResultSync
+          >;
 }
 
 export type EventConfigType = "broadcast" | "self" | "sync";
@@ -37,11 +46,11 @@ export type EventConfigType = "broadcast" | "self" | "sync";
 export type EventResolver<
     TContext extends JsonObject = {},
     TData extends JsonObject = {},
-    TResult extends EventRecord<string, any> = {}
+    TResultBroadcast extends EventRecord<string, any> = {}
 > = (
     data: TData,
     context: EventResolverContext<TContext>
-) => MaybePromise<TResult | void>;
+) => MaybePromise<TResultBroadcast | void>;
 
 export interface EventResolverContext<TContext extends JsonObject = {}> {
     context: TContext;
@@ -63,13 +72,35 @@ export interface EventResolverContext<TContext extends JsonObject = {}> {
     sessions: Map<string, WebSocketSession>;
 }
 
+export type EventResolverObject<
+    TContext extends JsonObject = {},
+    TData extends JsonObject = {},
+    TResultBroadcast extends EventRecord<string, any> = {},
+    TResultSelf extends EventRecord<string, any> = {},
+    TResultSync extends EventRecord<string, any> = {}
+> = {
+    broadcast?: EventResolver<TContext, TData, TResultBroadcast>;
+    self?: EventResolver<TContext, TData, TResultSelf>;
+    sync?: EventResolver<TContext, TData, TResultSync>;
+};
+
 export type InferEventConfig<
     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> = {}
 > = {
     [P in keyof TInput]: P extends string
-        ? Id<EventConfig<TContext, TInput[P], TOutput>>
+        ? Id<
+              EventConfig<
+                  TContext,
+                  TInput[P],
+                  TOutputBroadcast,
+                  TOutputSelf,
+                  TOutputSync
+              >
+          >
         : never;
 };