@pluv/client 1.0.1 → 2.0.0

package/src/MockedRoom.ts

@@ -1,32 +1,40 @@
-import type { AbstractCrdtDoc, CrdtType, InferCrdtJson } from "@pluv/crdt";
-import type { IOLike, Id, InferIOInput, InferIOOutput, JsonObject } from "@pluv/types";
-import { AbstractRoom } from "./AbstractRoom";
+import type { AbstractCrdtDocFactory, CrdtType, InferCrdtJson, InferStorage } from "@pluv/crdt";
+import type {
+    CrdtDocLike,
+    EventNotifierSubscriptionCallback,
+    IOLike,
+    Id,
+    InferIOInput,
+    InferIOOutput,
+    JsonObject,
+    MergeEvents,
+    OtherNotifierSubscriptionCallback,
+    RoomLike,
+    UpdateMyPresenceAction,
+    UserInfo,
+    WebSocketState,
+} from "@pluv/types";
+import { ConnectionState } from "@pluv/types";
 import type { CrdtManagerOptions } from "./CrdtManager";
 import { CrdtManager } from "./CrdtManager";
 import { CrdtNotifier } from "./CrdtNotifier";
-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 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 { ConnectionState } from "./enums";
+import { MAX_PRESENCE_SIZE_BYTES } from "./constants";
 import type {
     EventResolver,
     EventResolverContext,
     InternalSubscriptions,
     PluvClientLimits,
-    UpdateMyPresenceAction,
-    UserInfo,
     WebSocketConnection,
-    WebSocketState,
 } from "./types";
