@pluv/client 0.26.0 → 0.27.0

package/src/PluvClient.ts

@@ -1,45 +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, TMetadata extends JsonObject> = RoomEndpoints<TIO, TMetadata> & {
+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, TMetadata extends JsonObject = {}> {
+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 _initialStorage?: AbstractCrdtDocFactory<TStorage>;
+    private _presence?: InputZodLike<TPresence>;
     private _wsEndpoint: WsEndpoint<TMetadata> | undefined;
 
-    private _rooms = new Map<string, PluvRoom<TIO, TMetadata, 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, TMetadata>) {
-        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<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, TMetadata, TPresence, TStorage>,
+        options: CreateRoomOptions<TIO, TPresence, TStorage, TMetadata, TEvents>,
     ): PluvRoom<TIO, TMetadata, TPresence, TStorage> => {
-        const oldRoom = this.getRoom<TPresence, TStorage>(room);
+        const oldRoom = this.getRoom(room);
 
         if (oldRoom) return oldRoom;
 
-        const newRoom = new PluvRoom<TIO, TMetadata, 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, TMetadata, TPresence, TStorage>);
+        } as RoomConfig<TIO, TMetadata, TPresence, TStorage, TEvents>);
 
         this._rooms.set(room, newRoom);
 
@@ -50,7 +97,7 @@ export class PluvClient<TIO extends IOLike = IOLike, TMetadata extends JsonObjec
 
     public enter = async (
         room: string | PluvRoom<TIO, any, any, any>,
-    ): Promise<PluvRoom<TIO, TMetadata, JsonObject, 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}.`);
@@ -64,15 +111,13 @@ export class PluvClient<TIO extends IOLike = IOLike, TMetadata extends JsonObjec
         return toEnter;
     };
 
-    public getRoom = <TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}>(
-        room: string,
-    ): PluvRoom<TIO, TMetadata, TPresence, TStorage> | null => {
-        const found = this._rooms.get(room) as PluvRoom<TIO, TMetadata, 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, TMetadata, JsonObject, any>[] => {
+    public getRooms = (): readonly PluvRoom<TIO, TMetadata, TPresence, TStorage, any>[] => {
         return Array.from(this._rooms.values());
     };
 
@@ -88,6 +133,12 @@ export class PluvClient<TIO extends IOLike = IOLike, TMetadata extends JsonObjec
         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;
+    }
+}

package/src/PluvRoom.ts

@@ -21,20 +21,25 @@ 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 { StorageStore } from "./StorageStore";
 import type { UsersManagerConfig } from "./UsersManager";
 import { UsersManager } from "./UsersManager";
+import { ConnectionState } from "./enums";
 import type {
     AuthorizationState,
+    EventResolver,
+    EventResolverContext,
     InternalSubscriptions,
     UpdateMyPresenceAction,
     UserInfo,
     WebSocketConnection,
     WebSocketState,
 } from "./types";
-import { ConnectionState } from "./types";
 import { debounce } from "./utils";
 
 const ADD_TO_STORAGE_STATE_DEBOUNCE_MS = 1_000;
@@ -131,44 +136,44 @@ export type PluvRoomDebug<TIO extends IOLike> = Id<{
     input: readonly (keyof InferIOInput<TIO>)[];
 }>;
 
-export type PluvRoomOptions<
-    TIO extends IOLike,
-    TMetadata extends JsonObject = {},
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-> = {
-    addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>[];
-    debug?: boolean | PluvRoomDebug<TIO>;
-    onAuthorizationFail?: (error: Error) => void;
-} & Omit<CrdtManagerOptions<TStorage>, "encodedState"> &
-    UsersManagerConfig<TPresence> &
-    (keyof TMetadata extends never ? { metadata?: undefined } : { metadata: TMetadata });
-
 export type RoomConfig<
     TIO extends IOLike,
     TMetadata extends JsonObject = {},
     TPresence extends JsonObject = {},
     TStorage extends Record<string, CrdtType<any, any>> = {},
-> = RoomEndpoints<TIO, TMetadata> & PluvRoomOptions<TIO, TMetadata, TPresence, TStorage>;
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
+> = Id<
+    {
+        addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>[];
+        debug?: boolean | PluvRoomDebug<TIO>;
+        onAuthorizationFail?: (error: Error) => void;
+        router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+    } & RoomEndpoints<TIO, TMetadata> &
+        Pick<CrdtManagerOptions<TStorage>, "initialStorage"> &
+        UsersManagerConfig<TPresence> &
+        (keyof TMetadata extends never ? { metadata?: undefined } : { metadata: TMetadata })
+>;
 
 export class PluvRoom<
     TIO extends IOLike,
     TMetadata extends JsonObject = {},
     TPresence extends JsonObject = {},
     TStorage extends Record<string, CrdtType<any, any>> = {},
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
 > extends AbstractRoom<TIO, TPresence, TStorage> {
     readonly _endpoints: RoomEndpoints<TIO, TMetadata>;
 
     private _crdtManager: CrdtManager<TStorage>;
     private _crdtNotifier = new CrdtNotifier<TStorage>();
     private _debug: boolean | PluvRoomDebug<TIO>;
-    private _eventNotifier = new EventNotifier<TIO>();
+    private _eventNotifier = new EventNotifier<MergeEvents<TEvents, TIO>>();
     private _intervals: IntervalIds = {
         heartbeat: null,
     };
     private _listeners: InternalListeners;
     private _metadata: TMetadata = {} as TMetadata;
     private _otherNotifier = new OtherNotifier<TIO>();
+    private _router: PluvRouter<TIO, TPresence, TStorage, TEvents>;
     private _state: WebSocketState<TIO> = {
         authorization: {
             token: null,
@@ -194,7 +199,7 @@ export class PluvRoom<
     private _wsListeners: WebSocketListeners | null = null;
     private _usersManager: UsersManager<TIO, TPresence>;
 
-    constructor(room: string, options: RoomConfig<TIO, TMetadata, TPresence, TStorage>) {
+    constructor(room: string, options: RoomConfig<TIO, TMetadata, TPresence, TStorage, TEvents>) {
         const {
             addons = [],
             authEndpoint,
@@ -204,6 +209,7 @@ export class PluvRoom<
             metadata,
             onAuthorizationFail,
             presence,
+            router,
             wsEndpoint,
         } = options;
 
@@ -231,6 +237,7 @@ export class PluvRoom<
             },
         };
 
+        this._router = router ?? (new PluvRouter({}) as PluvRouter<TIO, TPresence, TStorage, TEvents>);
         this._usersManager = new UsersManager<TIO, TPresence>({ initialPresence, presence });
         this._crdtManager = new CrdtManager<TStorage>({ initialStorage });
     }
@@ -244,23 +251,62 @@ export class PluvRoom<
     }
 
     public broadcast = new Proxy(
-        <TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void => {
+        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();
 
-            this._sendMessage({ data, type });
+            const procedure = this._router._defs.events[type] as PluvProcedure<
+                TIO,
+                any,
+                any,
+                TPresence,
+                TStorage
+            > | null;
+
+            if (!procedure?.config.broadcast) {
+                this._sendMessage({ data, type });
+
+                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,
+            );
+
+            Object.entries(output).forEach(([_type, _data]) => {
+                this._sendMessage({ data: _data, type: _type });
+            });
         },
         {
             get(fn, prop) {
-                return (data: Id<InferIOInput<TIO>[any]>): void => {
-                    return fn(prop, data);
+                return async (data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[any]>): Promise<void> => {
+                    return await fn(prop, data);
                 };
             },
         },
-    ) as (<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>) => void) & {
-        [event in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[event]>) => void;
+    ) 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 => {
@@ -348,20 +394,23 @@ export class PluvRoom<
     }
 
     public event = new Proxy(
-        <TEvent extends keyof InferIOOutput<TIO>>(
+        <TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(
             event: TEvent,
-            callback: EventNotifierSubscriptionCallback<TIO, TEvent>,
+            callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>,
         ): (() => void) => this._eventNotifier.subscribe(event, callback),
         {
             get(fn, prop) {
-                return (callback: EventNotifierSubscriptionCallback<TIO, any>): (() => void) => fn(prop, callback);
+                return (callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>): (() => void) =>
+                    fn(prop as any, callback);
             },
         },
-    ) as (<TEvent extends keyof InferIOOutput<TIO>>(
+    ) as (<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(
         event: TEvent,
-        callback: EventNotifierSubscriptionCallback<TIO, TEvent>,
+        callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>,
     ) => () => void) & {
-        [event in keyof InferIOOutput<TIO>]: (callback: EventNotifierSubscriptionCallback<TIO, event>) => () => void;
+        [event in keyof InferIOOutput<MergeEvents<TEvents, TIO>>]: (
+            callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>,
+        ) => () => void;
     };
 
     public getConnection = (): WebSocketConnection => {
@@ -475,7 +524,10 @@ export class PluvRoom<
         this._stateNotifier.subjects["my-presence"].next(myPresence);
         !!myself && this._stateNotifier.subjects["myself"].next(myself);
 
-        this.broadcast("$UPDATE_PRESENCE" as keyof InferIOInput<TIO>, { presence: newPresence } as any);
+        this.broadcast(
+            "$UPDATE_PRESENCE" as keyof InferIOInput<MergeEvents<TEvents, TIO>>,
+            { presence: newPresence } as any,
+        );
     };
 
     private async _addToStorageStore(update: string): Promise<void> {

package/src/PluvRouter.ts

@@ -0,0 +1,70 @@
+import type { CrdtType } from "@pluv/crdt";
+import type { Id, IOLike, IORouterLike, JsonObject, ProcedureLike } from "@pluv/types";
+import type { PluvProcedure } from "./PluvProcedure";
+
+export type PluvRouterEventConfig<
+    TIO extends IOLike = IOLike,
+    TPresence extends JsonObject = {},
+    TStorage extends Record<string, CrdtType<any, any>> = {},
+> = { [P: string]: Pick<PluvProcedure<TIO, any, any, TPresence, TStorage>, "config"> };
+
+export type MergedRouter<
+    TRouters extends PluvRouter<TIO, TPresence, TStorage, any>[] = [],
+    TIO extends IOLike = IOLike,
+    TPresence extends JsonObject = {},
+    TStorage extends Record<string, CrdtType<any, any>> = {},
+    TRoot extends TRouters[0]["_defs"]["events"] = {},
+> = TRouters extends [
+    infer IHead extends PluvRouter<TIO, TPresence, TStorage, any>,
+    ...infer ITail extends PluvRouter<TIO, TPresence, TStorage, any>[],
+]
+    ? MergedRouter<ITail, TIO, TPresence, TStorage, TRoot & IHead["_defs"]["events"]>
+    : PluvRouter<TIO, TPresence, TStorage, TRoot>;
+
+export type MergeEvents<
+    TClientEvents extends PluvRouterEventConfig<any, any, any>,
+    TServerIO extends IOLike<any, any>,
+> =
+    TServerIO extends IOLike<infer IAuthorize, infer IServerEvents>
+        ? IOLike<
+              IAuthorize,
+              {
+                  [P in keyof TClientEvents]: TClientEvents[P] extends ProcedureLike<
+                      infer IClientInput,
+                      infer IClientOutput
+                  >
+                      ? {
+                            [K in keyof IClientOutput]: K extends keyof IServerEvents
+                                ? IServerEvents[K]
+                                : ProcedureLike<IClientInput, Id<Pick<IClientOutput, K>>>;
+                        }[keyof IClientOutput]
+                      : never;
+              } & IServerEvents
+          >
+        : never;
+
+export class PluvRouter<
+    TIO extends IOLike = IOLike,
+    TPresence extends JsonObject = {},
+    TStorage extends Record<string, CrdtType<any, any>> = {},
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
+> implements IORouterLike<TEvents>
+{
+    readonly _defs: { events: TEvents } = { events: {} as TEvents };
+
+    constructor(events: TEvents) {
+        this._defs = { events };
+    }
+
+    public static merge<TRouters extends PluvRouter<any, any, any, any>[]>(
+        ...routers: TRouters
+    ): MergedRouter<TRouters> {
+        const events = Object.assign(Object.create(null), ...routers.map((router) => router._defs.events));
+
+        if (Object.keys(events).some((key) => key.startsWith("$"))) {
+            throw new Error('Procedures may not start with "$"');
+        }
+
+        return new PluvRouter<any, any, any, any>(events) as MergedRouter<TRouters>;
+    }
+}

package/src/createClient.ts

@@ -1,9 +1,15 @@
+import type { CrdtType } from "@pluv/crdt";
 import type { IOLike, JsonObject } from "@pluv/types";
 import type { PluvClientOptions } from "./PluvClient";
 import { PluvClient } from "./PluvClient";
 
-export const createClient = <TIO extends IOLike = IOLike, TMetadata extends JsonObject = {}>(
-    options: PluvClientOptions<TIO, TMetadata>,
-): PluvClient<TIO, TMetadata> => {
-    return new PluvClient<TIO, TMetadata>(options);
+export const createClient = <
+    TIO extends IOLike = IOLike,
+    TPresence extends JsonObject = {},
+    TStorage extends Record<string, CrdtType<any, any>> = {},
+    TMetadata extends JsonObject = {},
+>(
+    options: PluvClientOptions<TIO, TPresence, TStorage, TMetadata>,
+): PluvClient<TIO, TPresence, TStorage, TMetadata> => {
+    return new PluvClient<TIO, TPresence, TStorage, TMetadata>(options);
 };

package/src/enums.ts

@@ -0,0 +1,7 @@
+export enum ConnectionState {
+    Closed = "Closed",
+    Connecting = "Connecting",
+    Open = "Open",
+    Unavailable = "Unavailable",
+    Untouched = "Untouched",
+}

package/src/index.ts

@@ -3,17 +3,13 @@ export type { BaseUser, EventMessage, EventRecord, IOEventMessage } from "@pluv/
 export { AbstractRoom } from "./AbstractRoom";
 export { AbstractStorageStore } from "./AbstractStorageStore";
 export { createClient } from "./createClient";
+export { ConnectionState } from "./enums";
 export { MockedRoom } from "./MockedRoom";
 export type { MockedRoomConfig, MockedRoomEvents } from "./MockedRoom";
 export { PluvClient } from "./PluvClient";
-export type { PluvClientOptions } from "./PluvClient";
+export type { CreateRoomOptions, PluvClientOptions } from "./PluvClient";
+export type { PluvProcedureConfig } from "./PluvProcedure";
 export { PluvRoom } from "./PluvRoom";
-export type {
-    PluvRoomAddon,
-    PluvRoomAddonInput,
-    PluvRoomAddonResult,
-    PluvRoomDebug,
-    PluvRoomOptions,
-} from "./PluvRoom";
-export { ConnectionState } from "./types";
+export type { PluvRoomAddon, PluvRoomAddonInput, PluvRoomAddonResult, PluvRoomDebug } from "./PluvRoom";
+export type { MergeEvents, PluvRouter, PluvRouterEventConfig } from "./PluvRouter";
 export type { UserInfo, WebSocketConnection, WebSocketState } from "./types";

package/src/types.ts

@@ -1,22 +1,58 @@
-import type { Id, InferIOAuthorize, InferIOAuthorizeUser, IOLike, JsonObject } from "@pluv/types";
+import type { AbstractCrdtDoc, CrdtType } from "@pluv/crdt";
+import type {
+    EventRecord,
+    Id,
+    InferIOAuthorize,
+    InferIOAuthorizeUser,
+    IOLike,
+    JsonObject,
+    MaybePromise,
+} from "@pluv/types";
+import type { ConnectionState } from "./enums";
 
 export interface AuthorizationState<TIO extends IOLike> {
     token: string | null;
     user: InferIOAuthorizeUser<InferIOAuthorize<TIO>> | null;
 }
 
-export enum ConnectionState {
-    Closed = "Closed",
-    Connecting = "Connecting",
-    Open = "Open",
-    Unavailable = "Unavailable",
-    Untouched = "Untouched",
+export type EventResolver<
+    TIO extends IOLike = IOLike,
+    TInput extends JsonObject = {},
+    TOutput extends EventRecord<string, any> = {},
+    TPresence extends JsonObject = {},
+    TStorage extends Record<string, CrdtType<any, any>> = {},
+> = (data: TInput, context: EventResolverContext<TIO, TPresence, TStorage>) => MaybePromise<TOutput | void>;
+
+export interface EventResolverContext<
+    TIO extends IOLike = IOLike,
+    TPresence extends JsonObject = {},
+    TStorage extends Record<string, CrdtType<any, any>> = {},
+> {
+    doc: AbstractCrdtDoc<TStorage>;
+    others: readonly UserInfo<TIO, TPresence>[];
+    room: string;
+    user: UserInfo<TIO, TPresence>;
 }
 
 export interface InternalSubscriptions {
     observeCrdt: (() => void) | null;
 }
 
+export type MergeEventRecords<
+    TEventRecords extends EventRecord<string, any>[],
+    TRoot extends EventRecord<string, any> = {},
+> = TEventRecords extends [
+    infer IHead extends EventRecord<string, any>,
+    ...infer ITail extends EventRecord<string, any>[],
+]
+    ? MergeEventRecords<
+          ITail,
+          Omit<TRoot, keyof IHead> & {
+              [P in keyof IHead]: TRoot extends Record<P, any> ? TRoot[P] | IHead[P] : IHead[P];
+          }
+      >
+    : Id<TRoot>;
+
 export type UpdateMyPresenceAction<TPresence extends JsonObject> =
     | Partial<TPresence>
     | ((oldPresence: TPresence | null) => Partial<TPresence>);

package/src/utils/identity.ts

@@ -0,0 +1 @@
+export const identity = <T extends unknown>(x: T): T => x;

package/src/utils/index.ts

@@ -1 +1,2 @@
 export { debounce } from "./debounce";
+export { identity } from "./identity";