@pluv/client 0.26.0 → 0.28.0

package/dist/index.mjs

@@ -52,6 +52,41 @@ var AbstractStorageStore = class {
   }
 };
 
+// src/PluvProcedure.ts
+var PluvProcedure = class _PluvProcedure {
+  constructor(config = {}) {
+    this._broadcast = null;
+    this._input = null;
+    const { broadcast, input } = config;
+    this._broadcast = broadcast != null ? broadcast : null;
+    this._input = input != null ? input : null;
+  }
+  get config() {
+    var _a, _b, _c;
+    return {
+      broadcast: (_b = (_a = this._broadcast) == null ? void 0 : _a.bind(this)) != null ? _b : null,
+      input: (_c = this._input) != null ? _c : null,
+      resolver: this._resolver()
+    };
+  }
+  broadcast(resolver) {
+    const { broadcast } = this.config;
+    if (!!broadcast) throw new Error("Broadcast was already defined for this procedure");
+    return new _PluvProcedure(__spreadProps(__spreadValues({}, this.config), {
+      broadcast: resolver
+    }));
+  }
+  input(input) {
+    return new _PluvProcedure({ input });
+  }
+  _resolver() {
+    return (data, context) => {
+      var _a;
+      return (_a = this._broadcast) == null ? void 0 : _a.call(this, data, context);
+    };
+  }
+};
+
 // src/CrdtManager.ts
 import { noop } from "@pluv/crdt";
 var CrdtManager = class {
@@ -179,6 +214,21 @@ var OtherNotifier = class {
   }
 };
 
