@pluv/io 0.0.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@pluv/io",
+  "version": "0.0.0",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@panva/hkdf": "^1.0.2",
+    "@pluv/crdt-yjs": "^0.0.0",
+    "@pluv/types": "^0.0.0",
+    "chalk": "^4.1.2",
+    "jose": "^4.11.2",
+    "wonka": "^6.1.2"
+  },
+  "peerDependencies": {
+    "yjs": "^13.0.0"
+  },
+  "devDependencies": {
+    "@pluv/tsconfig": "^0.0.0",
+    "eslint-config-pluv": "^0.0.0",
+    "tsup": "^6.5.0",
+    "typescript": "^4.9.4",
+    "yjs": "^13.5.44"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "lint": "eslint src/**/*.ts* --fix",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  }
+}

package/src/AbstractPersistance.ts

@@ -0,0 +1,31 @@
+import { JsonObject } from "@pluv/types";
+
+export abstract class AbstractPersistance {
+    public abstract addUser(
+        room: string,
+        connectionId: string,
+        user: JsonObject | null
+    ): Promise<void>;
+
+    public abstract deleteStorageState(room: string): Promise<void>;
+
+    public abstract deleteUser(
+        room: string,
+        connectionId: string
+    ): Promise<void>;
+
+    public abstract deleteUsers(room: string): Promise<void>;
+
+    public abstract getStorageState(room: string): Promise<string | null>;
+
+    public abstract getUser(
+        room: string,
+        connectionId: string
+    ): Promise<JsonObject | null>;
+
+    public abstract getUsers(
+        room: string
+    ): Promise<readonly (JsonObject | null)[]>;
+
+    public abstract setStorageState(room: string, state: string): Promise<void>;
+}

package/src/AbstractPlatform.ts

@@ -0,0 +1,40 @@
+import { AbstractPersistance } from "./AbstractPersistance";
+import type { AbstractPubSub } from "./AbstractPubSub";
+import type { AbstractWebSocket } from "./AbstractWebSocket";
+import { Persistance } from "./Persistance";
+import { PubSub } from "./PubSub";
+
+export type InferWebSocketType<TPlatform extends AbstractPlatform<any>> =
+    TPlatform extends AbstractPlatform<infer IWebSocket> ? IWebSocket : never;
+
+export type AbstractPlatformConfig =
+    | { persistance?: undefined; pubSub?: undefined }
+    | {
+          persistance: AbstractPersistance;
+          pubSub: AbstractPubSub;
+      };
+
+export interface ConvertWebSocketConfig {
+    room: string;
+}
+
+export abstract class AbstractPlatform<TWebSocket = any> {
+    public persistance: AbstractPersistance;
+    public pubSub: AbstractPubSub;
+
+    constructor(config: AbstractPlatformConfig = {}) {
+        const { persistance, pubSub } = config;
+
+        this.persistance = persistance ?? new Persistance();
+        this.pubSub = pubSub ?? new PubSub();
+    }
+
+    public abstract convertWebSocket(
+        webSocket: TWebSocket,
+        config: ConvertWebSocketConfig
+    ): AbstractWebSocket;
+
+    public abstract parseData(data: string | ArrayBuffer): Record<string, any>;
+
+    public abstract randomUUID(): string;
+}

package/src/AbstractPubSub.ts

@@ -0,0 +1,23 @@
+import type { IOEventMessage, IOLike, InferIOOutput } from "@pluv/types";
+import type { SendMessageOptions } from "./types";
+
+export type IOPubSubEventMessage<
+    TIO extends IOLike,
+    TEvent extends keyof InferIOOutput<TIO> = keyof InferIOOutput<TIO>
+> = IOEventMessage<TIO, TEvent> & {
+    options?: SendMessageOptions;
+};
+
+export abstract class AbstractPubSub {
+    public abstract publish(
+        roomName: string,
+        payload: IOPubSubEventMessage<any>
+    ): Promise<void>;
+
+    public abstract subscribe(
+        roomName: string,
+        onMessage: (message: IOPubSubEventMessage<any>) => void
+    ): Promise<number>;
+
+    public abstract unsubscribe(subscriptionId: number): void;
+}

package/src/AbstractWebSocket.ts

@@ -0,0 +1,117 @@
+import type { IOEventMessage, MaybePromise } from "@pluv/types";
+import type { AbstractPubSub } from "./AbstractPubSub";
+import type { WebSocketSession } from "./types";
+
+export type AbstractEvent = {};
+
+export type AbstractCloseEvent = AbstractEvent & {
+    readonly code: number;
+    readonly reason: string;
+};
+
+export type AbstractMessageEvent<T = any> = AbstractEvent & {
+    readonly data: T;
+};
+
+export type AbstractErrorEvent = AbstractEvent & {
+    error: unknown;
+    message: string;
+};
+
+export interface AbstractEventMap {
+    close: AbstractCloseEvent;
+    message: AbstractMessageEvent;
+    error: AbstractErrorEvent;
+}
+
+export type EventType = keyof AbstractEventMap;
+
+export interface AbstractWebSocketHandleErrorParams {
+    error: unknown;
+    message?: string;
+    session?: WebSocketSession;
+}
+
+export type AbstractListener<TType extends keyof AbstractEventMap> = (
+    event: AbstractEventMap[TType]
+) => MaybePromise<void>;
+
+export interface AbstractWebSocketConfig {
+    pubSub?: AbstractPubSub;
+    room: string;
+}
+
+export abstract class AbstractWebSocket {
+    /** The connection is not yet open. */
+    public readonly CONNECTING = 0;
+    /** The connection is open and ready to communicate. */
+    public readonly OPEN = 1;
+    /** The connection is in the process of closing. */
+    public readonly CLOSING = 2;
+    /** The connection is closed. */
+    public readonly CLOSED = 3;
+
+    public pubSub?: AbstractPubSub;
+    public room: string;
+
+    public abstract get readyState(): 0 | 1 | 2 | 3;
+
+    constructor(config: AbstractWebSocketConfig) {
+        const { room } = config;
+
+        this.room = room;
+    }
+
+    /**
+     * 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
+     */
+    public abstract addEventListener<TType extends EventType>(
+        type: TType,
+        handler: AbstractListener<TType>
+    ): void;
+
+    public abstract close(
+        code?: number | undefined,
+        reason?: string | undefined
+    ): void;
+
+    public abstract initialize(): Promise<() => void>;
+
+    public abstract send(message: ArrayBuffer | ArrayBufferView | string): void;
+
+    public abstract terminate(): void;
+
+    public handleError(params: AbstractWebSocketHandleErrorParams): void {
+        const {
+            error,
+            message = error instanceof Error
+                ? error.message
+                : "Unexpected error",
+            session,
+        } = params;
+
+        const stack: string | null =
+            error instanceof Error ? error.stack ?? null : null;
+
+        return this.sendMessage({
+            connectionId: session?.id ?? null,
+            data: { message, stack },
+            room: this.room,
+            type: "$ERROR",
+            user: session?.user ?? null,
+        });
+    }
+
+    public sendMessage<
+        TMessage extends IOEventMessage<any> = IOEventMessage<any>
+    >(data: TMessage): void {
+        return this.send(JSON.stringify(data));
+    }
+}