@pluv/io 5.0.1 → 5.0.2

package/src/Persistence.ts

@@ -1,81 +0,0 @@
-import type { JsonObject } from "@pluv/types";
-import { AbstractPersistence } from "./AbstractPersistence";
-
-export class Persistence extends AbstractPersistence {
-    private _storages = new Map<string, string>();
-    private _users = new Map<string, Map<string, JsonObject | null>>();
-
-    public addUser(room: string, connectionId: string, user: JsonObject | null): Promise<void> {
-        const users = this._users.get(room) ?? new Map<string, JsonObject | null>();
-
-        this._users.set(room, users);
-        users.set(connectionId, user);
-
-        return Promise.resolve();
-    }
-
-    public deleteStorageState(room: string): Promise<void> {
-        this._storages.delete(room);
-
-        return Promise.resolve();
-    }
-
-    public async deleteUser(room: string, connectionId: string): Promise<void> {
-        const users = this._users.get(room);
-
-        if (!users) return;
-
-        users.delete(connectionId);
-
-        if (!users.size) {
-            await this.deleteUsers(room);
-            await this.deleteStorageState(room);
-        }
-
-        return Promise.resolve();
-    }
-
-    public deleteUsers(room: string): Promise<void> {
-        this._users.delete(room);
-
-        return Promise.resolve();
-    }
-
-    public getSize(room: string): Promise<number> {
-        return Promise.resolve(this._users.get(room)?.size ?? 0);
-    }
-
-    public getStorageState(room: string): Promise<string | null> {
-        const storage = this._storages.get(room) ?? null;
-
-        return Promise.resolve(storage);
-    }
-
-    public getUser(room: string, connectionId: string): Promise<JsonObject | null> {
-        const user = this._users.get(room)?.get(connectionId);
-
-        return Promise.resolve(user ?? null);
-    }
-
-    public async getUsers(room: string): Promise<Map<string, JsonObject | null>> {
-        const users = this._users.get(room);
-
-        if (!users) return new Map();
-
-        return users;
-    }
-
-    public async getUsersSize(room: string): Promise<number> {
-        return this._users.size;
-    }
-
-    public initialize(roomContext: any): this {
-        return this;
-    }
-
-    public setStorageState(room: string, state: string): Promise<void> {
-        this._storages.set(room, state);
-
-        return Promise.resolve();
-    }
-}

package/src/PluvIO.ts