-import { MAX_PRESENCE_SIZE_BYTES } from "./constants";
 
 export type MockedRoomEvents<TIO extends IOLike> = Partial<{
     [P in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[P]>) => Partial<InferIOOutput<TIO>>;
@@ -34,29 +42,32 @@ export type MockedRoomEvents<TIO extends IOLike> = Partial<{
 
 export type MockedRoomConfig<
     TIO extends IOLike,
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
+    TPresence extends JsonObject,
+    TCrdt extends AbstractCrdtDocFactory<any>,
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>>,
 > = {
     events?: MockedRoomEvents<MergeEvents<TEvents, TIO>>;
     limits?: PluvClientLimits;
-    router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
-} & Pick<CrdtManagerOptions<TStorage>, "initialStorage"> &
+    router?: PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
+} & Pick<CrdtManagerOptions<TCrdt>, "initialStorage"> &
     Omit<UsersManagerConfig<TPresence>, "limits">;
 
 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 readonly _crdtManager: CrdtManager<TStorage>;
-    private readonly _crdtNotifier = new CrdtNotifier<TStorage>();
+    TPresence extends JsonObject,
+    TCrdt extends AbstractCrdtDocFactory<any>,
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>>,
+> implements RoomLike<TIO, TPresence, InferStorage<TCrdt>>
+{
+    public readonly id: string;
+
+    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 _router: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+    private readonly _router: PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
     private _state: WebSocketState<TIO> = {
         authorization: {
             token: null,
@@ -76,10 +87,10 @@ export class MockedRoom<
     };
     private readonly _usersManager: UsersManager<TIO, TPresence>;
 
-    constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TStorage, TEvents>) {
+    constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TCrdt, TEvents>) {
         const { events, initialPresence, initialStorage, limits, presence, router } = options;
 
-        super(room);
+        this.id = room;
 
         this._events = events;
         this._limits = {
@@ -87,14 +98,15 @@ export class MockedRoom<
             ...limits,
         };
         this._router =
-            router ?? (new PluvRouter({}) as PluvRouter<TIO, TPresence, TStorage, TEvents>);
+            router ??
+            (new PluvRouter({}) as PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>);
         this._usersManager = new UsersManager<TIO, TPresence>({
             initialPresence,
             limits: this._limits,
             presence,
         });
 
-        this._crdtManager = new CrdtManager<TStorage>({
+        this._crdtManager = new CrdtManager<TCrdt>({
             initialStorage,
         });
 
@@ -120,7 +132,7 @@ export class MockedRoom<
                 any,
                 any,
                 TPresence,
-                TStorage
+                InferStorage<TCrdt>
             > | null;
 
             if (!procedure?.config.broadcast) {
@@ -134,7 +146,7 @@ export class MockedRoom<
             if (!myself) return;
 
             const parsed = procedure.config.input ? procedure.config.input.parse(data) : data;
-            const context: EventResolverContext<TIO, TPresence, TStorage> = {
+            const context: EventResolverContext<TIO, TPresence, InferStorage<TCrdt>> = {
                 doc: this._crdtManager.doc,
                 others: this._usersManager.getOthers(),
                 room: this.id,
@@ -142,7 +154,13 @@ export class MockedRoom<
             };
 
             const output = await (
-                procedure.config.broadcast as EventResolver<TIO, any, any, TPresence, TStorage>
+                procedure.config.broadcast as EventResolver<
+                    TIO,
+                    any,
+                    any,
+                    TPresence,
+                    InferStorage<TCrdt>
+                >
             )(parsed, context);
 
             Object.entries(output).forEach(([_type, _data]) => {
@@ -199,7 +217,7 @@ export class MockedRoom<
         return Object.freeze(JSON.parse(JSON.stringify(this._state.connection)));
     };
 
-    public getDoc(): AbstractCrdtDoc<TStorage> {
+    public getDoc(): CrdtDocLike<InferStorage<TCrdt>> {
         return this._crdtManager.doc;
     }
 
@@ -219,7 +237,9 @@ export class MockedRoom<
         return this._usersManager.getOthers();
     };
 
-    public getStorage = <TKey extends keyof TStorage>(type: TKey): TStorage[TKey] | null => {
+    public getStorage = <TKey extends keyof InferStorage<TCrdt>>(
+        type: TKey,
+    ): InferStorage<TCrdt>[TKey] | null => {
         const sharedType = this._crdtManager.get(type);
 
         if (typeof sharedType === "undefined") return null;
@@ -227,11 +247,11 @@ export class MockedRoom<
         return sharedType;
     };
 
-    public getStorageJson(): InferCrdtJson<TStorage> | null;
-    public getStorageJson<TKey extends keyof TStorage>(
+    public getStorageJson(): InferCrdtJson<InferStorage<TCrdt>> | null;
+    public getStorageJson<TKey extends keyof InferStorage<TCrdt>>(
         type: TKey,
-    ): InferCrdtJson<TStorage[TKey]> | null;
-    public getStorageJson<TKey extends keyof TStorage>(type?: TKey) {
+    ): 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();
@@ -254,16 +274,16 @@ export class MockedRoom<
         this._crdtManager.doc.redo();
     };
 
-    public storage = <TKey extends keyof TStorage>(
+    public storage = <TKey extends keyof InferStorage<TCrdt>>(
         key: TKey,
-        fn: (value: InferCrdtJson<TStorage[TKey]>) => void,
+        fn: (value: InferCrdtJson<InferStorage<TCrdt>[TKey]>) => void,
     ): (() => void) => {
         return this._crdtNotifier.subscribe(key, fn);
     };
 
     public storageRoot = (
         fn: (value: {
-            [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
+            [P in keyof InferStorage<TCrdt>]: InferCrdtJson<InferStorage<TCrdt>[P]>;
         }) => void,
     ): (() => void) => {
         return this._crdtNotifier.subcribeRoot(fn);
@@ -276,7 +296,7 @@ export class MockedRoom<
         return this._stateNotifier.subscribe(name, callback);
     };
 
-    public transact = (fn: (storage: TStorage) => void, origin?: string): void => {
+    public transact = (fn: (storage: InferStorage<TCrdt>) => void, origin?: string): void => {
         const _origin = origin ?? this._state.connection.id;
         const crdtManager = this._crdtManager;
 
@@ -338,7 +358,7 @@ export class MockedRoom<
                     return { ...acc, [prop]: serialized };
                 },
                 {} as {
-                    [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
+                    [P in keyof InferStorage<TCrdt>]: InferCrdtJson<InferStorage<TCrdt>[P]>;
                 },
             );
 

package/src/OtherNotifier.ts

@@ -1,11 +1,12 @@
-import type { Id, IOLike, JsonObject } from "@pluv/types";
+import type {
+    Id,
+    IOLike,
+    JsonObject,
+    OtherNotifierSubscriptionCallback,
+    UserInfo,
+} from "@pluv/types";
 import type { Subject } from "wonka";
 import { makeSubject, subscribe } from "wonka";
-import type { UserInfo } from "./types";
-
-export type OtherNotifierSubscriptionCallback<TIO extends IOLike, TPresence extends JsonObject> = (
-    value: Id<UserInfo<TIO, TPresence>> | null,
-) => void;
 
 export class OtherNotifier<TIO extends IOLike, TPresence extends JsonObject = {}> {
     private _subjects = new Map<

package/src/PluvClient.ts

@@ -1,4 +1,9 @@
-import type { AbstractCrdtDocFactory, CrdtType } from "@pluv/crdt";
+import type {
+    AbstractCrdtDocFactory,
+    CrdtType,
+    InferStorage,
+    NoopCrdtDocFactory,
+} from "@pluv/crdt";
 import type { InputZodLike, IOLike, JsonObject } from "@pluv/types";
 import { MAX_PRESENCE_SIZE_BYTES } from "./constants";
 import type { InferCallback } from "./infer";
@@ -20,11 +25,11 @@ import type { PluvClientLimits, PublicKey, WithMetadata } from "./types";
 export type PluvClientOptions<
     TIO extends IOLike<any, any>,
     TPresence extends JsonObject,
-    TStorage extends Record<string, CrdtType<any, any>>,
+    TCrdt extends AbstractCrdtDocFactory<any>,
     TMetadata extends JsonObject,
 > = RoomEndpoints<TIO, TMetadata> & {
     debug?: boolean;
-    initialStorage?: AbstractCrdtDocFactory<TStorage>;
+    initialStorage?: TCrdt;
     /**
      * @description Configurable limits defined for client-side validation. You should only set
      * this if you control the server and have changed the limits there.
@@ -39,17 +44,17 @@ export type PluvClientOptions<
 export type CreateRoomOptions<
     TIO extends IOLike<any, any>,
     TPresence extends JsonObject,
-    TStorage extends Record<string, CrdtType<any, any>>,
+    TCrdt extends AbstractCrdtDocFactory<any>,
     TMetadata extends JsonObject,
-    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>> = {},
 > = {
-    addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, TStorage>[];
+    addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, InferStorage<TCrdt>>[];
     debug?: boolean | PluvRoomDebug<TIO>;
     initialPresence?: TPresence;
-    initialStorage?: AbstractCrdtDocFactory<TStorage>;
+    initialStorage?: TCrdt;
     onAuthorizationFail?: (error: Error) => void;
     reconnectTimeoutMs?: ReconnectTimeoutMs;
-    router?: PluvRouter<TIO, TPresence, TStorage, TEvents>;
+    router?: PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
 };
 
 export type EnterRoomParams<TMetadata extends JsonObject = {}> = keyof TMetadata extends never
@@ -59,18 +64,18 @@ export type EnterRoomParams<TMetadata extends JsonObject = {}> = keyof TMetadata
 export class PluvClient<
     TIO extends IOLike<any, any>,
     TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
+    TCrdt extends AbstractCrdtDocFactory<any> = NoopCrdtDocFactory,
     TMetadata extends JsonObject = {},
 > {
     public readonly metadata?: InputZodLike<TMetadata>;
 
     private readonly _authEndpoint: AuthEndpoint<TMetadata> | undefined;
     private readonly _debug: boolean;
-    private readonly _initialStorage?: AbstractCrdtDocFactory<TStorage>;
+    private readonly _initialStorage?: TCrdt;
     private readonly _limits: PluvClientLimits;
     private readonly _presence?: InputZodLike<TPresence>;
     private readonly _publicKey: PublicKey<TMetadata> | null = null;
-    private readonly _rooms = new Map<string, PluvRoom<TIO, TMetadata, TPresence, TStorage, any>>();
+    private readonly _rooms = new Map<string, PluvRoom<TIO, TMetadata, TPresence, TCrdt, any>>();
     private readonly _wsEndpoint: WsEndpoint<TMetadata> | undefined;
 
     public get _defs() {
@@ -79,11 +84,11 @@ export class PluvClient<
         };
     }
 
-    public get procedure(): PluvProcedure<TIO, {}, {}, TPresence, TStorage> {
-        return new PluvProcedure<TIO, {}, {}, TPresence, TStorage>();
+    public get procedure(): PluvProcedure<TIO, {}, {}, TPresence, InferStorage<TCrdt>> {
+        return new PluvProcedure<TIO, {}, {}, TPresence, InferStorage<TCrdt>>();
     }
 
-    constructor(options: PluvClientOptions<TIO, TPresence, TStorage, TMetadata>) {
+    constructor(options: PluvClientOptions<TIO, TPresence, TCrdt, TMetadata>) {
         const {
             authEndpoint,
             debug = false,
@@ -110,20 +115,22 @@ export class PluvClient<
         if (!!publicKey) this._publicKey = publicKey;
     }
 
-    public createRoom = <TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}>(
+    public createRoom = <
+        TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>> = {},
+    >(
         room: string,
-        options: CreateRoomOptions<TIO, TPresence, TStorage, TMetadata, TEvents> = {},
-    ): PluvRoom<TIO, TMetadata, TPresence, TStorage, TEvents> => {
+        options: CreateRoomOptions<TIO, TPresence, TCrdt, TMetadata, TEvents> = {},
+    ): PluvRoom<TIO, TMetadata, TPresence, TCrdt, TEvents> => {
         const oldRoom = this.getRoom(room);
 
         if (oldRoom) return oldRoom;
 
-        const newRoom = new PluvRoom<TIO, TMetadata, TPresence, TStorage, TEvents>(room, {
+        const newRoom = new PluvRoom<TIO, TMetadata, TPresence, TCrdt, TEvents>(room, {
             addons: options.addons,
             authEndpoint: this._authEndpoint,
             debug: options.debug,
             initialPresence: options.initialPresence,
-            initialStorage: this._initialStorage,
+            initialStorage: options.initialStorage ?? this._initialStorage,
             limits: this._limits,
             metadata: this.metadata,
             onAuthorizationFail: options.onAuthorizationFail,
@@ -132,7 +139,7 @@ export class PluvClient<
             reconnectTimeoutMs: options.reconnectTimeoutMs,
             router: options.router,
             wsEndpoint: this._wsEndpoint,
-        } as RoomConfig<TIO, TMetadata, TPresence, TStorage, TEvents>);
+        } as RoomConfig<TIO, TMetadata, TPresence, TCrdt, TEvents>);
 
         this._rooms.set(room, newRoom);
 
@@ -144,7 +151,7 @@ export class PluvClient<
     public enter = async (
         room: string | PluvRoom<TIO, TMetadata, any, any, any>,
         ...args: EnterRoomParams<TMetadata>
-    ): Promise<PluvRoom<TIO, TMetadata, TPresence, TStorage, any>> => {
+    ): Promise<PluvRoom<TIO, TMetadata, TPresence, TCrdt, any>> => {
         const toEnter = typeof room === "string" ? this.getRoom(room) : room;
 
         if (!toEnter) throw new Error(`Could not find room: ${room}.`);
@@ -157,15 +164,15 @@ export class PluvClient<
         return toEnter;
     };
 
-    public getRoom = (room: string): PluvRoom<TIO, TMetadata, TPresence, TStorage, any> | null => {
+    public getRoom = (room: string): PluvRoom<TIO, TMetadata, TPresence, TCrdt, any> | null => {
         const found = this._rooms.get(room) as
-            | PluvRoom<TIO, TMetadata, TPresence, TStorage, any>
+            | PluvRoom<TIO, TMetadata, TPresence, TCrdt, any>
             | undefined;
 
         return found ?? null;
     };
 
-    public getRooms = (): readonly PluvRoom<TIO, TMetadata, TPresence, TStorage, any>[] => {
+    public getRooms = (): readonly PluvRoom<TIO, TMetadata, TPresence, TCrdt, any>[] => {
         return Array.from(this._rooms.values());
     };
 
@@ -181,20 +188,21 @@ export class PluvClient<
         this._logDebug(`Left and deleted room: ${room}`);
     };
 
-    public router<TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {}>(
+    public router<TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>> = {}>(
         events: TEvents,
-    ): PluvRouter<TIO, TPresence, TStorage, TEvents> {
+    ): PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents> {
         const invalidName = Object.keys(events).find((name) => name.includes("$"));
 
         if (typeof invalidName === "string") {
             throw new Error(`Invalid event name. Event names must not contain $: "${invalidName}"`);
         }
 
-        return new PluvRouter<TIO, TPresence, TStorage, TEvents>(events);
+        return new PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>(events);
     }
 
     private _logDebug(...data: any[]): void {
-        if (process?.env?.NODE_ENV === "production") return;
+        if (typeof process === "undefined") return;
+        if (process.env?.NODE_ENV === "production") return;
 
         if (this._debug) console.log(...data);
     }

package/src/PluvProcedure.ts

@@ -20,7 +20,8 @@ export class PluvProcedure<
     TPresence extends JsonObject = {},
     TStorage extends Record<string, CrdtType<any, any>> = {},
     TFilled extends "input" | "broadcast" | "" = "",
-> {
+> implements ProcedureLike<TInput, TOutput>
+{
     private _broadcast: EventResolver<TIO, TInput, Partial<TOutput>, TPresence, TStorage> | null =
         null;
     private _input: InputZodLike<TInput> | null = null;