@pluv/client 5.0.1 → 5.0.3

package/src/MockedRoom.ts

@@ -1,457 +0,0 @@
-import type {
-    AbstractCrdtDocFactory,
-    InferCrdtJson,
-    InferDoc,
-    InferDocLike,
-    InferStorage,
-} from "@pluv/crdt";
-import type {
-    BroadcastProxy,
-    CrdtDocLike,
-    EventNotifierSubscriptionCallback,
-    EventProxy,
-    IOLike,
-    Id,
-    InferIOInput,
-    InferIOOutput,
-    MergeEvents,
-    OtherSubscriptionCallback,
-    OthersSubscriptionCallback,
-    RoomEventListenerMap,
-    RoomLike,
-    StateNotifierSubjects,
-    StorageProxy,
-    StorageRootSubscriptionCallback,
-    StorageSubscriptionCallback,
-    SubscribeProxy,
-    SubscriptionCallback,
-    UpdateMyPresenceAction,
-    UserInfo,
-    WebSocketConnection,
-    WebSocketState,
-} 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 { PluvProcedure } from "./PluvProcedure";
-import type { PluvRouterEventConfig } from "./PluvRouter";
-import { PluvRouter } from "./PluvRouter";
-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,
-} from "./types";
-
-export type MockedRoomEvents<TIO extends IOLike> = Partial<{
-    [P in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[P]>) => Partial<InferIOOutput<TIO>>;
-}>;
-
-export type MockedRoomConfig<
-    TIO extends IOLike,
-    TPresence extends Record<string, any>,
-    TCrdt extends AbstractCrdtDocFactory<any, any>,
-    TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>>,
-> = {
-    events?: MockedRoomEvents<MergeEvents<TEvents, TIO>>;
-    limits?: PluvClientLimits;
-    router?: PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
-} & Pick<CrdtManagerOptions<TCrdt>, "initialStorage"> &
-    Omit<UsersManagerConfig<TPresence>, "limits">;
-
-export class MockedRoom<
-    TIO extends IOLike,
-    TPresence extends Record<string, any>,
-    TCrdt extends AbstractCrdtDocFactory<any, any>,
-    TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>>,
-> implements RoomLike<TIO, InferDoc<TCrdt>, 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 _usersNotifier = new UsersNotifier<TIO, TPresence>();
-    private readonly _router: PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
-    private _state: WebSocketState<TIO> = {
-        authorization: {
-            token: null,
-            user: null,
-        },
-        connection: {
-            attempts: 0,
-            id: null,
-            state: ConnectionState.Untouched,
-        },
-        storage: {
-            state: StorageState.Unavailable,
-        },
-        webSocket: null,
-    };
-    private readonly _stateNotifier = new StateNotifier<TIO, TPresence>();
-    private readonly _subscriptions: InternalSubscriptions = {
-        observeCrdt: null,
-    };
-    private readonly _usersManager: UsersManager<TIO, TPresence>;
-
-    constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TCrdt, TEvents>) {
-        const { events, initialPresence, initialStorage, limits, presence, router } = options;
-
-        this.id = room;
-
-        this._events = events;
-        this._limits = {
-            presenceMaxSize: MAX_PRESENCE_SIZE_BYTES,
-            ...limits,
-        };
-        this._router =
-            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<TCrdt>({
-            initialStorage,
-        });
-
-        this._observeCrdt();
-    }
-
-    public addEventListener<TKind extends keyof RoomEventListenerMap>(
-        kind: TKind,
-        handler: RoomEventListenerMap[TKind],
-    ): () => void {
-        return () => undefined;
-    }
-
-    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,
-                TCrdt,
-                ""
-            > | 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, InferDocLike<TCrdt>> = {
-                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,
-                    InferStorage<TCrdt>
-                >
-            )(parsed, context);
-
-            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 BroadcastProxy<TIO, TEvents>;
-
-    public canRedo = (): boolean => {
-        return !!this._crdtManager.doc.canRedo();
-    };
-
-    public canUndo = (): boolean => {
-        return !!this._crdtManager.doc.canUndo();
-    };
-
-    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<InferDoc<TCrdt>, InferStorage<TCrdt>> {
-        return this._crdtManager.doc;
-    }
-
-    public getMyPresence = (): TPresence => {
-        return this._usersManager.myPresence;
-    };
-
-    public getMyself = (): Id<UserInfo<TIO, TPresence>> | null => {
-        return this._usersManager.myself;
-    };
-
-    public getOther = (connectionId: string): Id<UserInfo<TIO, TPresence>> | null => {
-        return this._usersManager.getOther(connectionId);
-    };
-
-    public getOthers = (): readonly Id<UserInfo<TIO, TPresence>>[] => {
-        return this._usersManager.getOthers();
-    };
-
-    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;
-
-        return sharedType;
-    };
-
-    public getStorageJson(): InferCrdtJson<InferStorage<TCrdt>> | null;
-    public getStorageJson<TKey extends keyof InferStorage<TCrdt>>(
-        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();
-
-        return this._crdtManager.doc.toJson(type);
-    }
-
-    public getStorageLoaded(): boolean {
-        return true;
-    }
-
-    public redo = (): void => {
-        this._crdtManager.doc.redo();
-    };
-
-    public storageRoot = (
-        fn: (value: {
-            [P in keyof InferStorage<TCrdt>]: InferCrdtJson<InferStorage<TCrdt>[P]>;
-        }) => void,
-    ): (() => void) => {
-        return this._crdtNotifier.subcribeRoot(fn);
-    };
-
-    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;
-        const crdtManager = this._crdtManager;
-
-        /**
-         * !HACK
-         * @description Don't transact anything if there is no origin, because
-         * that means the user isn't connected yet. This will mean events are
-         * lost unfortunately.
-         * @date September 23, 2023
-         */
-        if (typeof _origin !== "string") return;
-        if (!crdtManager) return;
-
-        crdtManager.doc.transact(() => {
-            const storage = crdtManager.doc.get();
-
-            fn(storage);
-        }, _origin);
-    };
-
-    public undo = (): void => {
-        this._crdtManager.doc.undo();
-    };
-
-    public updateMyPresence = (presence: UpdateMyPresenceAction<TPresence>): void => {
-        const newPresence =
-            typeof presence === "function" ? presence(this.getMyPresence()) : presence;
-
-        this._usersManager.updateMyPresence(newPresence);
-
-        const myPresence = this._usersManager.myPresence;
-        const myself = this._usersManager.myself ?? null;
-
-        this._stateNotifier.subjects["my-presence"].next(myPresence);
-        if (!!myself) this._stateNotifier.subjects["myself"].next(myself);
-    };
-
-    private _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 EventProxy<TIO, TEvents>;
-
-    private _observeCrdt(): void {
-        this._subscriptions.observeCrdt?.();
-
-        if (!this._crdtManager) return;
-
-        const unsubscribe = this._crdtManager.doc.subscribe((event) => {
-            const origin = event.origin ?? null;
-
-            if (!this._crdtManager) return;
-            if (origin === "$storageUpdated") return;
-
-            const sharedTypes = this._crdtManager.doc.get();
-
-            const storageRoot = Object.keys(sharedTypes).reduce(
-                (acc, prop) => {
-                    if (!this._crdtManager) return acc;
-
-                    const serialized = this._crdtManager.doc.toJson(prop);
-
-                    this._crdtNotifier.subject(prop).next(serialized);
-
-                    return { ...acc, [prop]: serialized };
-                },
-                {} as {
-                    [P in keyof InferStorage<TCrdt>]: InferCrdtJson<InferStorage<TCrdt>[P]>;
-                },
-            );
-
-            this._crdtNotifier.rootSubject.next(storageRoot);
-        });
-
-        this._subscriptions.observeCrdt = unsubscribe;
-    }
-
-    private _other = (
-        connectionId: string,
-        callback: OtherSubscriptionCallback<TIO, TPresence>,
-    ): (() => void) => {
-        const clientId = this._usersManager.getClientId(connectionId);
-
-        if (!clientId) return () => undefined;
-
-        return this._usersNotifier.subscribeOther(clientId, callback);
-    };
-
-    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);
-        });
-    }
-
-    #_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>>;
-}