@@ -1,239 +0,0 @@
-import type { AbstractCrdtDocFactory, CrdtLibraryType, NoopCrdtDocFactory } from "@pluv/crdt";
-import { noop } from "@pluv/crdt";
-import type { BaseUser, HasRequiredProperty, IOAuthorize, InferIOAuthorizeUser } from "@pluv/types";
-import type { AbstractPlatform, InferInitContextType } from "./AbstractPlatform";
-import type { WebSocketRegisterConfig } from "./IORoom";
-import { PluvProcedure } from "./PluvProcedure";
-import type { MergedRouter, PluvRouterEventConfig } from "./PluvRouter";
-import { PluvRouter } from "./PluvRouter";
-import { PluvServer, PluvServerConfig } from "./PluvServer";
-import type { JWTEncodeParams } from "./authorize";
-import { authorize } from "./authorize";
-import {
-    MAX_PRESENCE_SIZE_BYTES,
-    MAX_STORAGE_SIZE_BYTES,
-    MAX_USER_ID_LENGTH,
-    MAX_USER_SIZE_BYTES,
-} from "./constants";
-import type {
-    GetInitialStorageFn,
-    PluvContext,
-    PluvIOAuthorize,
-    PluvIOLimits,
-    PluvIOListeners,
-    PluvIORouter,
-    ResolvedPluvIOAuthorize,
-} from "./types";
-import { oneLine } from "./utils";
-import { __PLUV_VERSION } from "./version";
-
-export type PluvIOConfig<
-    TPlatform extends AbstractPlatform<any>,
-    TAuthorize extends IOAuthorize<any, InferInitContextType<TPlatform>> | null,
-    TContext extends Record<string, any>,
-    TCrdt extends CrdtLibraryType<any> = CrdtLibraryType<any>,
-> = {
-    authorize?: TAuthorize;
-    context?: PluvContext<TPlatform, TContext>;
-    crdt?: TCrdt;
-    debug?: boolean;
-    limits?: PluvIOLimits;
-    platform: () => TPlatform;
-};
-
-type ResolvedServerConfig<
-    TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
-    TAuthorize extends PluvIOAuthorize<TPlatform, any, InferInitContextType<TPlatform>> | null =
-        any,
-    TContext extends Record<string, any> = {},
-    TCrdt extends CrdtLibraryType<any> = CrdtLibraryType<NoopCrdtDocFactory>,
-    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
-> = Partial<PluvIOListeners<TPlatform, TAuthorize, TContext, TEvents>> &
-    PluvIORouter<TPlatform, TAuthorize, TContext, TEvents> &
-    (TCrdt extends CrdtLibraryType<NoopCrdtDocFactory>
-        ? { getInitialStorage?: "[ERROR]: Must specify crdt to use getInitialStorage" }
-        : { getInitialStorage: GetInitialStorageFn<TContext> });
-
-export type BaseServerConfig<
-    TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
-    TAuthorize extends PluvIOAuthorize<TPlatform, any, InferInitContextType<TPlatform>> | null =
-        any,
-    TContext extends Record<string, any> = {},
-    TCrdt extends CrdtLibraryType<any> = CrdtLibraryType<NoopCrdtDocFactory>,
-    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
-> = {
-    [
-        P in keyof ResolvedServerConfig<
-            TPlatform,
-            TAuthorize,
-            TContext,
-            TCrdt,
-            TEvents
-        > as ResolvedServerConfig<
-            TPlatform,
-            TAuthorize,
-            TContext,
-            TCrdt,
-            TEvents
-        >[P] extends undefined
-            ? never
-            : P
-    ]: ResolvedServerConfig<TPlatform, TAuthorize, TContext, TCrdt, TEvents>[P];
-};
-
-export type ServerConfig<
-    TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
-    TAuthorize extends PluvIOAuthorize<TPlatform, any, InferInitContextType<TPlatform>> | null =
-        any,
-    TContext extends Record<string, any> = {},
-    TCrdt extends CrdtLibraryType<any> = CrdtLibraryType<NoopCrdtDocFactory>,
-    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
-> =
-    HasRequiredProperty<
-        BaseServerConfig<TPlatform, TAuthorize, TContext, TCrdt, TEvents>
-    > extends true
-        ? [BaseServerConfig<TPlatform, TAuthorize, TContext, TCrdt, TEvents>]
-        : [BaseServerConfig<TPlatform, TAuthorize, TContext, TCrdt, TEvents>?];
-
-export class PluvIO<
-    TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
-    TAuthorize extends PluvIOAuthorize<TPlatform, any, InferInitContextType<TPlatform>> | null =
-        any,
-    TContext extends Record<string, any> = {},
-    TCrdt extends CrdtLibraryType<any> = CrdtLibraryType<any>,
-> {
-    public readonly version: string = __PLUV_VERSION as any;
-
-    private readonly _authorize: TAuthorize = null as TAuthorize;
-    private readonly _context: PluvContext<TPlatform, TContext> = {} as PluvContext<
-        TPlatform,
-        TContext
-    >;
-    private readonly _crdt: { doc: (value: any) => AbstractCrdtDocFactory<any, any> };
-    private readonly _debug: boolean;
-    private readonly _limits: PluvIOLimits;
-    private readonly _platform: () => TPlatform;
-
-    public get procedure(): PluvProcedure<TPlatform, TAuthorize, TContext, {}, {}> {
-        return new PluvProcedure();
-    }
-
-    constructor(options: PluvIOConfig<TPlatform, TAuthorize, TContext, TCrdt>) {
-        const { authorize, context, crdt = noop, debug = false, limits, platform } = options;
-
-        this._crdt = crdt as CrdtLibraryType<any>;
-        this._debug = debug;
-        this._limits = {
-            presenceMaxSize: MAX_PRESENCE_SIZE_BYTES,
-            storageMaxSize: MAX_STORAGE_SIZE_BYTES,
-            userIdMaxLength: MAX_USER_ID_LENGTH,
-            userMaxSize: MAX_USER_SIZE_BYTES,
-            ...limits,
-        };
-        this._platform = platform;
-
-        if (authorize) this._authorize = authorize;
-        if (context) this._context = context;
-    }
-
-    public async createToken(
-        params: JWTEncodeParams<InferIOAuthorizeUser<TAuthorize>, TPlatform>,
-    ): Promise<string> {
-        if (!this._authorize) {
-            throw new Error("IO does not specify authorize during initialization.");
-        }
-
-        const ioAuthorize = this._getIOAuthorize(params);
-        const user = params.user as BaseUser;
-        const parsed = !!ioAuthorize ? ioAuthorize.user.parse(user) : user;
-
-        if (!!this._limits.userIdMaxLength && user.id.length > this._limits.userIdMaxLength) {
-            throw new Error(oneLine`
-                createToken was called with a long user id. User ID must be at
-                most 128 characters. Current length: ${user.id.length.toLocaleString()}
-            `);
-        }
-
-        const bytes = new TextEncoder().encode(JSON.stringify(parsed)).length;
-
-        if (!!this._limits.userMaxSize && bytes > this._limits.userMaxSize) {
-            throw new Error(oneLine`
-                createToken called with large payload. User must be at most 512
-                bytes. Current size: ${bytes.toLocaleString()}
-            `);
-        }
-
-        const platform = this._platform();
-
-        /**
-         * !HACK
-         * @description Allow the platform to overwrite this behavior as needed. This is introduced
-         * to support platformPluv
-         * @date December 15, 2024
-         */
-        if (platform._createToken) {
-            return await platform._createToken({ ...params, authorize: ioAuthorize });
-        }
-
-        const secret = ioAuthorize?.secret ?? null;
-
-        if (!secret) throw new Error("`authorize` was specified without a valid secret");
-
-        return await authorize({ platform, secret }).encode(
-            params as JWTEncodeParams<any, TPlatform>,
-        );
-    }
-
-    public mergeRouters<TRouters extends PluvRouter<TPlatform, TAuthorize, TContext, any>[]>(
-        ...routers: TRouters
-    ): MergedRouter<TRouters> {
-        return PluvRouter.merge(...routers);
-    }
-
-    public router<TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext>>(
-        events: TEvents,
-    ): PluvRouter<TPlatform, TAuthorize, TContext, TEvents> {
-        const invalidName = Object.keys(events).find((name) => name.includes("$"));
-
-        if (typeof invalidName === "string") {
-            throw new Error(oneLine`
-                Invalid event name. Event names must not contain $: "${invalidName}"
-            `);
-        }
-
-        return new PluvRouter<TPlatform, TAuthorize, TContext, TEvents>(events);
-    }
-
-    public server<TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {}>(
-        ...config: ServerConfig<TPlatform, TAuthorize, TContext, TCrdt, TEvents>
-    ): PluvServer<TPlatform, TAuthorize, TContext, TCrdt, TEvents> {
-        const serverConfig = (config[0] ?? {}) as PluvServerConfig<
-            TPlatform,
-            TAuthorize,
-            TContext,
-            TCrdt,
-            TEvents
-        >;
-
-        return new PluvServer<TPlatform, TAuthorize, TContext, TCrdt, TEvents>({
-            ...serverConfig,
-            authorize: this._authorize ?? undefined,
-            context: this._context,
-            crdt: this._crdt,
-            debug: this._debug,
-            io: this as PluvIO<TPlatform, TAuthorize, TContext, TCrdt>,
-            limits: this._limits,
-            platform: this._platform,
-        });
-    }
-
-    private _getIOAuthorize(
-        options: WebSocketRegisterConfig<TPlatform>,
-    ): ResolvedPluvIOAuthorize<any, any> | null {
-        if (typeof this._authorize === "function") {
-            return this._authorize(options);
-        }
-
-        return this._authorize as ResolvedPluvIOAuthorize<any, any> | null;
-    }
-}

