@pluv/io 0.4.2 → 0.6.0

package/src/PluvIO.ts

@@ -15,23 +15,24 @@ import type {
     Spread,
 } from "@pluv/types";
 import colors from "kleur";
-import type { AbstractPlatform } from "./AbstractPlatform";
-import { IORoom } from "./IORoom";
+import type {
+    AbstractPlatform,
+    InferPlatformRoomContextType,
+} from "./AbstractPlatform";
+import { IORoom, IORoomListenerEvent } from "./IORoom";
 import type { JWTEncodeParams } from "./authorize";
 import { authorize } from "./authorize";
 import type { EventConfig, InferEventConfig } from "./types";
 
-export type InferIOContext<
-    TIO extends PluvIO<any, any, any, any, any, any, any>
-> = TIO extends PluvIO<any, any, infer IContext, any, any, any, any>
-    ? IContext
-    : never;
+type InferIOContext<TIO extends PluvIO<any, any, any, any, any, any, any>> =
+    TIO extends PluvIO<any, any, infer IContext, any, any, any, any>
+        ? IContext
+        : never;
 
-export type InferIOPlatform<
-    TIO extends PluvIO<any, any, any, any, any, any, any>
-> = TIO extends PluvIO<infer IPlatform, any, any, any, any, any, any>
-    ? IPlatform
-    : never;
+type InferIOPlatform<TIO extends PluvIO<any, any, any, any, any, any, any>> =
+    TIO extends PluvIO<infer IPlatform, any, any, any, any, any, any>
+        ? IPlatform
+        : never;
 
 export type InferIORoom<TIO extends PluvIO<any, any, any, any, any, any, any>> =
     TIO extends PluvIO<
@@ -54,13 +55,17 @@ export type InferIORoom<TIO extends PluvIO<any, any, any, any, any, any, any>> =
           >
         : never;
 
-export interface PluvIORegisterOptions {
-    token?: string;
-}
+type GetInitialStorageEvent<TPlatform extends AbstractPlatform> = {
+    room: string;
+} & InferPlatformRoomContextType<TPlatform>;
+
+export type GetInitialStorageFn<TPlatform extends AbstractPlatform> = (
+    event: GetInitialStorageEvent<TPlatform>
+) => MaybePromise<Maybe<string>>;
 
-export interface PluvIOListeners {
-    onRoomDeleted: (room: string, encodedState: string) => void;
-    onStorageUpdated: (room: string, encodedState: string) => void;
+export interface PluvIOListeners<TPlatform extends AbstractPlatform> {
+    onRoomDeleted: (event: IORoomListenerEvent<TPlatform>) => void;
+    onStorageUpdated: (event: IORoomListenerEvent<TPlatform>) => void;
 }
 
 export type PluvIOConfig<
@@ -71,24 +76,25 @@ export type PluvIOConfig<
     TOutputBroadcast extends EventRecord<string, any> = {},
     TOutputSelf extends EventRecord<string, any> = {},
     TOutputSync extends EventRecord<string, any> = {}
-> = Partial<PluvIOListeners> & {
+> = Partial<PluvIOListeners<TPlatform>> & {
     authorize?: TAuthorize;
     context?: TContext;
     debug?: boolean;
     events?: InferEventConfig<
+        TPlatform,
         TContext,
         TInput,
         TOutputBroadcast,
         TOutputSelf,
         TOutputSync
     >;
-    initialStorage?: (room: string) => MaybePromise<Maybe<string>>;
+    getInitialStorage?: GetInitialStorageFn<TPlatform>;
     platform: TPlatform;
 };
 
-export interface GetRoomOptions {
+export type GetRoomOptions<TPlatform extends AbstractPlatform> = {
     debug?: boolean;
-}
+} & InferPlatformRoomContextType<TPlatform>;
 
 export class PluvIO<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
@@ -102,9 +108,7 @@ export class PluvIO<
         IOLike<TAuthorize, TInput, TOutputBroadcast, TOutputSelf, TOutputSync>
 {
     private _context: TContext = {} as TContext;
-    private _initialStorage:
-        | ((room: string) => MaybePromise<Maybe<string>>)
-        | null = null;
+    private _getInitialStorage: GetInitialStorageFn<TPlatform> | null = null;
     private _rooms = new Map<
         string,
         IORoom<
@@ -121,6 +125,7 @@ export class PluvIO<
     readonly _authorize: TAuthorize | null = null;
     readonly _debug: boolean;
     readonly _events: InferEventConfig<
+        TPlatform,
         TContext,
         TInput,
         TOutputBroadcast,
@@ -170,26 +175,35 @@ export class PluvIO<
                         },
                     };
                 },
