@pluv/client 2.0.2 → 2.2.0

package/src/CrdtManager.ts

@@ -1,7 +1,7 @@
-import type { AbstractCrdtDocFactory, CrdtDocLike, CrdtType, InferStorage } from "@pluv/crdt";
+import type { AbstractCrdtDocFactory, InferDocLike, InferStorage } from "@pluv/crdt";
 import { noop } from "@pluv/crdt";
 
-export type CrdtManagerOptions<TCrdt extends AbstractCrdtDocFactory<any>> = {
+export type CrdtManagerOptions<TCrdt extends AbstractCrdtDocFactory<any, any>> = {
     initialStorage?: TCrdt;
 };
 
@@ -15,8 +15,8 @@ interface ApplyUpdateParams {
     update: string | readonly string[];
 }
 
-export class CrdtManager<TCrdt extends AbstractCrdtDocFactory<any>> {
-    public doc: CrdtDocLike<InferStorage<TCrdt>>;
+export class CrdtManager<TCrdt extends AbstractCrdtDocFactory<any, any>> {
+    public doc: InferDocLike<TCrdt>;
     public initialized: boolean = false;
 
     private readonly _docFactory: TCrdt;
@@ -25,7 +25,7 @@ export class CrdtManager<TCrdt extends AbstractCrdtDocFactory<any>> {
         const { initialStorage = noop.doc({}) as any } = options;
 
         this._docFactory = initialStorage;
-        this.doc = initialStorage.getEmpty();
+        this.doc = this._docFactory.getEmpty() as InferDocLike<TCrdt>;
     }
 
     /**
@@ -49,7 +49,7 @@ export class CrdtManager<TCrdt extends AbstractCrdtDocFactory<any>> {
     public destroy(): void {
         this.initialized = false;
         this.doc.destroy();
-        this.doc = this._docFactory.getEmpty();
+        this.doc = this._docFactory.getEmpty() as InferDocLike<TCrdt>;
     }
 
     public get<TKey extends keyof InferStorage<TCrdt>>(key: TKey): InferStorage<TCrdt>[TKey] {
@@ -94,11 +94,7 @@ export class CrdtManager<TCrdt extends AbstractCrdtDocFactory<any>> {
         const initialized = this._docFactory.getInitialized();
         const reference = initialized.get();
 
-        this.doc = this._applyDocUpdates(
-            this._docFactory.getEmpty(),
-            updates,
-            origin,
-        ).rebuildStorage(reference);
+        this.doc = this._applyDocUpdates(this.doc, updates, origin).rebuildStorage(reference);
         this.initialized = true;
         initialized.destroy();
 
@@ -110,10 +106,10 @@ export class CrdtManager<TCrdt extends AbstractCrdtDocFactory<any>> {
     }
 
     private _applyDocUpdates(
-        doc: CrdtDocLike<InferStorage<TCrdt>>,
+        doc: InferDocLike<TCrdt>,
         updates: readonly string[],
         origin?: string,
-    ): CrdtDocLike<InferStorage<TCrdt>> {
+    ): InferDocLike<TCrdt> {
         doc.transact(() => {
             doc.batchApplyEncodedState({ origin, updates });
         }, origin);

package/src/CrdtNotifier.ts

@@ -1,4 +1,5 @@
 import type { CrdtType, InferCrdtJson } from "@pluv/crdt";
+import type { StorageSubscriptionCallback } from "@pluv/types";
 import type { Subject } from "wonka";
 import { makeSubject, subscribe } from "wonka";
 
@@ -36,7 +37,7 @@ export class CrdtNotifier<TStorage extends Record<string, CrdtType<any, any>>> {
 
     public subscribe<TKey extends keyof TStorage>(
         key: TKey,
-        callback: (value: InferCrdtJson<TStorage[TKey]>) => void,
+        callback: StorageSubscriptionCallback<TStorage, TKey>,
     ): () => void {
         const subject = this.subject(key);
 

package/src/ListenerManager.ts

@@ -0,0 +1,21 @@
+import { makeSubject, subscribe, TypeOfSource } from "wonka";
+
+export class ListenerManager {
+    public subjects = {
+        close: makeSubject<CloseEvent>(),
+        error: makeSubject<Event>(),
+        message: makeSubject<MessageEvent<any>>(),
+        open: makeSubject<Event>(),
+    };
+
+    public subscribe<TKind extends keyof typeof this.subjects>(
+        kind: TKind,
+        callback: (event: TypeOfSource<(typeof this.subjects)[TKind]["source"]>) => void,
+    ): () => void {
+        const source = this.subjects[kind]?.source;
+
+        if (!source) return () => undefined;
+
+        return subscribe(callback)(source as any).unsubscribe;
+    }
+}

package/src/MockedRoom.ts

@@ -1,39 +1,53 @@
-import type { AbstractCrdtDocFactory, CrdtType, InferCrdtJson, InferStorage } from "@pluv/crdt";
 import type {
+    AbstractCrdtDocFactory,
+    InferCrdtJson,
+    InferDoc,
+    InferDocLike,
+    InferStorage,
+} from "@pluv/crdt";
+import type {
+    BroadcastProxy,
     CrdtDocLike,
     EventNotifierSubscriptionCallback,
+    EventProxy,
     IOLike,
     Id,
     InferIOInput,
     InferIOOutput,
-    JsonObject,
     MergeEvents,
-    OtherNotifierSubscriptionCallback,
+    OtherSubscriptionCallback,
+    OthersSubscriptionCallback,
+    RoomEventListenerMap,
     RoomLike,
+    StateNotifierSubjects,
+    StorageProxy,
+    StorageRootSubscriptionCallback,
+    StorageSubscriptionCallback,
+    SubscribeProxy,
+    SubscriptionCallback,
     UpdateMyPresenceAction,
     UserInfo,
+    WebSocketConnection,
     WebSocketState,
 } from "@pluv/types";
-import { ConnectionState } from "@pluv/types";
+import { ConnectionState, StorageState } from "@pluv/types";
 import type { CrdtManagerOptions } from "./CrdtManager";
 import { CrdtManager } from "./CrdtManager";
 import { CrdtNotifier } from "./CrdtNotifier";
 import { EventNotifier } from "./EventNotifier";
-import { OtherNotifier } from "./OtherNotifier";
 import { PluvProcedure } from "./PluvProcedure";
 import type { 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 { UsersNotifier } from "./UsersNotifier";
 import { MAX_PRESENCE_SIZE_BYTES } from "./constants";
 import type {
     EventResolver,
     EventResolverContext,
     InternalSubscriptions,
     PluvClientLimits,
-    WebSocketConnection,
 } from "./types";
 
 export type MockedRoomEvents<TIO extends IOLike> = Partial<{
@@ -42,8 +56,8 @@ export type MockedRoomEvents<TIO extends IOLike> = Partial<{
 
 export type MockedRoomConfig<
     TIO extends IOLike,
-    TPresence extends JsonObject,
-    TCrdt extends AbstractCrdtDocFactory<any>,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
     TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>>,
 > = {
     events?: MockedRoomEvents<MergeEvents<TEvents, TIO>>;
@@ -54,19 +68,24 @@ export type MockedRoomConfig<
 
 export class MockedRoom<
     TIO extends IOLike,
-    TPresence extends JsonObject,
-    TCrdt extends AbstractCrdtDocFactory<any>,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
     TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>>,
-> implements RoomLike<TIO, TPresence, InferStorage<TCrdt>>
+> implements RoomLike<TIO, InferDoc<TCrdt>, TPresence, InferStorage<TCrdt>>
 {
     public readonly id: string;
 
+    /**
+     * @deprecated To be removed in v3. Use `getStorageLoaded` instead.
+     */
+    public readonly storageLoaded: boolean = true;
+
     private readonly _crdtManager: CrdtManager<TCrdt>;
     private readonly _crdtNotifier = new CrdtNotifier<InferStorage<TCrdt>>();
     private readonly _eventNotifier = new EventNotifier<MergeEvents<TEvents, TIO>>();
     private readonly _events?: MockedRoomEvents<MergeEvents<TEvents, TIO>>;
     private readonly _limits: PluvClientLimits;
-    private readonly _otherNotifier = new OtherNotifier<TIO, TPresence>();
+    private readonly _usersNotifier = new UsersNotifier<TIO, TPresence>();
     private readonly _router: PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
     private _state: WebSocketState<TIO> = {
         authorization: {
@@ -75,10 +94,12 @@ export class MockedRoom<
         },
         connection: {
             attempts: 0,
-            count: 1,
             id: null,
             state: ConnectionState.Untouched,
         },
+        storage: {
+            state: StorageState.Unavailable,
+        },
         webSocket: null,
     };
     private readonly _stateNotifier = new StateNotifier<TIO, TPresence>();
@@ -113,8 +134,11 @@ export class MockedRoom<
         this._observeCrdt();
     }
 
-    public get storageLoaded(): boolean {
-        return true;
+    public addEventListener<TKind extends keyof RoomEventListenerMap>(
+        kind: TKind,
+        handler: RoomEventListenerMap[TKind],
+    ): () => void {
+        return () => undefined;
     }
 
     public broadcast = new Proxy(
@@ -132,7 +156,8 @@ export class MockedRoom<
                 any,
                 any,
                 TPresence,
-                InferStorage<TCrdt>
+                TCrdt,
+                ""
             > | null;
 
             if (!procedure?.config.broadcast) {
@@ -146,7 +171,7 @@ export class MockedRoom<
             if (!myself) return;
 
             const parsed = procedure.config.input ? procedure.config.input.parse(data) : data;
-            const context: EventResolverContext<TIO, TPresence, InferStorage<TCrdt>> = {
+            const context: EventResolverContext<TIO, TPresence, InferDocLike<TCrdt>> = {
                 doc: this._crdtManager.doc,
                 others: this._usersManager.getOthers(),
                 room: this.id,
@@ -176,12 +201,7 @@ export class MockedRoom<
                 };
             },
         },
-    ) 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>;
-    };
+    ) as BroadcastProxy<TIO, TEvents>;
 
     public canRedo = (): boolean => {
         return !!this._crdtManager.doc.canRedo();
@@ -203,21 +223,14 @@ export class MockedRoom<
                 ): (() => void) => fn(prop as any, callback);
             },
         },
