@pluv/io 0.0.0

package/.eslintrc.js

@@ -0,0 +1,4 @@
+module.exports = {
+  root: true,
+  extends: ["pluv"],
+};

package/.turbo/turbo-build.log

@@ -0,0 +1,17 @@
+
+> @pluv/io@0.0.0 build /home/runner/work/pluv/pluv/packages/io
+> tsup src/index.ts --format esm,cjs --dts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v6.5.0
+CLI Target: es6
+ESM Build start
+CJS Build start
+ESM dist/index.mjs 25.31 KB
+ESM ⚡️ Build success in 112ms
+CJS dist/index.js 27.11 KB
+CJS ⚡️ Build success in 112ms
+DTS Build start
+DTS ⚡️ Build success in 2486ms
+DTS dist/index.d.ts 12.29 KB

package/dist/index.d.ts

@@ -0,0 +1,257 @@
+import { JsonObject, MaybePromise, IOEventMessage, EventRecord, InputZodLike, Id, IOLike, InferIOOutput, BaseUser, IOAuthorize, BaseIOAuthorize, InferEventMessage, InferIOInput, BaseIOEventRecord, InferIOAuthorize, InferIOAuthorizeUser, Spread, BaseClientEventRecord } from '@pluv/types';
+export { BaseUser, EventMessage, EventRecord, IOEventMessage } from '@pluv/types';
+import { YjsDoc } from '@pluv/crdt-yjs';
+
+declare abstract class AbstractPersistance {
+    abstract addUser(room: string, connectionId: string, user: JsonObject | null): Promise<void>;
+    abstract deleteStorageState(room: string): Promise<void>;
+    abstract deleteUser(room: string, connectionId: string): Promise<void>;
+    abstract deleteUsers(room: string): Promise<void>;
+    abstract getStorageState(room: string): Promise<string | null>;
+    abstract getUser(room: string, connectionId: string): Promise<JsonObject | null>;
+    abstract getUsers(room: string): Promise<readonly (JsonObject | null)[]>;
+    abstract setStorageState(room: string, state: string): Promise<void>;
+}
+
+type AbstractEvent = {};
+type AbstractCloseEvent = AbstractEvent & {
+    readonly code: number;
+    readonly reason: string;
+};
+type AbstractMessageEvent<T = any> = AbstractEvent & {
+    readonly data: T;
+};
+type AbstractErrorEvent = AbstractEvent & {
+    error: unknown;
+    message: string;
+};
+interface AbstractEventMap {
+    close: AbstractCloseEvent;
+    message: AbstractMessageEvent;
+    error: AbstractErrorEvent;
+}
+type EventType = keyof AbstractEventMap;
+interface AbstractWebSocketHandleErrorParams {
+    error: unknown;
+    message?: string;
+    session?: WebSocketSession;
+}
+type AbstractListener<TType extends keyof AbstractEventMap> = (event: AbstractEventMap[TType]) => MaybePromise<void>;
+interface AbstractWebSocketConfig {
+    pubSub?: AbstractPubSub;
+    room: string;
+}
+declare abstract class AbstractWebSocket {
+    /** The connection is not yet open. */
+    readonly CONNECTING = 0;
+    /** The connection is open and ready to communicate. */
+    readonly OPEN = 1;
+    /** The connection is in the process of closing. */
+    readonly CLOSING = 2;
+    /** The connection is closed. */
+    readonly CLOSED = 3;
+    pubSub?: AbstractPubSub;
+    room: string;
+    abstract get readyState(): 0 | 1 | 2 | 3;
+    constructor(config: AbstractWebSocketConfig);
+    /**
+     * TODO
+     * @description Return an unsubscribe method to remove the event-listener.
+     * This is preferred over adding an explicit abstract removeEventListener
+     * method, because the implementing class might have to transform the
+     * listener, and removing the same listener might be complicated as a
+     * result.
+     * @author leedavidcs
+     * @date August 28, 2022
+     */
+    abstract addEventListener<TType extends EventType>(type: TType, handler: AbstractListener<TType>): void;
+    abstract close(code?: number | undefined, reason?: string | undefined): void;
+    abstract initialize(): Promise<() => void>;
+    abstract send(message: ArrayBuffer | ArrayBufferView | string): void;
+    abstract terminate(): void;
+    handleError(params: AbstractWebSocketHandleErrorParams): void;
+    sendMessage<TMessage extends IOEventMessage<any> = IOEventMessage<any>>(data: TMessage): void;
+}
+
+declare global {
+    var console: {
+        log: (...data: any[]) => void;
+    };
+}
+interface EventConfig<TContext extends JsonObject = {}, TData extends JsonObject = {}, TResult extends EventRecord<string, any> = {}> {
+    input?: InputZodLike<TData>;
+    options?: SendMessageOptions;
+    resolver: EventResolver<TContext, TData, TResult>;
+}
+type EventResolver<TContext extends JsonObject = {}, TData extends JsonObject = {}, TResult extends EventRecord<string, any> = {}> = (data: TData, context: EventResolverContext<TContext>) => MaybePromise<TResult | void>;
+interface EventResolverContext<TContext extends JsonObject = {}> {
+    context: TContext;
+    doc: YjsDoc<any>;
+    room: string;
+    /**
+     * !HACK
+     * @description Session should only not exist when invoking the event as a
+     * "sync" event on another machine where the session doesn't exist. There must
+     * be a better way to handle this, but going to make this nullable for ease
+     * for now.
+     *
+     * `session` should not be referenced most of the time anyhow (outside of
+     * internal to this library).
+     * @author leedavidcs
+     * @date December 25, 2022
+     */
+    session: WebSocketSession | null;
+    sessions: Map<string, WebSocketSession>;
+}
+type InferEventConfig<TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutput extends EventRecord<string, any> = {}> = {
+    [P in keyof TInput]: P extends string ? Id<EventConfig<TContext, TInput[P], TOutput>> : never;
+};
+type SendMessageOptions = {
+    type?: "broadcast";
+    sessionIds?: readonly string[];
+} | {
+    type: "self";
+} | {
+    type: "sync";
+};
+interface WebSocketSessionTimers {
+    ping: number;
+}
+interface WebSocketSession {
+    id: string;
+    presence: JsonObject | null;
+    quit: boolean;
+    room: string;
+    timers: WebSocketSessionTimers;
+    webSocket: AbstractWebSocket;
+    user: JsonObject | null;
+}
+
+type IOPubSubEventMessage<TIO extends IOLike, TEvent extends keyof InferIOOutput<TIO> = keyof InferIOOutput<TIO>> = IOEventMessage<TIO, TEvent> & {
+    options?: SendMessageOptions;
+};
+declare abstract class AbstractPubSub {
+    abstract publish(roomName: string, payload: IOPubSubEventMessage<any>): Promise<void>;
+    abstract subscribe(roomName: string, onMessage: (message: IOPubSubEventMessage<any>) => void): Promise<number>;
+    abstract unsubscribe(subscriptionId: number): void;
+}
+
+type InferWebSocketType<TPlatform extends AbstractPlatform<any>> = TPlatform extends AbstractPlatform<infer IWebSocket> ? IWebSocket : never;
+type AbstractPlatformConfig = {
+    persistance?: undefined;
+    pubSub?: undefined;
+} | {
+    persistance: AbstractPersistance;
+    pubSub: AbstractPubSub;
+};
+interface ConvertWebSocketConfig {
+    room: string;
+}
+declare abstract class AbstractPlatform<TWebSocket = any> {
+    persistance: AbstractPersistance;
+    pubSub: AbstractPubSub;
+    constructor(config?: AbstractPlatformConfig);
+    abstract convertWebSocket(webSocket: TWebSocket, config: ConvertWebSocketConfig): AbstractWebSocket;
+    abstract parseData(data: string | ArrayBuffer): Record<string, any>;
+    abstract randomUUID(): string;
+}
+
+interface JWT<TUser extends BaseUser> {
+    room: string;
+    sub: string;
+    user: TUser;
+}
+interface JWTEncodeParams<TUser extends BaseUser> {
+    maxAge?: number;
+    room: string;
+    user: TUser;
+}
+interface AuthorizeParams {
+    platform: AbstractPlatform;
+    secret: string;
+}
+interface AuthorizeModule {
+    decode: <TUser extends BaseUser>(jwt: string) => Promise<TUser | null>;
+    encode: <TUser extends BaseUser>(params: JWTEncodeParams<TUser>) => Promise<string>;
+}
+
+type BroadcastMessage<TIO extends IORoom<any, any, any, any, any>> = InferEventMessage<InferIOInput<TIO>> | InferEventMessage<BaseIOEventRecord<InferIOAuthorize<TIO>>>;
+interface IORoomConfig<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> = BaseIOAuthorize, TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutput extends EventRecord<string, any> = {}> {
+    authorize?: TAuthorize;
+    context: TContext;
+    debug: boolean;
+    events: InferEventConfig<TContext, TInput, TOutput>;
+    onDestroy?: () => void;
+    platform: TPlatform;
+}
+interface WebsocketRegisterOptions {
+    token?: string;
+}
+declare class IORoom<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> = BaseIOAuthorize, TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutput extends EventRecord<string, any> = {}> implements IOLike<TAuthorize, TInput, TOutput> {
+    private readonly _context;
+    private readonly _debug;
+    private readonly _platform;
+    private _doc;
+    private _listeners;
+    private _sessions;
+    private _uninitialize;
+    readonly _authorize: TAuthorize | null;
+    readonly _events: InferEventConfig<TContext, TInput, TOutput>;
+    readonly room: string;
+    constructor(room: string, config: IORoomConfig<TPlatform, TAuthorize, TContext, TInput, TOutput>);
+    broadcast(message: BroadcastMessage<this>): Promise<void>;
+    register(webSocket: InferWebSocketType<TPlatform>, options?: WebsocketRegisterOptions): Promise<void>;
+    private _broadcast;
+    private _emitQuitters;
+    private _emitRegistered;
+    private _emitStorageReceived;
+    private _emitUserJoined;
+    private _getAuthorizedUser;
+    private _getSessionsSize;
+    private _getEventConfig;
+    private _initialize;
+    private _logDebug;
+    private _parseMessage;
+    private _resolveMessage;
+    private _sendMessage;
+    private _sendBroadcastMessage;
+    private _sendSelfMessage;
+    private _sendSyncMessage;
+}
+
+type InferIOContext<TIO extends PluvIO<any, any, any, any, any>> = TIO extends PluvIO<any, any, infer IContext, any, any> ? IContext : never;
+type InferIOPlatform<TIO extends PluvIO<any, any, any, any>> = TIO extends PluvIO<infer IPlatform, any, any, any, any> ? IPlatform : never;
+type InferIORoom<TIO extends PluvIO<any, any, any, any>> = TIO extends PluvIO<infer IPlatform, infer IAuthorize, infer IContext, infer IInput, infer IOutput> ? IORoom<IPlatform, IAuthorize, IContext, IInput, IOutput> : never;
+interface PluvIOConfig<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> | null = null, TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutput extends EventRecord<string, any> = {}> {
+    authorize?: TAuthorize;
+    context?: TContext;
+    debug?: boolean;
+    events?: InferEventConfig<TContext, TInput, TOutput>;
+    platform: TPlatform;
+    room?: string;
+}
+declare class PluvIO<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TAuthorize extends IOAuthorize<any, any> = BaseIOAuthorize, TContext extends JsonObject = {}, TInput extends EventRecord<string, any> = {}, TOutput extends EventRecord<string, any> = {}> implements IOLike<TAuthorize, TInput, TOutput> {
+    readonly _authorize: TAuthorize | null;
+    readonly _debug: boolean;
+    readonly _events: InferEventConfig<TContext, TInput, TOutput>;
+    readonly _platform: TPlatform;
+    readonly room: string | null;
+    private _context;
+    private _rooms;
+    constructor(options: PluvIOConfig<TPlatform, TAuthorize, TContext, TInput, TOutput>);
+    createToken(params: JWTEncodeParams<InferIOAuthorizeUser<InferIOAuthorize<this>>>): Promise<string>;
+    event<TEvent extends string, TData extends JsonObject = {}, TResult extends EventRecord<string, any> = {}>(event: TEvent, config: EventConfig<TContext, TData, TResult>): PluvIO<TPlatform, TAuthorize, TContext, Spread<[TInput, EventRecord<TEvent, TData>]>, Spread<[TOutput, TResult]>>;
+    getRoom(room: string): IORoom<TPlatform, TAuthorize, TContext, TInput, TOutput>;
+    static merge<TIO1 extends PluvIO, TIO2 extends PluvIO>(first: TIO1, second: TIO2): PluvIO<InferIOPlatform<TIO1>, InferIOAuthorize<TIO1>, InferIOContext<TIO1>, Spread<[InferIOInput<TIO1>, InferIOInput<TIO2>]>, Spread<[InferIOOutput<TIO1>, InferIOOutput<TIO2>]>>;
+    private _logDebug;
+}
+
+interface CreateIOParams<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TContext extends JsonObject = {}, TAuthorizeUser extends BaseUser = BaseUser, TAuthorizeRequired extends boolean = false> {
+    authorize?: IOAuthorize<TAuthorizeUser, TAuthorizeRequired>;
+    context?: TContext;
+    debug?: boolean;
+    platform: TPlatform;
+}
+declare const createIO: <TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TContext extends JsonObject = {}, TAuthorizeUser extends BaseUser = BaseUser, TAuthorizeRequired extends boolean = false>(params: CreateIOParams<TPlatform, TContext, TAuthorizeUser, TAuthorizeRequired>) => PluvIO<TPlatform, IOAuthorize<TAuthorizeUser, TAuthorizeRequired>, TContext, BaseClientEventRecord, BaseIOEventRecord<IOAuthorize<TAuthorizeUser, TAuthorizeRequired>>>;
+
+export { AbstractCloseEvent, AbstractErrorEvent, AbstractEvent, AbstractEventMap, AbstractListener, AbstractMessageEvent, AbstractPersistance, AbstractPlatform, AbstractPubSub, AbstractWebSocket, AbstractWebSocketConfig, AbstractWebSocketHandleErrorParams, AuthorizeModule, AuthorizeParams, ConvertWebSocketConfig, IOPubSubEventMessage, IORoom, InferIORoom, InferWebSocketType, JWT, JWTEncodeParams, PluvIO, createIO };