-                self: async ({ update }, { doc, room }) => {
+                self: async ({ update }, { context, doc, room }) => {
                     const oldState =
                         await this._platform.persistance.getStorageState(room);
 
                     const updates: readonly Maybe<string>[] = [
-                        oldState ? null : await this._initialStorage?.(room),
+                        oldState
+                            ? null
+                            : await this._getInitialStorage?.({
+                                  ...context,
+                                  room,
+                              }),
                         update,
                     ];
 
                     if (updates.some((_update) => !!_update)) {
-                        const state = updates
+                        const encodedState = updates
                             .reduce((_doc, _up) => _doc.applyUpdate(_up), doc)
                             .encodeStateAsUpdate();
 
                         await this._platform.persistance.setStorageState(
                             room,
-                            state
+                            encodedState
                         );
 
-                        this._listeners.onStorageUpdated(room, state);
+                        this._listeners.onStorageUpdated({
+                            ...context,
+                            encodedState,
+                            room,
+                        });
                     }
 
                     const state =
@@ -228,7 +242,7 @@ export class PluvIO<
             },
         },
         $UPDATE_STORAGE: {
-            resolver: ({ origin, update }, { doc, room }) => {
+            resolver: ({ origin, update }, { context, doc, room }) => {
                 if (
                     origin === "$STORAGE_RECEIVED" &&
                     Object.keys(doc.toJSON()).length
@@ -237,25 +251,30 @@ export class PluvIO<
                 }
 
                 const updated = doc.applyUpdate(update);
-                const state = updated.encodeStateAsUpdate();
+                const encodedState = updated.encodeStateAsUpdate();
 
                 this._platform.persistance
-                    .setStorageState(room, state)
+                    .setStorageState(room, encodedState)
                     .then(() => {
-                        this._listeners.onStorageUpdated(room, state);
+                        this._listeners.onStorageUpdated({
+                            ...context,
+                            encodedState,
+                            room,
+                        });
                     });
 
-                return { $STORAGE_UPDATED: { state } };
+                return { $STORAGE_UPDATED: { state: encodedState } };
             },
         },
     } as InferEventConfig<
+        TPlatform,
         TContext,
         TInput,
         TOutputBroadcast,
         TOutputSelf,
         TOutputSync
     >;
-    readonly _listeners: PluvIOListeners;
+    readonly _listeners: PluvIOListeners<TPlatform>;
     readonly _platform: TPlatform;
 
     constructor(
@@ -274,7 +293,7 @@ export class PluvIO<
             context,
             debug = false,
             events,
-            initialStorage,
+            getInitialStorage,
             onRoomDeleted,
             onStorageUpdated,
             platform,
@@ -286,15 +305,11 @@ export class PluvIO<
         if (authorize) this._authorize = authorize;
         if (context) this._context = context;
         if (events) this._events = events;
-        if (initialStorage) this._initialStorage = initialStorage;
+        if (getInitialStorage) this._getInitialStorage = getInitialStorage;
 
         this._listeners = {
-            onRoomDeleted: (room, encodedState) => {
-                return onRoomDeleted?.(room, encodedState);
-            },
-            onStorageUpdated: (room, encodedState) => {
-                return onStorageUpdated?.(room, encodedState);
-            },
+            onRoomDeleted: (event) => onRoomDeleted?.(event),
+            onStorageUpdated: (event) => onStorageUpdated?.(event),
         };
     }
 
