@pluv/io 0.4.1 → 0.5.0

package/src/PluvIO.ts

@@ -15,8 +15,11 @@ 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";
@@ -54,13 +57,9 @@ export type InferIORoom<TIO extends PluvIO<any, any, any, any, any, any, any>> =
           >
         : never;
 
-export interface PluvIORegisterOptions {
-    token?: 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,11 +70,12 @@ 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,
@@ -86,9 +86,9 @@ export type PluvIOConfig<
     platform: TPlatform;
 };
 
-export interface GetRoomOptions {
+export type GetRoomOptions<TPlatform extends AbstractPlatform> = {
     debug?: boolean;
-}
+} & InferPlatformRoomContextType<TPlatform>;
 
 export class PluvIO<
     TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
@@ -105,7 +105,6 @@ export class PluvIO<
     private _initialStorage:
         | ((room: string) => MaybePromise<Maybe<string>>)
         | null = null;
-    private _listeners: PluvIOListeners;
     private _rooms = new Map<
         string,
         IORoom<
@@ -122,6 +121,7 @@ export class PluvIO<
     readonly _authorize: TAuthorize | null = null;
     readonly _debug: boolean;
     readonly _events: InferEventConfig<
+        TPlatform,
         TContext,
         TInput,
         TOutputBroadcast,
@@ -171,7 +171,7 @@ export class PluvIO<
                         },
                     };
                 },
-                self: async ({ update }, { doc, room }) => {
+                self: async ({ update }, { context, doc, room }) => {
                     const oldState =
                         await this._platform.persistance.getStorageState(room);
 
@@ -181,16 +181,20 @@ export class PluvIO<
                     ];
 
                     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 =
@@ -229,7 +233,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
@@ -238,24 +242,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<TPlatform>;
     readonly _platform: TPlatform;
 
     constructor(
@@ -289,12 +299,8 @@ export class PluvIO<
         if (initialStorage) this._initialStorage = initialStorage;
 
         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 +328,7 @@ export class PluvIO<
     >(
         event: TEvent,
         config: EventConfig<
+            TPlatform,
             TContext,
             TData,
             TResultBroadcast,
@@ -344,6 +351,7 @@ export class PluvIO<
         const newEvent = {
             [event]: config,
         } as InferEventConfig<
+            TPlatform,
             TContext,
             EventRecord<TEvent, TData>,
             TResultBroadcast extends EventRecord<string, any>
@@ -377,7 +385,7 @@ export class PluvIO<
 
     public getRoom(
         room: string,
-        options: GetRoomOptions = {}
+        options: GetRoomOptions<TPlatform>
     ): IORoom<
         TPlatform,
         TAuthorize,
@@ -387,7 +395,7 @@ export class PluvIO<
         TOutputSelf,
         TOutputSync
     > {
-        const { debug } = options;
+        const { debug, ...platformRoomContext } = options;
 
         this._purgeEmptyRooms();
 
@@ -400,6 +408,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 +423,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());
@@ -467,12 +487,16 @@ export class PluvIO<
         const events1 = first._events;
         const events2 = second._events;
 
+        const { onRoomDeleted, onStorageUpdated } = first._listeners;
+
         const events = Object.assign(Object.create(null), events1, events2);
 
         return new PluvIO({
             authorize,
             debug,
             events,
+            onRoomDeleted,
+            onStorageUpdated,
             platform,
         });
     }

package/src/createIO.ts

@@ -16,7 +16,7 @@ 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;

package/src/index.ts

@@ -4,32 +4,34 @@ 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 } 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,