+// src/PluvRouter.ts
+var PluvRouter = class _PluvRouter {
+  constructor(events) {
+    this._defs = { events: {} };
+    this._defs = { events };
+  }
+  static merge(...routers) {
+    const events = Object.assign(/* @__PURE__ */ 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(events);
+  }
+};
+
 // src/StateNotifier.ts
 import { makeSubject as makeSubject4, subscribe as subscribe4 } from "wonka";
 var StateNotifier = class {
@@ -317,7 +367,7 @@ var UsersManager = class {
   }
 };
 
-// src/types.ts
+// src/enums.ts
 var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
   ConnectionState2["Closed"] = "Closed";
   ConnectionState2["Connecting"] = "Connecting";
@@ -367,6 +417,7 @@ var PluvRoom = class extends AbstractRoom {
       metadata,
       onAuthorizationFail,
       presence,
+      router,
       wsEndpoint
     } = options;
     super(room);
@@ -400,17 +451,37 @@ var PluvRoom = class extends AbstractRoom {
     this._windowListeners = null;
     this._wsListeners = null;
     this.broadcast = new Proxy(
-      (event, data) => {
+      (event, data) => __async(this, null, function* () {
         if (!this._state.webSocket) return;
         if (this._state.connection.state !== "Open" /* Open */) return;
         const type = event.toString();
-        this._sendMessage({ data, type });
-      },
+        const procedure = this._router._defs.events[type];
+        if (!(procedure == null ? void 0 : 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 = {
+          doc: this._crdtManager.doc,
+          others: this._usersManager.getOthers(),
+          room: this.id,
+          user: myself
+        };
+        const output = yield procedure.config.broadcast(
+          parsed,
+          context
+        );
+        Object.entries(output).forEach(([_type, _data]) => {
+          this._sendMessage({ data: _data, type: _type });
+        });
+      }),
       {
         get(fn, prop) {
-          return (data) => {
-            return fn(prop, data);
-          };
+          return (data) => __async(this, null, function* () {
+            return yield fn(prop, data);
+          });
         }
       }
     );
@@ -485,7 +556,10 @@ var PluvRoom = class extends AbstractRoom {
       const myself = (_a = this._usersManager.myself) != null ? _a : null;
       this._stateNotifier.subjects["my-presence"].next(myPresence);
       !!myself && this._stateNotifier.subjects["myself"].next(myself);
-      this.broadcast("$UPDATE_PRESENCE", { presence: newPresence });
+      this.broadcast(
+        "$UPDATE_PRESENCE",
+        { presence: newPresence }
+      );
     };
     this._flattenStorageStore = debounce(
       () => __async(this, null, function* () {
@@ -517,6 +591,7 @@ var PluvRoom = class extends AbstractRoom {
         onAuthorizationFail == null ? void 0 : onAuthorizationFail(error);
       }
     };
+    this._router = router != null ? router : new PluvRouter({});
     this._usersManager = new UsersManager({ initialPresence, presence });
     this._crdtManager = new CrdtManager({ initialStorage });
   }
@@ -1085,9 +1160,11 @@ var PluvClient = class {
         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
       });
       this._rooms.set(room, newRoom);
@@ -1116,11 +1193,24 @@ var PluvClient = class {
       this._rooms.delete(toLeave.id);
       this._logDebug(`Left and deleted room: ${room}`);
     });
-    const { authEndpoint, debug = false, wsEndpoint } = options;
+    const { authEndpoint, debug = false, initialStorage, presence, wsEndpoint } = options;
     this._authEndpoint = authEndpoint;
     this._debug = debug;
+    this._initialStorage = initialStorage;
+    this._presence = presence;
     this._wsEndpoint = wsEndpoint;
   }
+  get _defs() {
+    return {
+      initialStorage: this._initialStorage
+    };
+  }
+  get procedure() {
+    return new PluvProcedure();
+  }
+  router(events) {
+    return new PluvRouter(events);
+  }
   _logDebug(...data) {
     var _a;
     if (((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.NODE_ENV) === "production") return;
@@ -1136,7 +1226,7 @@ var createClient = (options) => {
 // src/MockedRoom.ts
 var MockedRoom = class extends AbstractRoom {
   constructor(room, options) {
-    const { events, initialPresence, initialStorage, presence } = options;
+    const { events, initialPresence, initialStorage, presence, router } = options;
     super(room);
     this._crdtNotifier = new CrdtNotifier();
     this._eventNotifier = new EventNotifier();
@@ -1157,15 +1247,55 @@ var MockedRoom = class extends AbstractRoom {
     this._subscriptions = {
       observeCrdt: null
     };
+    this.broadcast = new Proxy(
+      (event, data) => __async(this, null, function* () {
+        if (!this._state.webSocket) return;
+        if (this._state.connection.state !== "Open" /* Open */) return;
+        const type = event.toString();
+        const procedure = this._router._defs.events[type];
+        if (!(procedure == null ? void 0 : procedure.config.broadcast)) {
+          this._simulateEvent(type, data);
+          return;
+        }
+        const myself = this._usersManager.myself;
+        if (!myself) return;
+        const parsed = procedure.config.input ? procedure.config.input.parse(data) : data;
+        const context = {
+          doc: this._crdtManager.doc,
+          others: this._usersManager.getOthers(),
+          room: this.id,
+          user: myself
+        };
+        const output = yield procedure.config.broadcast(
+          parsed,
+          context
+        );
+        Object.entries(output).forEach(([_type, _data]) => {
+          this._simulateEvent(_type, _data);
+        });
+      }),
+      {
+        get(fn, prop) {
+          return (data) => __async(this, null, function* () {
+            return yield fn(prop, data);
+          });
+        }
+      }
+    );
     this.canRedo = () => {
       return !!this._crdtManager.doc.canRedo();
     };
     this.canUndo = () => {
       return !!this._crdtManager.doc.canUndo();
     };
-    this.event = (event, callback) => {
-      return this._eventNotifier.subscribe(event, callback);
-    };
+    this.event = new Proxy(
+      (event, callback) => this._eventNotifier.subscribe(event, callback),
+      {
+        get(fn, prop) {
+          return (callback) => fn(prop, callback);
+        }
+      }
+    );
     this.getConnection = () => {
       return Object.freeze(JSON.parse(JSON.stringify(this._state.connection)));
     };
@@ -1224,6 +1354,7 @@ var MockedRoom = class extends AbstractRoom {
       !!myself && this._stateNotifier.subjects["myself"].next(myself);
     };
     this._events = events;
+    this._router = router != null ? router : new PluvRouter({});
     this._usersManager = new UsersManager({
       initialPresence,
       presence
@@ -1236,18 +1367,6 @@ var MockedRoom = class extends AbstractRoom {
   get storageLoaded() {
     return true;
   }
-  broadcast(event, data) {
-    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();
-      const data2 = result[_type];
-      if (!data2) return;
-      this._eventNotifier.subject(_type).next(data2);
-    });
-  }
   getDoc() {
     return this._crdtManager.doc;
   }
@@ -1279,6 +1398,19 @@ var MockedRoom = class extends AbstractRoom {
     });
     this._subscriptions.observeCrdt = unsubscribe;
   }
+  _simulateEvent(event, data) {
+    if (!this._events) return;
+    const type = event.toString();
+    const resolver = this._events[type];
+    if (!resolver) return;
+    const result = resolver(data);
+    Object.keys(result).forEach((type2) => {
+      const _type = type2.toString();
+      const data2 = result[_type];
+      if (!data2) return;
+      this._eventNotifier.subject(_type).next(data2);
+    });
+  }
 };
 export {
   AbstractRoom,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/client",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "description": "@pluv/io frontend client",
   "author": "leedavidcs",
   "license": "MIT",
@@ -18,15 +18,15 @@
   },
   "dependencies": {
     "wonka": "^6.3.4",
-    "@pluv/crdt": "^0.26.0",
-    "@pluv/types": "^0.26.0"
+    "@pluv/crdt": "^0.28.0",
+    "@pluv/types": "^0.28.0"
   },
   "devDependencies": {
     "eslint": "^8.57.0",
-    "tsup": "^8.2.4",
-    "typescript": "^5.5.4",
-    "@pluv/tsconfig": "^0.26.0",
-    "eslint-config-pluv": "^0.26.0"
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.2",
+    "@pluv/tsconfig": "^0.28.0",
+    "eslint-config-pluv": "^0.28.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/AbstractRoom.ts

@@ -2,6 +2,7 @@ import type { AbstractCrdtDoc, CrdtType, InferCrdtJson } from "@pluv/crdt";
 import type { IOLike, Id, InferIOInput, InferIOOutput, JsonObject } from "@pluv/types";
 import type { EventNotifierSubscriptionCallback } from "./EventNotifier";
 import type { OtherNotifierSubscriptionCallback } from "./OtherNotifier";
+import type { MergeEvents, PluvRouterEventConfig } from "./PluvRouter";
 import type { StateNotifierSubjects, SubscriptionCallback } from "./StateNotifier";
 import type { UpdateMyPresenceAction, UserInfo, WebSocketConnection } from "./types";
 
@@ -9,6 +10,7 @@ export abstract class AbstractRoom<
     TIO extends IOLike,
     TPresence extends JsonObject = {},
     TStorage extends Record<string, CrdtType<any, any>> = {},
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
 > {
     public readonly id: string;
 
@@ -18,9 +20,9 @@ export abstract class AbstractRoom<
 
     public abstract storageLoaded: boolean;
 
-    public abstract broadcast<TEvent extends keyof InferIOInput<TIO>>(
+    public abstract broadcast<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(
         event: TEvent,
-        data: Id<InferIOInput<TIO>[TEvent]>,
+        data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>,
     ): void;
 
     public abstract canRedo(): boolean;
@@ -29,9 +31,9 @@ export abstract class AbstractRoom<
 
     public abstract getDoc(): AbstractCrdtDoc<TStorage>;
 
-    public abstract event<TEvent extends keyof InferIOOutput<TIO>>(
+    public abstract event<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(
         event: TEvent,
-        callback: EventNotifierSubscriptionCallback<TIO, TEvent>,
+        callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>,
     ): () => void;
 
     public abstract getConnection(): WebSocketConnection;

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);
+        });
+    }
 }