@pluv/io 0.19.0 → 0.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/io",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "@pluv/io server-side websocket manager",
   "author": "leedavidcs",
   "license": "MIT",
@@ -17,20 +17,20 @@
     "access": "public"
   },
   "dependencies": {
-    "@panva/hkdf": "^1.2.0",
-    "jose": "^5.6.2",
+    "@panva/hkdf": "^1.2.1",
+    "jose": "^5.6.3",
     "kleur": "^4.1.5",
     "wonka": "^6.3.4",
-    "@pluv/crdt": "^0.19.0",
-    "@pluv/types": "^0.19.0"
+    "@pluv/crdt": "^0.21.0",
+    "@pluv/types": "^0.21.0"
   },
   "devDependencies": {
     "eslint": "^8.57.0",
     "genversion": "^3.2.0",
-    "tsup": "^8.1.0",
-    "typescript": "^5.4.5",
-    "@pluv/tsconfig": "^0.19.0",
-    "eslint-config-pluv": "^0.19.0"
+    "tsup": "^8.2.4",
+    "typescript": "^5.5.4",
+    "@pluv/tsconfig": "^0.21.0",
+    "eslint-config-pluv": "^0.21.0"
   },
   "scripts": {
     "build": "pnpm run version && tsup src/index.ts --format esm,cjs --dts",

package/src/AbstractPlatform.ts

@@ -1,48 +1,92 @@
-import { AbstractPersistance } from "./AbstractPersistance";
+import type { AbstractPersistance } from "./AbstractPersistance";
 import type { AbstractPubSub } from "./AbstractPubSub";
-import type { AbstractWebSocket, AbstractWebSocketConfig } from "./AbstractWebSocket";
+import type { AbstractWebSocket, InferWebSocketSource } from "./AbstractWebSocket";
 import { Persistance } from "./Persistance";
 import { PubSub } from "./PubSub";
+import type { WebSocketSerializedState } from "./types";
+
+export type WebSocketRegistrationMode = "attached" | "detached";
 
 export type InferPlatformWebSocketType<TPlatform extends AbstractPlatform> =
-    TPlatform extends AbstractPlatform<infer IWebSocket> ? IWebSocket : never;
+    TPlatform extends AbstractPlatform<infer IAbstractWebSocket> ? IAbstractWebSocket : never;
 
-export type InferPlatformRoomContextType<TPlatform extends AbstractPlatform> =
-    TPlatform extends AbstractPlatform<any, infer IIOContext> ? IIOContext : never;
+export type InferPlatformWebSocketSource<TPlatform> =
+    TPlatform extends AbstractPlatform<infer IAbstractWebSocket> ? InferWebSocketSource<IAbstractWebSocket> : never;
 
-export type InferPlatformEventContextType<TPlatform extends AbstractPlatform> =
-    TPlatform extends AbstractPlatform<any, any, infer IRoomContext> ? IRoomContext : never;
+export type InferPlatformContextType<TPlatform extends AbstractPlatform> =
+    TPlatform extends AbstractPlatform<any, infer IPlatformContext> ? IPlatformContext : never;
 
-export type AbstractPlatformConfig =
-    | { persistance?: undefined; pubSub?: undefined }
-    | {
-          persistance: AbstractPersistance;
-          pubSub: AbstractPubSub;
-      };
+export type InferRoomContextType<TPlatform extends AbstractPlatform> =
+    TPlatform extends AbstractPlatform<any, infer IPlatformContext, infer IRoomContext>
+        ? IPlatformContext & IRoomContext
+        : never;
 
-export type ConvertWebSocketConfig = AbstractWebSocketConfig;
+export type AbstractPlatformConfig<
+    TPlatformContext extends Record<string, any> = {},
+    TRoomContext extends Record<string, any> = {},
+> = {
+    context?: TPlatformContext & TRoomContext;
+    persistance?: AbstractPersistance;
+    pubSub?: AbstractPubSub;
+};
+
+export interface ConvertWebSocketConfig {
+    room: string;
+}
 
 export abstract class AbstractPlatform<
-    TWebSocket = any,
-    TIOContext extends Record<string, any> = {},
+    TWebSocket extends AbstractWebSocket = AbstractWebSocket,
+    TPlatformContext extends Record<string, any> = {},
     TRoomContext extends Record<string, any> = {},
 > {
-    readonly _ioContext: TIOContext | undefined;
+    private _initialized: boolean = false;
+
+    readonly _ioContext: TPlatformContext | undefined;
     readonly _roomContext: TRoomContext | undefined;
 
+    abstract readonly _registrationMode: WebSocketRegistrationMode;
+
     public persistance: AbstractPersistance;
     public pubSub: AbstractPubSub;
 
-    constructor(config: AbstractPlatformConfig = {}) {
-        const { persistance, pubSub } = config;
+    constructor(config: AbstractPlatformConfig<TPlatformContext, TRoomContext> = {}) {
+        const { context, persistance, pubSub } = config;
+
+        context && (this._ioContext = context);
+        context && (this._roomContext = context);
 
         this.persistance = persistance ?? new Persistance();
         this.pubSub = pubSub ?? new PubSub();
     }
 
-    public abstract convertWebSocket(webSocket: TWebSocket, config: ConvertWebSocketConfig): AbstractWebSocket;
+    public abstract acceptWebSocket(webSocket: AbstractWebSocket): Promise<void>;
+
+    public abstract convertWebSocket(
+        webSocket: InferWebSocketSource<TWebSocket>,
+        config: ConvertWebSocketConfig,
+    ): AbstractWebSocket;
+
+    public abstract getLastPing(webSocket: AbstractWebSocket): number | null;
+
+    public abstract getSerializedState(webSocket: AbstractWebSocket): WebSocketSerializedState | null;
+
+    public abstract getSessionId(webSocket: InferWebSocketSource<TWebSocket>): string | null;
+
+    public abstract getWebSockets(): readonly InferWebSocketSource<TWebSocket>[];
+
+    public abstract initialize(config: AbstractPlatformConfig<TPlatformContext, TRoomContext>): this;
 
     public abstract parseData(data: string | ArrayBuffer): Record<string, any>;
 
     public abstract randomUUID(): string;
+
+    public abstract setSerializedState(webSocket: AbstractWebSocket, state: WebSocketSerializedState): void;
+
+    protected _initialize(): this {
+        if (this._initialized) throw new Error("Platform is already initialized");
+
+        this._initialized = true;
+
+        return this;
+    }
 }

package/src/AbstractWebSocket.ts

@@ -1,5 +1,13 @@
-import type { IOEventMessage, MaybePromise } from "@pluv/types";
-import type { WebSocketSession } from "./types";
+import type {
+    BaseUser,
+    InferIOAuthorizeUser,
+    IOAuthorize,
+    IOEventMessage,
+    JsonObject,
+    MaybePromise,
+} from "@pluv/types";
+import type { AbstractPersistance } from "./AbstractPersistance";
+import type { WebSocketSerializedState, WebSocketSession } from "./types";
 
 export type AbstractEvent = {};
 
@@ -14,7 +22,7 @@ export type AbstractMessageEvent<T = any> = AbstractEvent & {
 
 export type AbstractErrorEvent = AbstractEvent & {
     error: unknown;
-    message: string;
+    message?: string;
 };
 
 export interface AbstractEventMap {
@@ -28,6 +36,7 @@ export type EventType = keyof AbstractEventMap;
 export interface AbstractWebSocketHandleErrorParams {
     error: unknown;
     message?: string;
+    room: string;
     session?: WebSocketSession<any>;
 }
 
@@ -35,13 +44,15 @@ export type AbstractListener<TType extends keyof AbstractEventMap> = (
     event: AbstractEventMap[TType],
 ) => MaybePromise<void>;
 
+export type InferWebSocketSource<TAbstractWebSocket extends AbstractWebSocket> =
+    TAbstractWebSocket extends AbstractWebSocket<infer IWebSocket> ? IWebSocket : never;
+
 export interface AbstractWebSocketConfig {
+    persistance: AbstractPersistance;
     room: string;
-    sessionId: string;
-    userId: string | null;
 }
 
-export abstract class AbstractWebSocket {
+export abstract class AbstractWebSocket<TWebSocket = any> {
     /** The connection is not yet open. */
     public readonly CONNECTING = 0;
     /** The connection is open and ready to communicate. */
@@ -51,16 +62,23 @@ export abstract class AbstractWebSocket {
     /** The connection is closed. */
     public readonly CLOSED = 3;
 
-    public room: string;
-    public sessionId: string;
+    public readonly persistance: AbstractPersistance;
+    public readonly room: string;
+    public readonly webSocket: TWebSocket;
 
+    private _user: BaseUser | null = null;
+
+    public abstract set presence(presence: JsonObject | null);
     public abstract get readyState(): 0 | 1 | 2 | 3;
+    public abstract get sessionId(): string;
+    public abstract get state(): WebSocketSerializedState;
 
-    constructor(config: AbstractWebSocketConfig) {
-        const { room, sessionId } = config;
+    constructor(webSocket: TWebSocket, config: AbstractWebSocketConfig) {
+        const { persistance, room } = config;
 
+        this.persistance = persistance;
         this.room = room;
-        this.sessionId = sessionId;
+        this.webSocket = webSocket;
     }
 
     /**
@@ -77,21 +95,37 @@ export abstract class AbstractWebSocket {
 
     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 async getSession<TAuthorize extends IOAuthorize<any, any, any>>(): Promise<WebSocketSession<TAuthorize>> {
+        const sessionId = this.sessionId;
+        const state = this.state;
+        const room = state.room;
+
+        const user = this._user ?? (await this.persistance.getUser(room, sessionId));
+
+        this._user = user as BaseUser;
+
+        return {
+            ...state,
+            id: sessionId,
+            user: user as InferIOAuthorizeUser<TAuthorize>,
+            webSocket: this,
+        };
+    }
+
     public handleError(params: AbstractWebSocketHandleErrorParams): void {
-        const { error, message = error instanceof Error ? error.message : "Unexpected error", session } = params;
+        const { error, message: _message, room, session } = params;
 
-        const stack: string | null = error instanceof Error ? error.stack ?? null : null;
+        const message = error instanceof Error ? error.message : "Unexpected error";
+        const stack: string | null = error instanceof Error ? (error.stack ?? null) : null;
 
         return this.sendMessage({
             connectionId: session?.id ?? null,
             data: { message, stack },
-            room: this.room,
+            room,
             type: "$ERROR",
             user: session?.user ?? null,
         });