package/src/PluvProcedure.ts

@@ -1,203 +0,0 @@
-import type {
-    EventRecord,
-    IOAuthorize,
-    InputZodLike,
-    JsonObject,
-    ProcedureLike,
-} from "@pluv/types";
-import type { AbstractPlatform, InferInitContextType } from "./AbstractPlatform";
-import type { EventResolver, EventResolverKind, MergeEventRecords } from "./types";
-
-export interface PluvProcedureConfig<
-    TPlatform extends AbstractPlatform<any>,
-    TAuthorize extends IOAuthorize<any, InferInitContextType<TPlatform>> | null,
-    TContext extends Record<string, any>,
-    TInput extends JsonObject = {},
-    TOutput extends EventRecord<string, any> = {},
-> {
-    broadcast?: EventResolver<
-        "broadcast",
-        TPlatform,
-        TAuthorize,
-        TContext,
-        TInput,
-        Partial<TOutput>
-    > | null;
-    input?: InputZodLike<TInput>;
-    self?: EventResolver<"self", TPlatform, TAuthorize, TContext, TInput, Partial<TOutput>> | null;
-    sync?: EventResolver<"sync", TPlatform, TAuthorize, TContext, TInput, Partial<TOutput>> | null;
-}
-
-export class PluvProcedure<
-    TPlatform extends AbstractPlatform<any>,
-    TAuthorize extends IOAuthorize<any, InferInitContextType<TPlatform>> | null,
-    TContext extends Record<string, any>,
-    TInput extends JsonObject = {},
-    TOutput extends EventRecord<string, any> = {},
-    TFilled extends "input" | "broadcast" | "self" | "sync" | "" = "",
-> {
-    private _broadcast: EventResolver<
-        "broadcast",
-        TPlatform,
-        TAuthorize,
-        TContext,
-        TInput,
-        Partial<TOutput>
-    > | null = null;
-    private _input: InputZodLike<TInput> | null = null;
-    private _self: EventResolver<
-        "self",
-        TPlatform,
-        TAuthorize,
-        TContext,
-        TInput,
-        Partial<TOutput>
-    > | null = null;
-    private _sync: EventResolver<
-        "sync",
-        TPlatform,
-        TAuthorize,
-        TContext,
-        TInput,
-        Partial<TOutput>
-    > | null = null;
-
-    public get config(): ProcedureLike<TInput, TOutput>["config"] {
-        return {
-            broadcast: this._broadcast?.bind(this) ?? null,
-            input: this._input ?? null,
-            resolver: this._resolver(),
-            self: this._self?.bind(this) ?? null,
-            sync: this._sync?.bind(this) ?? null,
-        } as ProcedureLike<TInput, TOutput>["config"];
-    }
-
-    constructor(
-        config: PluvProcedureConfig<TPlatform, TAuthorize, TContext, TInput, TOutput> = {},
-    ) {
-        const { broadcast, input, self, sync } = config;
-
-        this._broadcast = broadcast ?? null;
-        this._input = input ?? null;
-        this._self = self ?? null;
-        this._sync = sync ?? null;
-    }
-
-    public broadcast<TResult extends EventRecord<string, any> = {}>(
-        resolver: EventResolver<"broadcast", TPlatform, TAuthorize, TContext, TInput, TResult>,
-    ): Omit<
-        PluvProcedure<
-            TPlatform,
-            TAuthorize,
-            TContext,
-            TInput,
-            MergeEventRecords<[TOutput, TResult]>,
-            TFilled | "input" | "broadcast"
-        >,
-        TFilled | "input" | "broadcast"
-    > {
-        const { broadcast } = this.config;
-
-        if (!!broadcast) throw new Error("Broadcast was already defined for this procedure");
-
-        return new PluvProcedure<
-            TPlatform,
-            TAuthorize,
-            TContext,
-            TInput,
-            MergeEventRecords<[TOutput, TResult]>,
-            TFilled | "input" | "broadcast"
-        >({
-            ...(this.config as any),
-            broadcast: resolver as any,
-        });
-    }
-
-    public input<TData extends JsonObject>(
-        input: InputZodLike<TData>,
-    ): Omit<
-        PluvProcedure<TPlatform, TAuthorize, TContext, TData, {}, TFilled | "input">,
-        TFilled | "input"
-    > {
-        return new PluvProcedure<TPlatform, TAuthorize, TContext, TData, {}, TFilled | "input">({
-            input,
-        });
-    }
-
-    public self<TResult extends EventRecord<string, any> = {}>(
-        resolver: EventResolver<"self", TPlatform, TAuthorize, TContext, TInput, TResult>,
-    ): Omit<
-        PluvProcedure<
-            TPlatform,
-            TAuthorize,
-            TContext,
-            TInput,
-            MergeEventRecords<[TOutput, TResult]>,
-            TFilled | "input" | "self"
-        >,
-        TFilled | "input" | "self"
-    > {
-        const { self } = this.config;
-
-        if (!!self) throw new Error("Self was already defined for this procedure");
-
-        return new PluvProcedure<
-            TPlatform,
-            TAuthorize,
-            TContext,
-            TInput,
-            MergeEventRecords<[TOutput, TResult]>,
-            TFilled | "input" | "self"
-        >({
-            ...(this.config as any),
-            self: resolver as any,
-        });
-    }
-
-    public sync<TResult extends EventRecord<string, any> = {}>(
-        resolver: EventResolver<"sync", TPlatform, TAuthorize, TContext, TInput, TResult>,
-    ): Omit<
-        PluvProcedure<
-            TPlatform,
-            TAuthorize,
-            TContext,
-            TInput,
-            MergeEventRecords<[TOutput, TResult]>,
-            TFilled | "input" | "sync"
-        >,
-        TFilled | "input" | "sync"
-    > {
-        const { sync } = this.config;
-
-        if (!!sync) throw new Error("Sync was already defined for this procedure");
-
-        return new PluvProcedure<
-            TPlatform,
-            TAuthorize,
-            TContext,
-            TInput,
-            MergeEventRecords<[TOutput, TResult]>,
-            TFilled | "input" | "sync"
-        >({
-            ...(this.config as any),
-            sync: resolver as any,
-        });
-    }
-
-    private _resolver(): EventResolver<
-        EventResolverKind,
-        TPlatform,
-        TAuthorize,
-        TContext,
-        TInput,
-        TOutput
-    > {
-        return (data, context) => {
-            return {
-                ...this._broadcast?.(data, context),
-                ...this._self?.(data, context),
-                ...this._sync?.(data, context),
-            } as TOutput;
-        };
-    }
-}