package/src/PluvClient.ts

@@ -1,204 +0,0 @@
-import type { AbstractCrdtDocFactory, InferStorage, NoopCrdtDocFactory } from "@pluv/crdt";
-import type { InferIOCrdtKind, InputZodLike, IOLike, JsonObject } from "@pluv/types";
-import { MAX_PRESENCE_SIZE_BYTES } from "./constants";
-import type { InferCallback } from "./infer";
-import { PluvProcedure } from "./PluvProcedure";
-import type {
-    AuthEndpoint,
-    PluvRoomAddon,
-    PluvRoomDebug,
-    ReconnectTimeoutMs,
-    RoomConfig,
-    RoomEndpoints,
-    WsEndpoint,
-} from "./PluvRoom";
-import { PluvRoom } from "./PluvRoom";
-import type { PluvRouterEventConfig } from "./PluvRouter";
-import { PluvRouter } from "./PluvRouter";
-import type { PluvClientLimits, PublicKey, WithMetadata } from "./types";
-
-export type PluvClientOptions<
-    TIO extends IOLike<any, any, any>,
-    TPresence extends Record<string, any>,
-    TCrdt extends InferIOCrdtKind<TIO>,
-    TMetadata extends JsonObject,
-> = RoomEndpoints<TIO, TMetadata> & {
-    debug?: boolean;
-    /**
-     * @description Configurable limits defined for client-side validation. You should only set
-     * this if you control the server and have changed the limits there.
-     */
-    limits?: PluvClientLimits;
-    metadata?: InputZodLike<TMetadata>;
-    presence?: InputZodLike<TPresence>;
-    publicKey?: PublicKey<TMetadata>;
-    types: InferCallback<TIO>;
-} & (InferIOCrdtKind<TIO> extends NoopCrdtDocFactory
-        ? { initialStorage?: "[ERROR]: Must provide crdt to createIO to use storage" }
-        : { initialStorage?: TCrdt });
-
-export type CreateRoomOptions<
-    TIO extends IOLike<any, any, any>,
-    TPresence extends Record<string, any>,
-    TCrdt extends AbstractCrdtDocFactory<any, any>,
-    TMetadata extends JsonObject,
-    TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>> = {},
-> = {
-    addons?: readonly PluvRoomAddon<TIO, TMetadata, TPresence, InferStorage<TCrdt>>[];
-    debug?: boolean | PluvRoomDebug<TIO>;
-    initialPresence?: TPresence;
-    initialStorage?: TCrdt;
-    onAuthorizationFail?: (error: Error) => void;
-    reconnectTimeoutMs?: ReconnectTimeoutMs;
-    router?: PluvRouter<TIO, TPresence, InferStorage<TCrdt>, TEvents>;
-};
-
-export type EnterRoomParams<TMetadata extends JsonObject = {}> = keyof TMetadata extends never
-    ? []
-    : [WithMetadata<TMetadata>];
-
-export class PluvClient<
-    TIO extends IOLike<any, any, any>,
-    TPresence extends Record<string, any> = {},
-    TCrdt extends InferIOCrdtKind<TIO> = InferIOCrdtKind<TIO>,
-    TMetadata extends JsonObject = {},
-> {
-    public readonly metadata?: InputZodLike<TMetadata>;
-
-    private readonly _authEndpoint: AuthEndpoint<TMetadata> | undefined;
-    private readonly _debug: boolean;
-    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, TCrdt, any>>();
-    private readonly _wsEndpoint: WsEndpoint<TMetadata> | undefined;
-
-    public get _defs() {
-        return {
-            initialStorage: this._initialStorage,
-        };
-    }
-
-    public get procedure(): PluvProcedure<TIO, {}, {}, TPresence, TCrdt, ""> {
-        return new PluvProcedure<TIO, {}, {}, TPresence, TCrdt, "">();
-    }
-
-    constructor(options: PluvClientOptions<TIO, TPresence, TCrdt, TMetadata>) {
-        const {
-            authEndpoint,
-            debug = false,
-            initialStorage,
-            limits,
-            metadata,
-            presence,
-            publicKey,
-            wsEndpoint,
-        } = options;
-
-        this.metadata = metadata;
-
-        this._authEndpoint = authEndpoint as AuthEndpoint<TMetadata>;
-        this._debug = debug;
-        this._initialStorage = initialStorage as TCrdt;
-        this._limits = {
-            presenceMaxSize: MAX_PRESENCE_SIZE_BYTES,
-            ...limits,
-        };
-        this._presence = presence;
-        this._wsEndpoint = wsEndpoint;
-
-        if (!!publicKey) this._publicKey = publicKey;
-    }
-
-    public createRoom = <
-        TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>> = {},
-    >(
-        room: string,
-        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, TCrdt, TEvents>(room, {
-            addons: options.addons,
-            authEndpoint: this._authEndpoint,
-            debug: options.debug,
-            initialPresence: options.initialPresence,
-            initialStorage: options.initialStorage ?? this._initialStorage,
-            limits: this._limits,
-            metadata: this.metadata,
-            onAuthorizationFail: options.onAuthorizationFail,
-            presence: this._presence,
-            publicKey: this._publicKey ?? undefined,
-            reconnectTimeoutMs: options.reconnectTimeoutMs,
-            router: options.router,
-            wsEndpoint: this._wsEndpoint,
-        } as RoomConfig<TIO, TMetadata, TPresence, TCrdt, TEvents>);
-
-        this._rooms.set(room, newRoom);
-
-        this._logDebug(`New room was created: ${room}`);
-
-        return newRoom;
-    };
-
-    public enter = async (
-        room: string | PluvRoom<TIO, TMetadata, any, any, any>,
-        ...args: EnterRoomParams<TMetadata>
-    ): 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}.`);
-
-        this._rooms.set(toEnter.id, toEnter);
-        await toEnter.connect(...args);
-
-        this._logDebug(`Entered room: ${room}`);
-
-        return toEnter;
-    };
-
-    public getRoom = (room: string): PluvRoom<TIO, TMetadata, TPresence, TCrdt, any> | null => {
-        const found = this._rooms.get(room) as
-            PluvRoom<TIO, TMetadata, TPresence, TCrdt, any> | undefined;
-
-        return found ?? null;
-    };
-
-    public getRooms = (): readonly PluvRoom<TIO, TMetadata, TPresence, TCrdt, any>[] => {
-        return Array.from(this._rooms.values());
-    };
-
-    public leave = async (room: string | PluvRoom<TIO, any, any, any>): Promise<void> => {
-        const toLeave = typeof room === "string" ? this.getRoom(room) : room;
-
-        if (!toLeave) return;
-
-        await toLeave.disconnect();
-
-        this._rooms.delete(toLeave.id);
-
-        this._logDebug(`Left and deleted room: ${room}`);
-    };
-
-    public router<TEvents extends PluvRouterEventConfig<TIO, TPresence, InferStorage<TCrdt>> = {}>(
-        events: 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, InferStorage<TCrdt>, TEvents>(events);
-    }
-
-    private _logDebug(...data: any[]): void {
-        if (typeof process === "undefined") return;
-        if (process.env?.NODE_ENV === "production") return;
-
-        if (this._debug) console.log(...data);
-    }
-}