@pluv/client 0.25.4 → 0.27.0

package/src/MockedRoom.ts

@@ -8,18 +8,23 @@ import type { EventNotifierSubscriptionCallback } from "./EventNotifier";
 import { EventNotifier } from "./EventNotifier";
 import type { OtherNotifierSubscriptionCallback } from "./OtherNotifier";
 import { OtherNotifier } from "./OtherNotifier";
+import { PluvProcedure } from "./PluvProcedure";
+import type { MergeEvents, PluvRouterEventConfig } from "./PluvRouter";
+import { PluvRouter } from "./PluvRouter";
 import type { StateNotifierSubjects, SubscriptionCallback } from "./StateNotifier";
 import { StateNotifier } from "./StateNotifier";
 import type { UsersManagerConfig } from "./UsersManager";
 import { UsersManager } from "./UsersManager";
+import { ConnectionState } from "./enums";
 import type {
+    EventResolver,
+    EventResolverContext,
     InternalSubscriptions,
     UpdateMyPresenceAction,
     UserInfo,
     WebSocketConnection,
     WebSocketState,
 } from "./types";
-import { ConnectionState } from "./types";
 
 export type MockedRoomEvents<TIO extends IOLike> = Partial<{
     [P in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[P]>) => Partial<InferIOOutput<TIO>>;
@@ -29,19 +34,25 @@ export type MockedRoomConfig<
     TIO extends IOLike,
     TPresence extends JsonObject = {},
     TStorage extends Record<string, CrdtType<any, any>> = {},
-> = { events?: MockedRoomEvents<TIO> } & Omit<CrdtManagerOptions<TStorage>, "encodedState"> &
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
+> = {
+    events?: MockedRoomEvents<MergeEvents<TEvents, TIO>>;
+    router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+} & Pick<CrdtManagerOptions<TStorage>, "initialStorage"> &
     UsersManagerConfig<TPresence>;
 
 export class MockedRoom<
     TIO extends IOLike,
     TPresence extends JsonObject = {},
     TStorage extends Record<string, CrdtType<any, any>> = {},
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
 > extends AbstractRoom<TIO, TPresence, TStorage> {
     private _crdtManager: CrdtManager<TStorage>;
     private _crdtNotifier = new CrdtNotifier<TStorage>();
-    private _eventNotifier = new EventNotifier<TIO>();
-    private _events?: MockedRoomEvents<TIO>;
+    private _eventNotifier = new EventNotifier<MergeEvents<TEvents, TIO>>();
+    private _events?: MockedRoomEvents<MergeEvents<TEvents, TIO>>;
     private _otherNotifier = new OtherNotifier<TIO>();
+    private _router: PluvRouter<TIO, TPresence, TStorage, TEvents>;
     private _state: WebSocketState<TIO> = {
         authorization: {
             token: null,
@@ -60,13 +71,14 @@ export class MockedRoom<
     };
     private _usersManager: UsersManager<TIO, TPresence>;
 
-    constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TStorage>) {
-        const { events, initialPresence, initialStorage, presence } = options;
+    constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TStorage, TEvents>) {
+        const { events, initialPresence, initialStorage, presence, router } = options;
 
         super(room);
 
         this._events = events;
 
+        this._router = router ?? (new PluvRouter({}) as PluvRouter<TIO, TPresence, TStorage, TEvents>);
         this._usersManager = new UsersManager<TIO, TPresence>({
             initialPresence,
             presence,
@@ -83,24 +95,64 @@ export class MockedRoom<
         return true;
     }
 
-    public broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void {
-        if (!this._events) return;
-
-        const resolver = this._events[event];
-
-        if (!resolver) return;
-
-        const result = resolver(data);
-
-        Object.keys(result).forEach((type) => {
-            const _type = type.toString() as keyof Partial<InferIOOutput<TIO>>;
-            const data = result[_type] as any;
-
-            if (!data) return;
+    public broadcast = new Proxy(
+        async <TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(
+            event: TEvent,
+            data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>,
+        ): Promise<void> => {
+            if (!this._state.webSocket) return;
+            if (this._state.connection.state !== ConnectionState.Open) return;
+
+            const type = event.toString();
+
+            const procedure = this._router._defs.events[type] as PluvProcedure<
+                TIO,
+                any,
+                any,
+                TPresence,
+                TStorage
+            > | null;
+
+            if (!procedure?.config.broadcast) {
+                this._simulateEvent(type as TEvent, data);
+
+                return;
+            }
+
+            const myself = this._usersManager.myself;
+
+            if (!myself) return;
+
+            const parsed = procedure.config.input ? procedure.config.input.parse(data) : data;
+            const context: EventResolverContext<TIO, TPresence, TStorage> = {
+                doc: this._crdtManager.doc,
+                others: this._usersManager.getOthers(),
+                room: this.id,
+                user: myself,
+            };
+
+            const output = await (procedure.config.broadcast as EventResolver<TIO, any, any, TPresence, TStorage>)(
+                parsed,
+                context,
+            );
 
-            this._eventNotifier.subject(_type).next(data);
-        });
-    }
+            Object.entries(output).forEach(([_type, _data]) => {
+                this._simulateEvent(_type as TEvent, _data as any);
+            });
+        },
+        {
+            get(fn, prop) {
+                return async (data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[any]>): Promise<void> => {
+                    return await fn(prop, data);
+                };
+            },
+        },
+    ) as (<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(
+        event: TEvent,
+        data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>,
+    ) => Promise<void>) & {
+        [event in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[event]>) => Promise<void>;
+    };
 
     public canRedo = (): boolean => {
         return !!this._crdtManager.doc.canRedo();
@@ -110,11 +162,24 @@ export class MockedRoom<
         return !!this._crdtManager.doc.canUndo();
     };
 
-    public event = <TEvent extends keyof InferIOOutput<TIO>>(
+    public event = new Proxy(
+        <TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(
+            event: TEvent,
+            callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>,
+        ): (() => void) => this._eventNotifier.subscribe(event, callback),
+        {
+            get(fn, prop) {
+                return (callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>): (() => void) =>
+                    fn(prop as any, callback);
+            },
+        },
+    ) as (<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(
         event: TEvent,
-        callback: EventNotifierSubscriptionCallback<TIO, TEvent>,
-    ): (() => void) => {
-        return this._eventNotifier.subscribe(event, callback);
+        callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>,
+    ) => () => void) & {
+        [event in keyof InferIOOutput<MergeEvents<TEvents, TIO>>]: (
+            callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>,
+        ) => () => void;
     };
 
     public getConnection = (): WebSocketConnection => {
@@ -260,4 +325,27 @@ export class MockedRoom<
 
         this._subscriptions.observeCrdt = unsubscribe;
     }
+
+    private _simulateEvent<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(
+        event: TEvent,
+        data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>,
+    ) {
+        if (!this._events) return;
+
+        const type = event.toString();
+        const resolver = this._events[type as TEvent];
+
+        if (!resolver) return;
+
+        const result = resolver(data);
+
+        Object.keys(result).forEach((type) => {
+            const _type = type.toString() as keyof Partial<InferIOOutput<TIO>>;
+            const data = result[_type] as any;
+
+            if (!data) return;
+
+            this._eventNotifier.subject(_type).next(data);
+        });
+    }
 }

package/src/PluvClient.ts

@@ -1,44 +1,92 @@
-import type { CrdtType } from "@pluv/crdt";
-import type { IOLike, JsonObject } from "@pluv/types";
-import type { AuthEndpoint, PluvRoomOptions, RoomConfig, RoomEndpoints, WsEndpoint } from "./PluvRoom";
+import type { AbstractCrdtDocFactory, CrdtType } from "@pluv/crdt";
+import type { InputZodLike, IOLike, JsonObject } from "@pluv/types";
+import { PluvProcedure } from "./PluvProcedure";
+import type { AuthEndpoint, PluvRoomAddon, PluvRoomDebug, RoomConfig, RoomEndpoints, WsEndpoint } from "./PluvRoom";
 import { PluvRoom } from "./PluvRoom";
+import type { PluvRouterEventConfig } from "./PluvRouter";
+import { PluvRouter } from "./PluvRouter";
+import type { identity } from "./utils";
 
-export type PluvClientOptions<TIO extends IOLike> = RoomEndpoints<TIO> & {
+export type InferCallback<TIO extends IOLike> = (i: typeof identity) => {
+    io: (io: TIO) => TIO;
+};
+
+export type PluvClientOptions<
+    TIO extends IOLike,
+    TPresence extends JsonObject,
+    TStorage extends Record<string, CrdtType<any, any>>,
+    TMetadata extends JsonObject,
+> = RoomEndpoints<TIO, TMetadata> & {
     debug?: boolean;
+    infer: InferCallback<TIO>;
+    initialStorage?: AbstractCrdtDocFactory<TStorage>;
+    metadata?: InputZodLike<TMetadata>;
+    presence?: InputZodLike<TPresence>;
 };
 
-export class PluvClient<TIO extends IOLike = IOLike> {
-    private _authEndpoint: AuthEndpoint | undefined;
+export type CreateRoomOptions<
+    TIO extends IOLike,
+    TPresence extends JsonObject,
+    TStorage extends Record<string, CrdtType<any, any>>,
+    TMetadata extends JsonObject,
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
+> = {
+    addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>[];
+    debug?: boolean | PluvRoomDebug<TIO>;
+    initialPresence?: TPresence;
+    initialStorage?: AbstractCrdtDocFactory<TStorage>;
+    onAuthorizationFail?: (error: Error) => void;
+    router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+} & (keyof TMetadata extends never ? { metadata?: undefined } : { metadata: TMetadata });
+
+export class PluvClient<
+    TIO extends IOLike = IOLike,
+    TPresence extends JsonObject = {},
+    TStorage extends Record<string, CrdtType<any, any>> = {},
+    TMetadata extends JsonObject = {},
+> {
+    private _authEndpoint: AuthEndpoint<TMetadata> | undefined;
     private _debug: boolean;
-    private _wsEndpoint: WsEndpoint | undefined;
+    private _initialStorage?: AbstractCrdtDocFactory<TStorage>;
+    private _presence?: InputZodLike<TPresence>;
+    private _wsEndpoint: WsEndpoint<TMetadata> | undefined;
 
-    private _rooms = new Map<string, PluvRoom<TIO, any, any>>();
+    private _rooms = new Map<string, PluvRoom<TIO, TMetadata, TPresence, TStorage, any>>();
+
+    public get procedure(): PluvProcedure<TIO, {}, {}, TPresence, TStorage> {
+        return new PluvProcedure<TIO, {}, {}, TPresence, TStorage>();
+    }
 
-    constructor(options: PluvClientOptions<TIO>) {
-        const { authEndpoint, debug = false, wsEndpoint } = options;
+    constructor(options: PluvClientOptions<TIO, TPresence, TStorage, TMetadata>) {
+        const { authEndpoint, debug = false, initialStorage, presence, wsEndpoint } = options;
 
-        this._authEndpoint = authEndpoint as AuthEndpoint;
+        this._authEndpoint = authEndpoint as AuthEndpoint<TMetadata>;
         this._debug = debug;
+        this._initialStorage = initialStorage;
+        this._presence = presence;
         this._wsEndpoint = wsEndpoint;
     }
 
-    public createRoom = <TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}>(
+    public createRoom = <TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}>(
         room: string,
-        options: PluvRoomOptions<TIO, TPresence, TStorage>,
-    ): PluvRoom<TIO, TPresence, TStorage> => {
-        const oldRoom = this.getRoom<TPresence, TStorage>(room);
+        options: CreateRoomOptions<TIO, TPresence, TStorage, TMetadata, TEvents>,
+    ): PluvRoom<TIO, TMetadata, TPresence, TStorage> => {
+        const oldRoom = this.getRoom(room);
 
         if (oldRoom) return oldRoom;
 
-        const newRoom = new PluvRoom<TIO, TPresence, TStorage>(room, {
+        const newRoom = new PluvRoom<TIO, TMetadata, TPresence, TStorage, TEvents>(room, {
             addons: options.addons,
             authEndpoint: this._authEndpoint,
             debug: options.debug,
             initialPresence: options.initialPresence,
-            initialStorage: options.initialStorage,
+            initialStorage: this._initialStorage,
+            metadata: options.metadata,
             onAuthorizationFail: options.onAuthorizationFail,
+            presence: this._presence,
+            router: options.router,
             wsEndpoint: this._wsEndpoint,
-        } as RoomConfig<TIO, TPresence, TStorage>);
+        } as RoomConfig<TIO, TMetadata, TPresence, TStorage, TEvents>);
 
         this._rooms.set(room, newRoom);
 
@@ -47,12 +95,12 @@ export class PluvClient<TIO extends IOLike = IOLike> {
         return newRoom;
     };
 
-    public enter = async (room: string | PluvRoom<TIO, any, any>): Promise<PluvRoom<TIO, JsonObject, any>> => {
+    public enter = async (
+        room: string | PluvRoom<TIO, any, any, any>,
+    ): Promise<PluvRoom<TIO, TMetadata, TPresence, TStorage, any>> => {
         const toEnter = typeof room === "string" ? this.getRoom(room) : room;
 
-        if (!toEnter) {
-            throw new Error(`Could not find room: ${room}.`);
-        }
+        if (!toEnter) throw new Error(`Could not find room: ${room}.`);
 
         this._rooms.set(toEnter.id, toEnter);
 
@@ -63,19 +111,17 @@ export class PluvClient<TIO extends IOLike = IOLike> {
         return toEnter;
     };
 
-    public getRoom = <TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}>(
-        room: string,
-    ): PluvRoom<TIO, TPresence, TStorage> | null => {
-        const found = this._rooms.get(room) as PluvRoom<TIO, TPresence, TStorage> | undefined;
+    public getRoom = (room: string): PluvRoom<TIO, TMetadata, TPresence, TStorage, any> | null => {
+        const found = this._rooms.get(room) as PluvRoom<TIO, TMetadata, TPresence, TStorage, any> | undefined;
 
         return found ?? null;
     };
 
-    public getRooms = (): readonly PluvRoom<TIO, JsonObject, any>[] => {
+    public getRooms = (): readonly PluvRoom<TIO, TMetadata, TPresence, TStorage, any>[] => {
         return Array.from(this._rooms.values());
     };
 
-    public leave = async (room: string | PluvRoom<TIO, any, any>): Promise<void> => {
+    public leave = async (room: string | PluvRoom<TIO, any, any, any>): Promise<void> => {
         const toLeave = typeof room === "string" ? this.getRoom(room) : room;
 
         if (!toLeave) return;
@@ -87,6 +133,12 @@ export class PluvClient<TIO extends IOLike = IOLike> {
         this._logDebug(`Left and deleted room: ${room}`);
     };
 
+    public router<TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}>(
+        events: TEvents,
+    ): PluvRouter<TIO, TPresence, TStorage, TEvents> {
+        return new PluvRouter<TIO, TPresence, TStorage, TEvents>(events);
+    }
+
     private _logDebug(...data: any[]): void {
         // eslint-disable-next-line turbo/no-undeclared-env-vars
         if (process?.env?.NODE_ENV === "production") return;

package/src/PluvProcedure.ts

@@ -0,0 +1,81 @@
+import type { CrdtType } from "@pluv/crdt";
+import type { EventRecord, IOLike, InputZodLike, JsonObject, ProcedureLike } from "@pluv/types";
+import type { EventResolver, MergeEventRecords } from "./types";
+
+export interface PluvProcedureConfig<
+    TIO extends IOLike = IOLike,
+    TInput extends JsonObject = {},
+    TOutput extends EventRecord<string, any> = {},
+    TPresence extends JsonObject = {},
+    TStorage extends Record<string, CrdtType<any, any>> = {},
+> {
+    broadcast?: EventResolver<TIO, TInput, TOutput, TPresence, TStorage> | null;
+    input?: InputZodLike<TInput>;
+}
+
+export class PluvProcedure<
+    TIO extends IOLike = IOLike,
+    TInput extends JsonObject = {},
+    TOutput extends EventRecord<string, any> = {},
+    TPresence extends JsonObject = {},
+    TStorage extends Record<string, CrdtType<any, any>> = {},
+    TFilled extends "input" | "broadcast" | "" = "",
+> {
+    private _broadcast: EventResolver<TIO, TInput, Partial<TOutput>, TPresence, TStorage> | null = null;
+    private _input: InputZodLike<TInput> | null = null;
+
+    public get config(): ProcedureLike<TInput, TOutput>["config"] {
+        return {
+            broadcast: this._broadcast?.bind(this) ?? null,
+            input: this._input ?? null,
+            resolver: this._resolver(),
+        } as ProcedureLike<TInput, TOutput>["config"];
+    }
+
+    constructor(config: PluvProcedureConfig<TIO, TInput, TOutput, TPresence, TStorage> = {}) {
+        const { broadcast, input } = config;
+
+        this._broadcast = broadcast ?? null;
+        this._input = input ?? null;
+    }
+
+    public broadcast<TResult extends EventRecord<string, any> = {}>(
+        resolver: EventResolver<TIO, TInput, TResult, TPresence, TStorage>,
+    ): Omit<
+        PluvProcedure<
+            TIO,
+            TInput,
+            MergeEventRecords<[TOutput, TResult]>,
+            TPresence,
+            TStorage,
+            TFilled | "input" | "broadcast"
+        >,
+        TFilled | "input" | "broadcast"
+    > {
+        const { broadcast } = this.config;
+
+        if (!!broadcast) throw new Error("Broadcast was already defined for this procedure");
+
+        return new PluvProcedure<
+            TIO,
+            TInput,
+            MergeEventRecords<[TOutput, TResult]>,
+            TPresence,
+            TStorage,
+            TFilled | "input" | "broadcast"
+        >({
+            ...(this.config as any),
+            broadcast: resolver as any,
+        });
+    }
+
+    public input<TData extends JsonObject>(
+        input: InputZodLike<TData>,
+    ): Omit<PluvProcedure<TIO, TData, {}, TPresence, TStorage, TFilled | "input">, TFilled | "input"> {
+        return new PluvProcedure<TIO, TData, {}, TPresence, TStorage, TFilled | "input">({ input });
+    }
+
+    private _resolver(): EventResolver<TIO, TInput, TOutput, TPresence, TStorage> {
+        return (data, context) => this._broadcast?.(data, context) as TOutput;
+    }
+}