package/src/PluvRouter.ts

@@ -1,61 +0,0 @@
-import type { IORouterLike } from "@pluv/types";
-import type { AbstractPlatform, InferInitContextType } from "./AbstractPlatform";
-import type { PluvProcedure } from "./PluvProcedure";
-import type { PluvIOAuthorize } from "./types";
-
-export type PluvRouterEventConfig<
-    TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
-    TAuthorize extends PluvIOAuthorize<TPlatform, any, InferInitContextType<TPlatform>> | null =
-        any,
-    TContext extends Record<string, any> = {},
-> = { [P: string]: Pick<PluvProcedure<TPlatform, TAuthorize, TContext, any, any>, "config"> };
-
-export type MergedRouter<
-    TRouters extends PluvRouter<TPlatform, TAuthorize, TContext, any>[] = [],
-    TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
-    TAuthorize extends PluvIOAuthorize<TPlatform, any, InferInitContextType<TPlatform>> = any,
-    TContext extends Record<string, any> = {},
-    TRoot extends TRouters[0]["_defs"]["events"] = {},
-> = TRouters extends [
-    infer IHead extends PluvRouter<TPlatform, TAuthorize, TContext, any>,
-    ...infer ITail extends PluvRouter<TPlatform, TAuthorize, TContext, any>[],
-]
-    ? MergedRouter<ITail, TPlatform, TAuthorize, TContext, TRoot & IHead["_defs"]["events"]>
-    : PluvRouter<TPlatform, TAuthorize, TContext, TRoot>;
-
-export class PluvRouter<
-    TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>,
-    TAuthorize extends PluvIOAuthorize<TPlatform, any, InferInitContextType<TPlatform>> | null =
-        any,
-    TContext extends Record<string, any> = {},
-    TEvents extends PluvRouterEventConfig<TPlatform, TAuthorize, TContext> = {},
-> implements IORouterLike<TEvents> {
-    readonly _defs: { events: TEvents } = { events: {} as TEvents };
-
-    constructor(events: TEvents) {
-        const invalidName = Object.keys(events).find((name) => !this._isValidEventName(name));
-
-        if (typeof invalidName === "string") {
-            throw new Error(
-                `Invalid event name. Event names must be formatted as valid JavaScript variable names: "${invalidName}"`,
-            );
-        }
-
-        this._defs = { events };
-    }
-
-    public static merge<TRouters extends PluvRouter<any, any, any, any>[]>(
-        ...routers: TRouters
-    ): MergedRouter<TRouters> {
-        const events = Object.assign(
-            Object.create(null),
-            ...routers.map((router) => router._defs.events),
-        );
-
-        return new PluvRouter<any, any, any, any>(events) as MergedRouter<TRouters>;
-    }
-
-    private _isValidEventName(name: string): boolean {
-        return /^[a-z_$][a-z0-9_$]*$/gi.test(name);
-    }
-}