@@ -322,6 +337,7 @@ export class PluvIO<
     >(
         event: TEvent,
         config: EventConfig<
+            TPlatform,
             TContext,
             TData,
             TResultBroadcast,
@@ -344,6 +360,7 @@ export class PluvIO<
         const newEvent = {
             [event]: config,
         } as InferEventConfig<
+            TPlatform,
             TContext,
             EventRecord<TEvent, TData>,
             TResultBroadcast extends EventRecord<string, any>
@@ -377,7 +394,7 @@ export class PluvIO<
 
     public getRoom(
         room: string,
-        options: GetRoomOptions = {}
+        options: GetRoomOptions<TPlatform>
     ): IORoom<
         TPlatform,
         TAuthorize,
@@ -387,7 +404,7 @@ export class PluvIO<
         TOutputSelf,
         TOutputSync
     > {
-        const { debug } = options;
+        const { debug, ...platformRoomContext } = options;
 
         this._purgeEmptyRooms();
 
@@ -400,6 +417,11 @@ export class PluvIO<
 
         if (oldRoom) return oldRoom;
 
+        const roomContext = {
+            ...this._context,
+            ...platformRoomContext,
+        } as TContext & InferPlatformRoomContextType<TPlatform>;
+
         const newRoom = new IORoom<
             TPlatform,
             TAuthorize,
@@ -410,16 +432,23 @@ export class PluvIO<
             TOutputSync
         >(room, {
             authorize: this._authorize ?? undefined,
-            context: this._context,
+            context: roomContext,
             debug: debug ?? this._debug,
             events: this._events,
-            onDestroy: (encodedState) => {
+            onDestroy: ({ encodedState, room }) => {
                 this._logDebug(
                     `${colors.blue("Deleting empty room:")} ${room}`
                 );
 
+                const roomContext = {
+                    room,
+                    encodedState,
+                    ...platformRoomContext,
+                } as IORoomListenerEvent<TPlatform> &
+                    InferPlatformRoomContextType<TPlatform>;
+
                 this._rooms.delete(room);
-                this._listeners.onRoomDeleted(room, encodedState);
+                this._listeners.onRoomDeleted(roomContext);
 
                 if (this._debug) {
                     const rooms = Array.from(this._rooms.keys());

package/src/createIO.ts

@@ -8,7 +8,7 @@ import type {
     MaybePromise,
 } from "@pluv/types";
 import type { AbstractPlatform } from "./AbstractPlatform";
-import type { PluvIOListeners } from "./PluvIO";
+import type { GetInitialStorageFn, PluvIOListeners } from "./PluvIO";
 import { PluvIO } from "./PluvIO";
 
 export type CreateIOParams<
@@ -16,11 +16,11 @@ export type CreateIOParams<
     TContext extends JsonObject = {},
     TAuthorizeUser extends BaseUser = BaseUser,
     TAuthorizeRequired extends boolean = false
-> = Partial<PluvIOListeners> & {
+> = Partial<PluvIOListeners<TPlatform>> & {
     authorize?: IOAuthorize<TAuthorizeUser, TAuthorizeRequired>;
     context?: TContext;
     debug?: boolean;
-    initialStorage?: (room: string) => MaybePromise<Maybe<string>>;
+    getInitialStorage?: GetInitialStorageFn<TPlatform>;
     platform: TPlatform;
 };
 
@@ -47,7 +47,7 @@ export const createIO = <
         authorize,
         context,
         debug,
-        initialStorage,
+        getInitialStorage,
         onRoomDeleted,
         onStorageUpdated,
         platform,
@@ -63,7 +63,7 @@ export const createIO = <
         authorize,
         context,
         debug,
-        initialStorage,
+        getInitialStorage,
         onRoomDeleted,
         onStorageUpdated,
         platform,

package/src/index.ts

@@ -4,32 +4,39 @@ export type {
     EventRecord,
     IOEventMessage,
 } from "@pluv/types";
+export { AbstractPersistance } from "./AbstractPersistance";
+export { AbstractPlatform } from "./AbstractPlatform";
 export type {
     ConvertWebSocketConfig,
-    InferWebSocketType,
+    InferPlatformEventContextType,
+    InferPlatformRoomContextType,
+    InferPlatformWebSocketType,
 } from "./AbstractPlatform";
-export { AbstractPersistance } from "./AbstractPersistance";
-export { AbstractPlatform } from "./AbstractPlatform";
-export type { IOPubSubEventMessage } from "./AbstractPubSub";
 export { AbstractPubSub } from "./AbstractPubSub";
+export type { IOPubSubEventMessage } from "./AbstractPubSub";
+export { AbstractWebSocket } from "./AbstractWebSocket";
 export type {
     AbstractCloseEvent,
     AbstractErrorEvent,
     AbstractEvent,
-    AbstractMessageEvent,
     AbstractEventMap,
     AbstractListener,
+    AbstractMessageEvent,
     AbstractWebSocketConfig,
     AbstractWebSocketHandleErrorParams,
 } from "./AbstractWebSocket";
-export { AbstractWebSocket } from "./AbstractWebSocket";
+export type { IORoom } from "./IORoom";
+export type {
+    GetRoomOptions,
+    InferIORoom,
+    PluvIO,
+    PluvIOConfig,
+} from "./PluvIO";
 export type {
     AuthorizeModule,
     AuthorizeParams,
     JWT,
     JWTEncodeParams,
 } from "./authorize";
-export type { CreateIOParams } from "./createIO";
 export { createIO } from "./createIO";
-export type { IORoom } from "./IORoom";
-export type { GetRoomOptions, InferIORoom, PluvIO } from "./PluvIO";
+export type { CreateIOParams } from "./createIO";

package/src/types.ts

@@ -6,6 +6,11 @@ import type {
     JsonObject,
     MaybePromise,
 } from "@pluv/types";
+import {
+    AbstractPlatform,
+    InferPlatformEventContextType,
+    InferPlatformRoomContextType,
+} from "./AbstractPlatform";
 import type { AbstractWebSocket } from "./AbstractWebSocket";
 
 export interface Console {
@@ -23,7 +28,8 @@ declare global {
 }
 
 export interface EventConfig<
-    TContext extends JsonObject = {},
+    TPlatform extends AbstractPlatform = AbstractPlatform,
+    TContext extends Record<string, any> = {},
     TData extends JsonObject = {},
     TResultBroadcast extends EventRecord<string, any> = {},
     TResultSelf extends EventRecord<string, any> = {},
@@ -31,8 +37,15 @@ export interface EventConfig<
 > {
     input?: InputZodLike<TData>;
     resolver:
-        | EventResolver<TContext, TData, TResultBroadcast>
+        | EventResolver<
+              TContext &
+                  InferPlatformRoomContextType<TPlatform> &
+                  InferPlatformEventContextType<TPlatform>,
+              TData,
+              TResultBroadcast
+          >
         | EventResolverObject<
+              TPlatform,
               TContext,
               TData,
               TResultBroadcast,
@@ -43,8 +56,17 @@ export interface EventConfig<
 
 export type EventConfigType = "broadcast" | "self" | "sync";
 
+export type SyncEventResolver<
+    TContext extends Record<string, any> = {},
+    TData extends JsonObject = {},
+    TResultBroadcast extends EventRecord<string, any> = {}
+> = (
+    data: TData,
+    context: EventResolverContext<TContext>
+) => MaybePromise<TResultBroadcast | void>;
+
 export type EventResolver<
-    TContext extends JsonObject = {},
+    TContext extends Record<string, any> = {},
     TData extends JsonObject = {},
     TResultBroadcast extends EventRecord<string, any> = {}
 > = (
@@ -52,7 +74,9 @@ export type EventResolver<
     context: EventResolverContext<TContext>
 ) => MaybePromise<TResultBroadcast | void>;
 
-export interface EventResolverContext<TContext extends JsonObject = {}> {
+export interface EventResolverContext<
+    TContext extends Record<string, any> = {}
+> {
     context: TContext;
     doc: YjsDoc<any>;
     room: string;
@@ -73,19 +97,33 @@ export interface EventResolverContext<TContext extends JsonObject = {}> {
 }
 
 export type EventResolverObject<
-    TContext extends JsonObject = {},
+    TPlatform extends AbstractPlatform = AbstractPlatform,
+    TContext extends Record<string, any> = {},
     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>;
+    broadcast?: EventResolver<
+        TContext &
+            InferPlatformRoomContextType<TPlatform> &
+            InferPlatformEventContextType<TPlatform>,
+        TData,
+        TResultBroadcast
+    >;
+    self?: EventResolver<
+        TContext &
+            InferPlatformRoomContextType<TPlatform> &
+            InferPlatformEventContextType<TPlatform>,
+        TData,
+        TResultSelf
+    >;
+    sync?: SyncEventResolver<TContext, TData, TResultSync>;
 };
 
 export type InferEventConfig<
-    TContext extends JsonObject = {},
+    TPlatform extends AbstractPlatform = AbstractPlatform,
+    TContext extends Record<string, any> = {},
     TInput extends EventRecord<string, any> = {},
     TOutputBroadcast extends EventRecord<string, any> = {},
     TOutputSelf extends EventRecord<string, any> = {},
@@ -94,6 +132,7 @@ export type InferEventConfig<
     [P in keyof TInput]: P extends string
         ? Id<
               EventConfig<
+                  TPlatform,
                   TContext,
                   TInput[P],
                   TOutputBroadcast,