@pluv/client 0.25.4 → 0.27.0

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;
@@ -46,10 +51,11 @@ const ORIGIN_STORAGE_UPDATED = "$STORAGE_UPDATED";
 
 export const DEFAULT_PLUV_CLIENT_ADDON = <
     TIO extends IOLike = IOLike,
+    TMetadata extends JsonObject = {},
     TPresence extends JsonObject = {},
     TStorage extends Record<string, CrdtType<any, any>> = {},
 >(
-    input: PluvRoomAddonInput<TIO, TPresence, TStorage>,
+    input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TStorage>,
 ): PluvRoomAddonResult => ({
     storage: new StorageStore(input.room.id),
 });
@@ -83,15 +89,22 @@ interface TimeoutIds {
     reconnect: number | null;
 }
 
-export type AuthEndpoint = string | ((room: string) => string | FetchOptions) | true;
-export type WsEndpoint = string | ((room: string) => string);
+export interface EndpointParams<TMetadata extends JsonObject> {
+    metadata: TMetadata;
+    room: string;
+}
+export type AuthEndpoint<TMetadata extends JsonObject> =
+    | string
+    | ((params: EndpointParams<TMetadata>) => string | FetchOptions)
+    | true;
+export type WsEndpoint<TMetadata extends JsonObject> = string | ((params: EndpointParams<TMetadata>) => string);
 
 type FetchOptions = { url: string; options?: RequestInit };
 
-export type RoomEndpoints<TIO extends IOLike> = {
-    wsEndpoint?: WsEndpoint;
+export type RoomEndpoints<TIO extends IOLike, TMetadata extends JsonObject> = {
+    wsEndpoint?: WsEndpoint<TMetadata>;
 } & (InferIOAuthorizeRequired<InferIOAuthorize<TIO>> extends true
-    ? { authEndpoint: AuthEndpoint }
+    ? { authEndpoint: AuthEndpoint<TMetadata> }
     : { authEndpoint?: undefined });
 
 interface InternalListeners {
@@ -100,16 +113,18 @@ interface InternalListeners {
 
 export type PluvRoomAddon<
     TIO extends IOLike = IOLike,
+    TMetadata extends JsonObject = {},
     TPresence extends JsonObject = {},
     TStorage extends Record<string, CrdtType<any, any>> = {},
-> = (input: PluvRoomAddonInput<TIO, TPresence, TStorage>) => Partial<PluvRoomAddonResult>;
+> = (input: PluvRoomAddonInput<TIO, TMetadata, TPresence, TStorage>) => Partial<PluvRoomAddonResult>;
 
 export interface PluvRoomAddonInput<
     TIO extends IOLike = IOLike,
+    TMetadata extends JsonObject = {},
     TPresence extends JsonObject = {},
     TStorage extends Record<string, CrdtType<any, any>> = {},
 > {
-    room: PluvRoom<TIO, TPresence, TStorage>;
+    room: PluvRoom<TIO, TMetadata, TPresence, TStorage>;
 }
 
 export interface PluvRoomAddonResult {
@@ -121,39 +136,44 @@ export type PluvRoomDebug<TIO extends IOLike> = Id<{
     input: readonly (keyof InferIOInput<TIO>)[];
 }>;
 
-export type PluvRoomOptions<
-    TIO extends IOLike,
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-> = {
-    addons?: readonly PluvRoomAddon<TIO, TPresence, TStorage>[];
-    debug?: boolean | PluvRoomDebug<TIO>;
-    onAuthorizationFail?: (error: Error) => void;
-} & Omit<CrdtManagerOptions<TStorage>, "encodedState"> &
-    UsersManagerConfig<TPresence>;
-
 export type RoomConfig<
     TIO extends IOLike,
+    TMetadata extends JsonObject = {},
     TPresence extends JsonObject = {},
     TStorage extends Record<string, CrdtType<any, any>> = {},
-> = RoomEndpoints<TIO> & PluvRoomOptions<TIO, 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>;
+    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,
@@ -179,15 +199,17 @@ export class PluvRoom<
     private _wsListeners: WebSocketListeners | null = null;
     private _usersManager: UsersManager<TIO, TPresence>;
 
-    constructor(room: string, options: RoomConfig<TIO, TPresence, TStorage>) {
+    constructor(room: string, options: RoomConfig<TIO, TMetadata, TPresence, TStorage, TEvents>) {
         const {
             addons = [],
             authEndpoint,
             debug = false,
             initialPresence,
             initialStorage,
+            metadata,
             onAuthorizationFail,
             presence,
+            router,
             wsEndpoint,
         } = options;
 
@@ -200,11 +222,11 @@ export class PluvRoom<
             ...addon({ room: this }),
         };
 
-        this._storageStore = storage;
-
         this._debug = debug;
+        this._endpoints = { authEndpoint, wsEndpoint } as RoomEndpoints<TIO, TMetadata>;
+        this._storageStore = storage;
 
-        this._endpoints = { authEndpoint, wsEndpoint } as RoomEndpoints<TIO>;
+        if (!!metadata) this._metadata = metadata;
 
         this._listeners = {
             onAuthorizationFail: (error) => {
@@ -215,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 });
     }
@@ -228,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 => {
@@ -332,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 => {
@@ -459,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> {
@@ -607,9 +675,9 @@ export class PluvRoom<
     );
 
     private _getAddon = (
-        addons: readonly PluvRoomAddon<TIO, TPresence, TStorage>[],
-    ): PluvRoomAddon<TIO, TPresence, TStorage> => {
-        return addons.reduce<PluvRoomAddon<TIO, TPresence, TStorage>>(
+        addons: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>[],
+    ): PluvRoomAddon<TIO, TMetadata, TPresence, TStorage> => {
+        return addons.reduce<PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>>(
             (acc, addon) => () => ({
                 ...acc({ room: this }),
                 ...addon({ room: this }),
@@ -635,7 +703,7 @@ export class PluvRoom<
             };
         }
 
-        const result = this._endpoints.authEndpoint(room);
+        const result = this._endpoints.authEndpoint({ metadata: this._metadata, room });
 
         return typeof result === "string" ? { url: result, options: {} } : result;
     }
@@ -667,7 +735,7 @@ export class PluvRoom<
             case "string":
                 return this._endpoints.wsEndpoint;
             default:
-                return this._endpoints.wsEndpoint(room);
+                return this._endpoints.wsEndpoint({ metadata: this._metadata, room });
         }
     }
 

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,7 +1,15 @@
-import type { IOLike } from "@pluv/types";
+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>(options: PluvClientOptions<TIO>): PluvClient<TIO> => {
-    return new PluvClient<TIO>(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

@@ -2,12 +2,14 @@ export type { CrdtType, InferCrdtJson } from "@pluv/crdt";
 export type { BaseUser, EventMessage, EventRecord, IOEventMessage } from "@pluv/types";
 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 } from "./PluvRoom";
-export { createClient } from "./createClient";
-export { ConnectionState } from "./types";
+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";