-    ) as (<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(
-        event: TEvent,
-        callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>,
-    ) => () => void) & {
-        [event in keyof InferIOOutput<MergeEvents<TEvents, TIO>>]: (
-            callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, any>,
-        ) => () => void;
-    };
+    ) as EventProxy<TIO, TEvents>;
 
     public getConnection = (): WebSocketConnection => {
         // Create a read-only clone of the connection state
         return Object.freeze(JSON.parse(JSON.stringify(this._state.connection)));
     };
 
-    public getDoc(): CrdtDocLike<InferStorage<TCrdt>> {
+    public getDoc(): CrdtDocLike<InferDoc<TCrdt>, InferStorage<TCrdt>> {
         return this._crdtManager.doc;
     }
 
@@ -253,33 +266,51 @@ export class MockedRoom<
     ): InferCrdtJson<InferStorage<TCrdt>[TKey]> | null;
     public getStorageJson<TKey extends keyof InferStorage<TCrdt>>(type?: TKey) {
         if (this._state.connection.id === null) return null;
-
         if (typeof type === "undefined") return this._crdtManager.doc.toJson();
 
         return this._crdtManager.doc.toJson(type);
     }
 
+    public getStorageLoaded(): boolean {
+        return true;
+    }
+
     public other = (
         connectionId: string,
-        callback: OtherNotifierSubscriptionCallback<TIO, TPresence>,
+        callback: OtherSubscriptionCallback<TIO, TPresence>,
     ): (() => void) => {
         const clientId = this._usersManager.getClientId(connectionId);
 
         if (!clientId) return () => undefined;
 
-        return this._otherNotifier.subscribe(clientId, callback);
+        return this._usersNotifier.subscribeOther(clientId, callback);
     };
 
     public redo = (): void => {
         this._crdtManager.doc.redo();
     };
 
