@pluv/client 2.0.2 → 2.2.0

package/src/PluvRouter.ts

@@ -1,31 +1,31 @@
-import type { CrdtType } from "@pluv/crdt";
+import type { AbstractCrdtDocFactory } from "@pluv/crdt";
 import type { IOLike, IORouterLike, JsonObject } 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"> };
+    TIO extends IOLike,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
+> = { [P: string]: Pick<PluvProcedure<TIO, any, any, TPresence, TCrdt, "">, "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 PluvRouter<TIO, TPresence, TCrdt, any>[],
+    TIO extends IOLike,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<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>[],
+    infer IHead extends PluvRouter<TIO, TPresence, TCrdt, any>,
+    ...infer ITail extends PluvRouter<TIO, TPresence, TCrdt, any>[],
 ]
-    ? MergedRouter<ITail, TIO, TPresence, TStorage, TRoot & IHead["_defs"]["events"]>
-    : PluvRouter<TIO, TPresence, TStorage, TRoot>;
+    ? MergedRouter<ITail, TIO, TPresence, TCrdt, TRoot & IHead["_defs"]["events"]>
+    : PluvRouter<TIO, TPresence, TCrdt, TRoot>;
 
 export class PluvRouter<
-    TIO extends IOLike = IOLike,
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
-    TEvents extends PluvRouterEventConfig<TIO, TPresence, TStorage> = {},
+    TIO extends IOLike,
+    TPresence extends Record<string, any>,
+    TCrdt extends AbstractCrdtDocFactory<any, any>,
+    TEvents extends PluvRouterEventConfig<TIO, TPresence, TCrdt> = {},
 > implements IORouterLike<TEvents>
 {
     readonly _defs: { events: TEvents } = { events: {} as TEvents };
@@ -42,9 +42,12 @@ export class PluvRouter<
         this._defs = { events };
     }
 
