@pluv/io 0.0.0

package/src/IORoom.ts

@@ -0,0 +1,630 @@
+import type { YjsDoc } from "@pluv/crdt-yjs";
+import { doc } from "@pluv/crdt-yjs";
+import type {
+    BaseIOAuthorize,
+    BaseIOEventRecord,
+    EventMessage,
+    EventRecord,
+    InferEventMessage,
+    InferIOAuthorize,
+    InferIOAuthorizeUser,
+    InferIOInput,
+    IOAuthorize,
+    IOLike,
+    JsonObject,
+} from "@pluv/types";
+import chalk from "chalk";
+import type { AbstractPlatform, InferWebSocketType } from "./AbstractPlatform";
+import { authorize } from "./authorize";
+import type {
+    EventResolverContext,
+    InferEventConfig,
+    SendMessageOptions,
+    WebSocketSession,
+} from "./types";
+
+const PING_TIMEOUT_MS = 30_000;
+
+type BroadcastMessage<TIO extends IORoom<any, any, any, any, any>> =
+    | InferEventMessage<InferIOInput<TIO>>
+    | InferEventMessage<BaseIOEventRecord<InferIOAuthorize<TIO>>>;
+
+interface BroadcastParams<TIO extends IORoom<any, any, any, any, any>> {
+    message: BroadcastMessage<TIO>;
+    senderId?: string;
+}
+
+interface IORoomListeners {
+    onDestroy: () => void;
+}
+
+export 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 SendMessageSender {
+    id: string | null;
+    user: JsonObject | null;
+}
+
+export interface WebsocketRegisterOptions {
+    token?: string;
+}
+
+export 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: TContext;
+    private readonly _debug: boolean;
+    private readonly _platform: TPlatform;
+
+    private _doc: YjsDoc<any> = doc();
+    private _listeners: IORoomListeners;
+    private _sessions = new Map<string, WebSocketSession>();
+    private _uninitialize: (() => Promise<void>) | null = null;
+
+    readonly _authorize: TAuthorize | null = null;
+    readonly _events: InferEventConfig<TContext, TInput, TOutput>;
+
+    readonly room: string;
+
+    constructor(
+        room: string,
+        config: IORoomConfig<TPlatform, TAuthorize, TContext, TInput, TOutput>
+    ) {
+        const { authorize, context, debug, events, onDestroy, platform } =
+            config;
+
+        this._context = context;
+        this._debug = debug;
+        this._events = events;
+        this._platform = platform;
+
+        this.room = room;
+
+        this._listeners = {
+            onDestroy: () => onDestroy?.(),
+        };
+
+        if (authorize) this._authorize = authorize;
+    }
+
+    public broadcast(message: BroadcastMessage<this>): Promise<void> {
+        return Promise.resolve(this._broadcast({ message }));
+    }
+
+    public async register(
+        webSocket: InferWebSocketType<TPlatform>,
+        options?: WebsocketRegisterOptions
+    ): Promise<void> {
+        if (!this._uninitialize) await this._initialize();
+
+        const token = options?.token;
+        const sessionId = this._platform.randomUUID();
+        const pluvWs = this._platform.convertWebSocket(webSocket, {
+            room: this.room,
+        });
+
+        this._logDebug(
+            `${chalk.blue(
+                `Registering connection for room ${this.room}:`
+            )} ${sessionId}`
+        );
+
+        const uninitializeWs = await pluvWs.initialize();
+
+        const user = await this._getAuthorizedUser(token);
+
+        const isUnauthorized = !!this._authorize?.required && !user;
+        // There is an attempt for multiple of the same identities. Probably malicious.
+        const isTokenInUse =
+            !!user &&
+            Array.from(this._sessions.values()).some(
+                (session) => session.user?.id === user.id
+            );
+
+        if (isUnauthorized || isTokenInUse) {
+            this._logDebug(
+                `${chalk.blue(
+                    "Authorization failed for connection:"
+                )} ${sessionId}`
+            );
+
+            pluvWs.handleError({ error: new Error("Not authorized") });
+            pluvWs.close(3000, "WebSocket unauthorized.");
+
+            return;
+        }
+
+        const currentTime = new Date().getTime();
+        const session: WebSocketSession = {
+            id: sessionId,
+            presence: null,
+            quit: false,
+            room: this.room,
+            timers: {
+                ping: currentTime,
+            },
+            webSocket: pluvWs,
+            user,
+        };
+
+        this._sessions.set(session.id, session);
+
+        await this._platform.persistance.addUser(
+            this.room,
+            sessionId,
+            user ?? {}
+        );
+
+        this._emitRegistered(session);
+        this._emitStorageReceived(session);
+        this._emitUserJoined(session);
+
+        const context: EventResolverContext<TContext> = {
+            context: this._context,
+            doc: this._doc,
+            room: this.room,
+            session,
+            sessions: this._sessions,
+        };
+
+        pluvWs.addEventListener("message", (event) => {
+            if (!this._uninitialize) return;
+
+            if (session.quit) {
+                session.webSocket.close(1011, "WebSocket broken.");
+
+                return;
+            }
+
+            const message = this._parseMessage(event);
+
+            if (!message) return;
+
+            const eventConfig = this._getEventConfig(message);
+
+            if (!eventConfig) return;
+
+            this._resolveMessage(message, context).then((output) => {
+                if (!output) return;
+
+                const eventType = eventConfig.options?.type ?? "broadcast";
+
+                switch (eventType) {
+                    case "self": {
+                        Object.entries(output).forEach(([type, data]) => {
+                            this._sendSelfMessage({ data, type }, session);
+                        });
+
+                        return;
+                    }
+                    case "sync": {
+                        this._platform.pubSub.publish(this.room, {
+                            connectionId: session.id,
+                            options: eventConfig.options,
+                            room: this.room,
+                            user: session.user,
+                            ...message,
+                        });
+
+                        Object.entries(output).forEach(([type, data]) => {
+                            this._sendSelfMessage({ data, type }, session);
+                        });
+
+                        return;
+                    }
+                    case "broadcast":
+                    default: {
+                        Object.entries(output).forEach(([type, data]: any) => {
+                            this._broadcast({
+                                message: { data, type },
+                                senderId: session.id,
+                            });
+                        });
+                    }
+                }
+            });
+        });
+
+        const closeHandler = () => {
+            if (!this._uninitialize) return;
+
+            session.quit = true;
+
+            this._logDebug(
+                `${chalk.blue(
+                    `(Unregistering connection for room ${this.room}:`
+                )} ${sessionId}`
+            );
+            this._sessions.delete(session.id);
+
+            this._platform.persistance.deleteUser(this.room, session.id);
+
+            this._broadcast({
+                message: {
+                    type: "$EXIT",
+                    data: { sessionId: session.id },
+                },
+                senderId: session.id,
+            });
+
+            uninitializeWs();
+
+            const size = this._getSessionsSize();
+
+            this._logDebug(
+                `${chalk.blue(
+                    `Unregistered connection for room ${this.room}:`
+                )} ${sessionId}`
+            );
+            this._logDebug(`${chalk.blue(`Room ${this.room} size:`)} ${size}`);
+
+            if (size) return;
+
+            this._uninitialize();
+        };
+
+        pluvWs.addEventListener("close", closeHandler);
+        pluvWs.addEventListener("error", closeHandler);
+
+        this._logDebug(
+            `${chalk.blue(
+                `Registered connection for room ${this.room}:`
+            )} ${sessionId}`
+        );
+
+        const size = this._getSessionsSize();
+
+        this._logDebug(`${chalk.blue(`Room ${this.room} size:`)} ${size}`);
+    }
+
+    private _broadcast(params: BroadcastParams<this>): void {
+        const { message, senderId } = params;
+
+        const currentTime = new Date().getTime();
+        const sender = senderId ? this._sessions.get(senderId) : null;
+
+        const quitters = Array.from(this._sessions.values()).filter(
+            (session) =>
+                session.quit ||
+                currentTime - session.timers.ping > PING_TIMEOUT_MS
+        );
+
+        quitters.forEach((session) => {
+            this._sessions.delete(session.id);
+        });
+
+        this._emitQuitters(quitters);
+
+        this._platform.pubSub.publish(this.room, {
+            connectionId: senderId ?? null,
+            room: this.room,
+            user: sender?.user ?? null,
+            ...message,
+        });
+    }
+
+    private _emitQuitters(quitters: readonly WebSocketSession[]): void {
+        quitters.forEach((quitter) => {
+            this._broadcast({
+                message: {
+                    type: "$EXIT",
+                    data: { sessionId: quitter.id },
+                },
+                senderId: quitter.id,
+            });
+        });
+    }
+
+    private _emitRegistered(session: WebSocketSession): void {
+        this._sendSelfMessage(
+            {
+                type: "$REGISTERED",
+                data: { sessionId: session.id },
+            },
+            session
+        );
+    }
+
+    private _emitStorageReceived(session: WebSocketSession): void {
+        this._platform.persistance.getStorageState(this.room).then((_state) => {
+            const state = _state ?? this._doc.encodeStateAsUpdate();
+
+            this._sendSelfMessage(
+                {
+                    type: "$STORAGE_RECEIVED",
+                    data: { state },
+                },
+                session
+            );
+        });
+    }
+
+    private _emitUserJoined(session: WebSocketSession): void {
+        const user = session.user as any;
+
+        if (!user) return;
+
+        this._broadcast({
+            message: {
+                type: "$USER_JOINED",
+                data: {
+                    connectionId: session.id,
+                    user,
+                },
+            },
+            senderId: session.id,
+        });
+    }
+
+    private async _getAuthorizedUser(
+        token: string | undefined
+    ): Promise<InferIOAuthorizeUser<InferIOAuthorize<this>> | null> {
+        if (!this._authorize) return null;
+        if (!token) return null;
+
+        const payload = await authorize({
+            platform: this._platform,
+            secret: this._authorize.secret,
+        }).decode(token);
+
+        if (!payload) {
+            this._logDebug(chalk.blue("Could not decode token:"));
+            this._logDebug(token);
+
+            return null;
+        }
+
+        if (payload.room !== this.room) {
+            this._logDebug(
+                chalk.blue(`Token is not authorized for room ${this.room}:`)
+            );
+            this._logDebug(chalk.blue("Received:"), payload.room);
+            this._logDebug(token);
+
+            return null;
+        }
+
+        try {
+            return this._authorize.user.parse(payload.user) ?? null;
+        } catch {
+            this._logDebug(`${chalk.blue("Token fails validation:")} ${token}`);
+
+            return null;
+        }
+    }
+
+    private _getSessionsSize(): number {
+        const currentTime = new Date().getTime();
+
+        /**
+         * @description Doing this instead of .size because some sessions
+         * in the map can be considered as "omitted".
+         * @author leedavidcs
+         * @date December 21, 2022
+         */
+        return Array.from(this._sessions.values()).reduce((count, session) => {
+            if (session.quit) return count;
+
+            return currentTime - session.timers.ping > PING_TIMEOUT_MS
+                ? count
+                : count + 1;
+        }, 0);
+    }
+
+    private _getEventConfig(
+        message: EventMessage<string, any>
+    ): InferEventConfig<TContext, TInput, TOutput>[keyof TInput] | null {
+        return this._events[message.type as keyof TInput] ?? null;
+    }
+
+    private async _initialize(): Promise<void> {
+        this._logDebug(`${chalk.blue(`Initializing room ${this.room}:`)}`);
+
+        if (!!this._uninitialize) {
+            await this._uninitialize();
+
+            this._uninitialize = null;
+        }
+
+        const pubSubId = await this._platform.pubSub.subscribe(
+            this.room,
+            ({ options = {}, ...message }) => {
+                const session = {
+                    id: message.connectionId,
+                    user: message.user,
+                };
+
+                this._sendMessage(message, session, options);
+            }
+        );
+
+        this._uninitialize = async () => {
+            this._platform.pubSub.unsubscribe(pubSubId);
+
+            this._doc.destroy();
+            this._doc = doc();
+
+            this._listeners.onDestroy();
+        };
+    }
+
+    private _logDebug(...data: any[]): void {
+        this._debug && console.log(...data);
+    }
+
+    private _parseMessage(message: {
+        data: string | ArrayBuffer;
+    }): EventMessage<string, any> | null {
+        const parsed = this._platform.parseData(message.data);
+
+        try {
+            if (typeof parsed !== "object") return null;
+            if (typeof parsed.type !== "string") return null;
+            if (typeof parsed.data !== "object") return null;
+
+            return parsed as EventMessage<string, any>;
+        } catch {
+            return null;
+        }
+    }
+
+    private async _resolveMessage(
+        message: EventMessage<string, any>,
+        context: EventResolverContext<TContext>
+    ): Promise<TOutput | null> {
+        const { session } = context;
+
+        const eventConfig = this._getEventConfig(message);
+
+        if (!eventConfig) return null;
+
+        let input: TInput[string];
+
+        /**
+         * !HACK
+         * @description If the config doesn't specify validation, we
+         * assume no input is to be expected, but pass through all values
+         * regardless. Leave this up to the implementer of the event.
+         * @author leedavidcs
+         * @date September 25, 2022
+         */
+        try {
+            input = eventConfig.input
+                ? (eventConfig.input.parse(message.data) as TInput[string])
+                : message.data;
+        } catch (error) {
+            session?.webSocket.handleError({
+                error,
+                message: "Invalid input",
+                session,
+            });
+
+            return null;
+        }
+
+        const output = await eventConfig.resolver(input, context);
+
+        if (!output) return null;
+
+        return output;
+    }
+
+    private _sendMessage(
+        message: EventMessage<string, any>,
+        sender: SendMessageSender | null,
+        options: SendMessageOptions = {}
+    ): void {
+        switch (options.type) {
+            case "self": {
+                this._sendSelfMessage(message, sender);
+
+                return;
+            }
+            case "sync": {
+                this._sendSyncMessage(message, sender);
+
+                return;
+            }
+            case "broadcast":
+            default: {
+                const sessionIds = options.sessionIds;
+
+                this._sendBroadcastMessage(message, sender, sessionIds);
+            }
+        }
+    }
+
+    private _sendBroadcastMessage(
+        message: EventMessage<string, any>,
+        sender: SendMessageSender | null,
+        sessionIds?: readonly string[]
+    ): void {
+        const senderId = sender?.id ?? null;
+
+        const sessions =
+            sessionIds?.reduce((dict, id) => {
+                const _session = this._sessions.get(id);
+
+                return _session ? dict.set(id, _session) : dict;
+            }, new Map<string, WebSocketSession>()) ?? this._sessions;
+
+        Array.from(sessions.values()).forEach((_session) => {
+            _session.webSocket.sendMessage({
+                connectionId: senderId,
+                room: this.room,
+                user: _session.user,
+                ...message,
+            });
+        });
+    }
+
+    private _sendSelfMessage(
+        message: EventMessage<string, any>,
+        sender: SendMessageSender | null
+    ): void {
+        const senderId = sender?.id;
+
+        if (!senderId) return;
+
+        const session = this._sessions.get(senderId);
+
+        if (!session) return;
+
+        session.webSocket.sendMessage({
+            connectionId: sender.id,
+            room: this.room,
+            user: sender.user,
+            ...message,
+        });
+    }
+
+    private _sendSyncMessage(
+        message: EventMessage<string, any>,
+        sender: SendMessageSender | null
+    ): void {
+        const senderId = sender?.id;
+
+        if (!senderId) return;
+
+        this._resolveMessage(message, {
+            context: this._context,
+            doc: this._doc,
+            room: this.room,
+            session: null,
+            sessions: this._sessions,
+        }).then((output) => {
+            if (!output) return;
+
+            Object.keys(output).forEach((type: string) => {
+                const data = output[type] ?? {};
+
+                this._platform.pubSub.publish(this.room, {
+                    connectionId: senderId,
+                    data,
+                    options: { type: "self" },
+                    room: this.room,
+                    type,
+                    user: sender.user ?? null,
+                });
+            });
+        });
+    }
+}

package/src/Persistance.ts

@@ -0,0 +1,77 @@
+import type { JsonObject } from "@pluv/types";
+import { AbstractPersistance } from "./AbstractPersistance";
+
+export class Persistance extends AbstractPersistance {
+    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 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 getUsers(room: string): Promise<readonly (JsonObject | null)[]> {
+        const users = this._users.get(room);
+
+        if (!users) return Promise.resolve([]);
+
+        return Promise.resolve(Array.from(users.values()));
+    }
+
+    public setStorageState(room: string, state: string): Promise<void> {
+        this._storages.set(room, state);
+
+        return Promise.resolve();
+    }
+}