-    public storage = <TKey extends keyof InferStorage<TCrdt>>(
-        key: TKey,
-        fn: (value: InferCrdtJson<InferStorage<TCrdt>[TKey]>) => void,
-    ): (() => void) => {
-        return this._crdtNotifier.subscribe(key, fn);
-    };
+    public storage = new Proxy(
+        <TKey extends keyof InferStorage<TCrdt>>(
+            key: TKey,
+            callback: StorageSubscriptionCallback<InferStorage<TCrdt>, TKey>,
+        ): (() => void) => this._crdtNotifier.subscribe(key, callback),
+        {
+            get: (fn, prop) => {
+                type _Storage = InferStorage<TCrdt>;
+
+                if (!!prop) {
+                    return (callback: StorageRootSubscriptionCallback<_Storage>) => {
+                        return this._crdtNotifier.subcribeRoot(callback);
+                    };
+                }
+
+                return (callback: StorageSubscriptionCallback<_Storage, keyof _Storage>) => {
+                    return fn(prop as keyof InferStorage<TCrdt>, callback);
+                };
+            },
+        },
+    ) as StorageProxy<InferStorage<TCrdt>>;
 
     public storageRoot = (
         fn: (value: {
@@ -289,12 +320,51 @@ export class MockedRoom<
         return this._crdtNotifier.subcribeRoot(fn);
     };
 
-    public subscribe = <TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(
-        name: TSubject,
-        callback: SubscriptionCallback<TIO, TPresence, TSubject>,
-    ): (() => void) => {
-        return this._stateNotifier.subscribe(name, callback);
-    };
+    public subscribe = new Proxy(
+        <TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(
+            name: TSubject,
+            callback: SubscriptionCallback<TIO, TPresence, TSubject>,
+        ): (() => void) => {
+            return this._stateNotifier.subscribe(name, callback);
+        },
+        {
+            get: (fn, prop) => {
+                if (prop === "connection") {
+                    return (callback: SubscriptionCallback<TIO, TPresence, "connection">) => {
+                        return fn("connection", callback);
+                    };
+                }
+
+                if (prop === "myPresence") {
+                    return (callback: SubscriptionCallback<TIO, TPresence, "my-presence">) => {
+                        return fn("my-presence", callback);
+                    };
+                }
+
+                if (prop === "myself") {
+                    return (callback: SubscriptionCallback<TIO, TPresence, "myself">) => {
+                        return fn("myself", callback);
+                    };
+                }
+
+                if (prop === "others") {
+                    return (callback: OthersSubscriptionCallback<TIO, TPresence>) => {
+                        return this._usersNotifier.subscribeOthers(callback);
+                    };
+                }
+
+                if (prop === "storageLoaded") {
+                    return (callback: SubscriptionCallback<TIO, TPresence, "storage-loaded">) => {
+                        return fn("storage-loaded", callback);
+                    };
+                }
+
+                if (prop === "event") return this.event;
+                if (prop === "other") return this.other;
+                if (prop === "storage") return this.storage;
+            },
+        },
+    ) as SubscribeProxy<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
 
     public transact = (fn: (storage: InferStorage<TCrdt>) => void, origin?: string): void => {
         const _origin = origin ?? this._state.connection.id;

package/src/PluvClient.ts

@@ -24,8 +24,8 @@ import type { PluvClientLimits, PublicKey, WithMetadata } from "./types";
 
 export type PluvClientOptions<
     TIO extends IOLike<any, any>,
-    TPresence extends JsonObject,
-    TCrdt extends AbstractCrdtDocFactory<any>,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
     TMetadata extends JsonObject,
 > = RoomEndpoints<TIO, TMetadata> & {
     debug?: boolean;
@@ -43,8 +43,8 @@ export type PluvClientOptions<
 
 export type CreateRoomOptions<
     TIO extends IOLike<any, any>,
-    TPresence extends JsonObject,
-    TCrdt extends AbstractCrdtDocFactory<any>,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
     TMetadata extends JsonObject,
     TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>> = {},
 > = {
@@ -63,8 +63,8 @@ export type EnterRoomParams<TMetadata extends JsonObject = {}> = keyof TMetadata
 
 export class PluvClient<
     TIO extends IOLike<any, any>,
-    TPresence extends JsonObject = {},
-    TCrdt extends AbstractCrdtDocFactory<any> = NoopCrdtDocFactory,
+    TPresence extends Record<string, any> = {},
+    TCrdt extends AbstractCrdtDocFactory<any, any> = NoopCrdtDocFactory,
     TMetadata extends JsonObject = {},
 > {
     public readonly metadata?: InputZodLike<TMetadata>;
@@ -84,8 +84,8 @@ export class PluvClient<
         };
     }
 
-    public get procedure(): PluvProcedure<TIO, {}, {}, TPresence, InferStorage<TCrdt>> {
-        return new PluvProcedure<TIO, {}, {}, TPresence, InferStorage<TCrdt>>();
+    public get procedure(): PluvProcedure<TIO, {}, {}, TPresence, TCrdt, ""> {
+        return new PluvProcedure<TIO, {}, {}, TPresence, TCrdt, "">();
     }
 
     constructor(options: PluvClientOptions<TIO, TPresence, TCrdt, TMetadata>) {

package/src/PluvProcedure.ts

@@ -1,29 +1,34 @@
-import type { CrdtType } from "@pluv/crdt";
+import type { AbstractCrdtDocFactory, InferDocLike } 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>> = {},
+    TIO extends IOLike,
+    TInput extends JsonObject,
+    TOutput extends EventRecord<string, any>,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
 > {
-    broadcast?: EventResolver<TIO, TInput, TOutput, TPresence, TStorage> | null;
+    broadcast?: EventResolver<TIO, TInput, TOutput, TPresence, InferDocLike<TCrdt>> | 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" | "" = "",
+    TIO extends IOLike,
+    TInput extends JsonObject,
+    TOutput extends EventRecord<string, any>,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
+    TFilled extends "input" | "broadcast" | "",
 > implements ProcedureLike<TInput, TOutput>
 {
-    private _broadcast: EventResolver<TIO, TInput, Partial<TOutput>, TPresence, TStorage> | null =
-        null;
+    private _broadcast: EventResolver<
+        TIO,
+        TInput,
+        Partial<TOutput>,
+        TPresence,
+        InferDocLike<TCrdt>
+    > | null = null;
     private _input: InputZodLike<TInput> | null = null;
 
     public get config(): ProcedureLike<TInput, TOutput>["config"] {
@@ -34,7 +39,7 @@ export class PluvProcedure<
         } as ProcedureLike<TInput, TOutput>["config"];
     }
 
-    constructor(config: PluvProcedureConfig<TIO, TInput, TOutput, TPresence, TStorage> = {}) {
+    constructor(config: PluvProcedureConfig<TIO, TInput, TOutput, TPresence, TCrdt> = {}) {
         const { broadcast, input } = config;
 
         this._broadcast = broadcast ?? null;
@@ -42,14 +47,14 @@ export class PluvProcedure<
     }
 
     public broadcast<TResult extends EventRecord<string, any> = {}>(
-        resolver: EventResolver<TIO, TInput, TResult, TPresence, TStorage>,
+        resolver: EventResolver<TIO, TInput, TResult, TPresence, InferDocLike<TCrdt>>,
     ): Omit<
         PluvProcedure<
             TIO,
             TInput,
             MergeEventRecords<[TOutput, TResult]>,
             TPresence,
-            TStorage,
+            TCrdt,
             TFilled | "input" | "broadcast"
         >,
         TFilled | "input" | "broadcast"
@@ -63,7 +68,7 @@ export class PluvProcedure<
             TInput,
             MergeEventRecords<[TOutput, TResult]>,
             TPresence,
-            TStorage,
+            TCrdt,
             TFilled | "input" | "broadcast"
         >({
             ...(this.config as any),
@@ -73,14 +78,11 @@ export class PluvProcedure<
 
     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 });
+    ): Omit<PluvProcedure<TIO, TData, {}, TPresence, TCrdt, TFilled | "input">, TFilled | "input"> {
+        return new PluvProcedure<TIO, TData, {}, TPresence, TCrdt, TFilled | "input">({ input });
     }
 
-    private _resolver(): EventResolver<TIO, TInput, TOutput, TPresence, TStorage> {
+    private _resolver(): EventResolver<TIO, TInput, TOutput, TPresence, InferDocLike<TCrdt>> {
         return (data, context) => this._broadcast?.(data, context) as TOutput;
     }
 }