-    public static merge<TRouters extends PluvRouter<any, any, any, any>[]>(
-        ...routers: TRouters
-    ): MergedRouter<TRouters> {
+    public static merge<
+        TRouters extends PluvRouter<TIO, TPresence, TCrdt, any>[],
+        TIO extends IOLike,
+        TPresence extends Record<string, any>,
+        TCrdt extends AbstractCrdtDocFactory<any, any>,
+    >(...routers: TRouters): MergedRouter<TRouters, TIO, TPresence, TCrdt, {}> {
         const events = Object.assign(
             Object.create(null),
             ...routers.map((router) => router._defs.events),
@@ -54,7 +57,13 @@ export class PluvRouter<
             throw new Error('Procedures may not start with "$"');
         }
 
-        return new PluvRouter<any, any, any, any>(events) as MergedRouter<TRouters>;
+        return new PluvRouter<any, any, any, any>(events) as MergedRouter<
+            TRouters,
+            TIO,
+            TPresence,
+            TCrdt,
+            {}
+        >;
     }
 
     private _isValidEventName(name: string): boolean {

package/src/StateNotifier.ts

@@ -1,36 +1,30 @@
-import type { Id, IOLike, JsonObject, UserInfo, WebSocketState } from "@pluv/types";
+import type {
+    Id,
+    IOLike,
+    JsonObject,
+    StateNotifierSubjects,
+    SubscriptionCallback,
+    UserInfo,
+    WebSocketState,
+} from "@pluv/types";
 import type { Subject } from "wonka";
 import { makeSubject, subscribe } from "wonka";
 
-export interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject> {
-    connection: Subject<Id<WebSocketState<TIO>>>;
-    "my-presence": Subject<TPresence | null>;
-    myself: Subject<Readonly<Id<UserInfo<TIO>>> | null>;
-    others: Subject<readonly Id<UserInfo<TIO>>[]>;
-    "storage-loaded": Subject<boolean>;
-}
-
 type InferSubjectValue<
     TIO extends IOLike,
-    TPresence extends JsonObject,
+    TPresence extends Record<string, any>,
     TSubject extends keyof StateNotifierSubjects<TIO, TPresence>,
 > =
     StateNotifierSubjects<TIO, TPresence>[TSubject] extends Subject<infer IValue>
         ? Id<IValue>
         : never;
 
-export type SubscriptionCallback<
-    TIO extends IOLike,
-    TPresence extends JsonObject,
-    TSubject extends keyof StateNotifierSubjects<TIO, TPresence>,
-> = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
-
-export class StateNotifier<TIO extends IOLike, TPresence extends JsonObject = {}> {
+export class StateNotifier<TIO extends IOLike, TPresence extends Record<string, any> = {}> {
     public subjects: StateNotifierSubjects<TIO, TPresence> = {
         connection: makeSubject<Id<WebSocketState<TIO>>>(),
         "my-presence": makeSubject<TPresence>(),
-        myself: makeSubject<Readonly<Id<UserInfo<TIO>>> | null>(),
-        others: makeSubject<readonly Id<UserInfo<TIO>>[]>(),
+        myself: makeSubject<Readonly<Id<UserInfo<TIO, TPresence>>> | null>(),
+        others: makeSubject<readonly Id<UserInfo<TIO, TPresence>>[]>(),
         "storage-loaded": makeSubject<true>(),
     };
 

package/src/UsersManager.ts

@@ -1,29 +1,33 @@
 import type { InputZodLike, IOLike, JsonObject, OptionalProps, UserInfo } from "@pluv/types";
+import { PLUV_PRESENCE_META_KEY } from "./constants";
 import type { PluvClientLimits } from "./types";
 import { pickBy } from "./utils";
 
 export type Presence = Record<string, unknown>;
 
-export type UsersManagerConfig<TPresence extends JsonObject = {}> = {
+export type UsersManagerConfig<TPresence extends Record<string, any> = {}> = {
     initialPresence?: TPresence;
     limits: PluvClientLimits;
     presence?: InputZodLike<TPresence>;
 };
 
-export type AddConnectionResult<TIO extends IOLike, TPresence extends JsonObject = {}> = {
+export type AddConnectionResult<TIO extends IOLike, TPresence extends Record<string, any> = {}> = {
     clientId: string;
     data: UserInfo<TIO, TPresence>;
     isMyself: boolean;
     remaining: number;
 };
 
-export type DeleteConnectionResult<TIO extends IOLike, TPresence extends JsonObject = {}> = {
+export type DeleteConnectionResult<
+    TIO extends IOLike,
+    TPresence extends Record<string, any> = {},
+> = {
     clientId: string;
     data: UserInfo<TIO, TPresence>;
     remaining: number;
 };
 
-export class UsersManager<TIO extends IOLike, TPresence extends JsonObject = {}> {
+export class UsersManager<TIO extends IOLike, TPresence extends Record<string, any> = {}> {
     public readonly initialPresence: TPresence;
 
     private readonly _idMap = {
@@ -210,6 +214,16 @@ export class UsersManager<TIO extends IOLike, TPresence extends JsonObject = {}>
         } as TPresence;
         const validated = this._presence ? this._presence.parse(presence) : presence;
 
+        /**
+         * !HACK
+         * @description We're patching internal metadata back into the presence field so it doesn't
+         * get stripped from validation
+         * @date May 13, 2025
+         */
+        if (!!presence[PLUV_PRESENCE_META_KEY]) {
+            (validated as any)[PLUV_PRESENCE_META_KEY] = presence[PLUV_PRESENCE_META_KEY];
+        }
+
         this._others.set(clientId, { ...other, presence: validated });
 
         return validated;

package/src/UsersNotifier.ts

@@ -0,0 +1,66 @@
+import type {
+    Id,
+    IOLike,
+    JsonObject,
+    OtherSubscriptionCallback,
+    OthersSubscriptionCallback,
+    OthersSubscriptionEvent,
+    UserInfo,
+} from "@pluv/types";
+import type { Subject } from "wonka";
+import { makeSubject, subscribe, TypeOfSource } from "wonka";
+
+export class UsersNotifier<TIO extends IOLike, TPresence extends Record<string, any> = {}> {
+    public readonly others = makeSubject<{
+        others: readonly Id<UserInfo<TIO, TPresence>>[];
+        event: OthersSubscriptionEvent<TIO, TPresence>;
+    }>();
+
+    private _otherSubjects = new Map<
+        [clientId: string][0],
+        Subject<Id<UserInfo<TIO, TPresence>> | null>
+    >();
+
+    public clear(): void {
+        this._otherSubjects.forEach((subject) => {
+            subject.next(null);
+        });
+
+        this._otherSubjects.clear();
+    }
+
+    public delete(clientId: string): void {
+        this.other(clientId).next(null);
+        this._otherSubjects.delete(clientId);
+    }
+
+    public other(clientId: string): Subject<Id<UserInfo<TIO, TPresence>> | null> {
+        const subject = this._otherSubjects.get(clientId);
+
+        if (subject) return subject;
+
+        const newSubject = makeSubject<Id<UserInfo<TIO, TPresence>>>();
+
+        this._otherSubjects.set(clientId, newSubject);
+
+        return newSubject;
+    }
+
+    public subscribeOther(
+        clientId: string,
+        callback: OtherSubscriptionCallback<TIO, TPresence>,
+    ): () => void {
+        const source = this.other(clientId).source;
+        const subscription = subscribe(callback)(source);
+
+        return subscription.unsubscribe;
+    }
+
+    public subscribeOthers(callback: OthersSubscriptionCallback<TIO, TPresence>): () => void {
+        const subscription = subscribe<TypeOfSource<typeof this.others.source>>(
+            ({ others, event }) => callback(others, event),
+        )(this.others.source);
+
+        return subscription.unsubscribe;
+    }
+}

package/src/constants.ts

@@ -1 +1,2 @@
 export const MAX_PRESENCE_SIZE_BYTES = 512;
+export const PLUV_PRESENCE_META_KEY = "__pluv";

package/src/createClient.ts

@@ -5,8 +5,8 @@ import { PluvClient } from "./PluvClient";
 
 export const createClient = <
     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 = {},
 >(
     options: PluvClientOptions<TIO, TPresence, TCrdt, TMetadata>,

package/src/index.ts

@@ -9,6 +9,7 @@ export type {
     MergeEvents,
     RoomLike,
     UserInfo,
+    WebSocketConnection,
     WebSocketState,
 } from "@pluv/types";
 export { AbstractStorageStore } from "./AbstractStorageStore";
@@ -32,4 +33,4 @@ export type {
 export type { PluvRouter, PluvRouterEventConfig } from "./PluvRouter";
 export { register } from "./register";
 export type { RegisterParams } from "./register";
-export type { InferMetadata, PublicKey, PublicKeyParams, WebSocketConnection } from "./types";
+export type { InferMetadata, PublicKey, PublicKeyParams } from "./types";

package/src/types.ts

@@ -1,6 +1,4 @@
-import type { CrdtType } from "@pluv/crdt";
 import type {
-    ConnectionState,
     CrdtDocLike,
     EventRecord,
     Id,
@@ -19,22 +17,22 @@ export interface AuthorizationState<TIO extends IOLike> {
 }
 
 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>> = {},
+    TIO extends IOLike,
+    TInput extends JsonObject,
+    TOutput extends EventRecord<string, any>,
+    TPresence extends Record<string, any>,
+    TDocLike extends CrdtDocLike<any, any>,
 > = (
     data: TInput,
-    context: EventResolverContext<TIO, TPresence, TStorage>,
+    context: EventResolverContext<TIO, TPresence, TDocLike>,
 ) => MaybePromise<TOutput | void>;
 
 export interface EventResolverContext<
-    TIO extends IOLike = IOLike,
-    TPresence extends JsonObject = {},
-    TStorage extends Record<string, CrdtType<any, any>> = {},
+    TIO extends IOLike,
+    TPresence extends Record<string, any>,
+    TDocLike extends CrdtDocLike<any, any>,
 > {
-    doc: CrdtDocLike<TStorage>;
+    doc: TDocLike;
     others: readonly UserInfo<TIO, TPresence>[];
     room: string;
     user: UserInfo<TIO, TPresence>;
@@ -76,25 +74,6 @@ export type PublicKey<TMetadata extends JsonObject> =
     | string
     | ((params: PublicKeyParams<TMetadata>) => string);
 
-export interface WebSocketConnection {
-    /**
-     * @description How many times a connection attempt was made. This will increment upon each
-     * unsuccessful attempt, and will reset upon a successful connection.
-     * @date April 13, 2025
-     */
-    attempts: number;
-    /**
-     * @description How many times the user has connected to the room. This can be more than 1 in
-     * the case of reconnects. This is tracked because on the very first connection (i.e. when
-     * count is 0) we don't want to send the storage state as an update to the room and overwrite
-     * the upstream state.
-     * @date April 13, 2025
-     */
-    count: number;
-    id: string | null;
-    state: ConnectionState;
-}
-
 export type WithMetadata<TMetadata extends JsonObject = {}> = keyof TMetadata extends never
     ? { metadata?: undefined }
     : { metadata: TMetadata };

package/src/OtherNotifier.ts

@@ -1,50 +0,0 @@
-import type {
-    Id,
-    IOLike,
-    JsonObject,
-    OtherNotifierSubscriptionCallback,
-    UserInfo,
-} from "@pluv/types";
-import type { Subject } from "wonka";
-import { makeSubject, subscribe } from "wonka";
-
-export class OtherNotifier<TIO extends IOLike, TPresence extends JsonObject = {}> {
-    private _subjects = new Map<
-        [clientId: string][0],
-        Subject<Id<UserInfo<TIO, TPresence>> | null>
-    >();
-
-    public clear(): void {
-        this._subjects.forEach((subject) => {
-            subject.next(null);
-        });
-
-        this._subjects.clear();
-    }
-
-    public delete(clientId: string): void {
-        this.subject(clientId).next(null);
-        this._subjects.delete(clientId);
-    }
-
-    public subject(clientId: string): Subject<Id<UserInfo<TIO, TPresence>> | null> {
-        const subject = this._subjects.get(clientId);
-
-        if (subject) return subject;
-
-        const newSubject = makeSubject<Id<UserInfo<TIO, TPresence>>>();
-
-        this._subjects.set(clientId, newSubject);
-
-        return newSubject;
-    }
-
-    public subscribe(
-        clientId: string,
-        callback: OtherNotifierSubscriptionCallback<TIO, TPresence>,
-    ): () => void {
-        const source = this.subject(clientId).source;
-
-        return subscribe(callback)(source).unsubscribe;
-    }
-}