@pluv/platform-node 5.0.1 → 5.0.3

package/eslint.config.mjs

@@ -1,4 +0,0 @@
-import { config } from "eslint-config-pluv/base";
-
-/** @type {import("eslint").Linter.Config} */
-export default config;

package/src/NodePlatform.ts

@@ -1,151 +0,0 @@
-import type {
-    AbstractPersistence,
-    AbstractPlatformConfig,
-    AbstractPubSub,
-    ConvertWebSocketConfig,
-    WebSocketRegistrationMode,
-    WebSocketSerializedState,
-} from "@pluv/io";
-import { AbstractPlatform } from "@pluv/io";
-import type { IOAuthorize, Json } from "@pluv/types";
-import crypto from "node:crypto";
-import { TextDecoder } from "node:util";
-import type { WebSocket } from "ws";
-import { NodeWebSocket } from "./NodeWebSocket";
-import type { NodeRegisterInput } from "./types";
-
-export type NodePlatformRoomContext<TMeta extends Record<string, Json>> = keyof TMeta extends never
-    ? { meta?: undefined }
-    : { meta: TMeta };
-
-export type NodePlatformConfig<TMeta extends Record<string, Json>> = {
-    mode?: WebSocketRegistrationMode;
-    origin?: string;
-} & (
-    | { persistence?: undefined; pubSub?: undefined }
-    | { persistence: AbstractPersistence; pubSub: AbstractPubSub }
-) & { roomContext?: NodePlatformRoomContext<TMeta> };
-
-export class NodePlatform<
-    TAuthorize extends IOAuthorize<any, any> | null = null,
-    TMeta extends Record<string, Json> = {},
-> extends AbstractPlatform<
-    NodeWebSocket<TAuthorize>,
-    NodeRegisterInput,
-    NodePlatformRoomContext<TMeta>,
-    {
-        authorize: {
-            secret: true;
-        };
-        handleMode: "io";
-        requireAuth: false;
-        registrationMode: WebSocketRegistrationMode;
-        listeners: {
-            onRoomDestroyed: true;
-            onRoomMessage: true;
-            onStorageDestroyed: true;
-            onStorageUpdated: true;
-            onUserConnected: true;
-            onUserDisconnected: true;
-        };
-        router: true;
-    }
-> {
-    public readonly id = crypto.randomUUID();
-    public readonly _config;
-    public readonly _name = "platformNode";
-    public readonly origin: string | undefined;
-
-    constructor(config: NodePlatformConfig<TMeta> = {}) {
-        const { origin, roomContext, mode = "attached", persistence, pubSub } = config;
-
-        super({
-            roomContext,
-            ...(persistence && pubSub ? { persistence, pubSub } : {}),
-        });
-
-        this.origin = origin;
-
-        this._config = {
-            authorize: {
-                secret: true as const,
-            },
-            handleMode: "io" as const,
-            registrationMode: mode,
-            requireAuth: false as const,
-            listeners: {
-                onRoomDestroyed: true as const,
-                onRoomMessage: true as const,
-                onStorageDestroyed: true as const,
-                onStorageUpdated: true as const,
-                onUserConnected: true as const,
-                onUserDisconnected: true as const,
-            },
-            router: true as const,
-        };
-    }
-
-    public acceptWebSocket(webSocket: NodeWebSocket<TAuthorize>): Promise<void> {
-        return Promise.resolve(undefined);
-    }
-
-    public convertWebSocket(
-        webSocket: WebSocket,
-        config: ConvertWebSocketConfig,
-    ): NodeWebSocket<TAuthorize> {
-        const { room } = config;
-
-        return new NodeWebSocket<TAuthorize>(webSocket, {
-            persistence: this.persistence,
-            platform: this,
-            room,
-        });
-    }
-
-    public getLastPing(webSocket: NodeWebSocket<TAuthorize>): number | null {
-        return null;
-    }
-
-    public getSerializedState(webSocket: WebSocket): WebSocketSerializedState | null {
-        return null;
-    }
-
-    public getSessionId(webSocket: WebSocket): string | null {
-        return null;
-    }
-
-    public getWebSockets(): readonly WebSocket[] {
-        return [];
-    }
-
-    public initialize(config: AbstractPlatformConfig<NodePlatformRoomContext<TMeta>>): this {
-        return new NodePlatform({
-            mode: this._config.registrationMode,
-            origin: this.origin,
-            persistence: this.persistence.initialize(config.roomContext),
-            pubSub: this.pubSub,
-            roomContext: config.roomContext,
-        } as NodePlatformConfig<TMeta>)._initialize() as this;
-    }
-
-    public parseData(data: string | ArrayBuffer): Record<string, any> {
-        if (typeof data === "string") return JSON.parse(data);
-
-        const decoder = new TextDecoder("utf8");
-
-        return JSON.parse(decoder.decode(data));
-    }
-
-    public randomUUID(): string {
-        return crypto.randomUUID();
-    }
-
-    public setSerializedState(
-        webSocket: NodeWebSocket<TAuthorize>,
-        state: WebSocketSerializedState,
-    ): WebSocketSerializedState {
-        webSocket.state = state;
-
-        return webSocket.state;
-    }
-}

package/src/NodeWebSocket.ts

@@ -1,144 +0,0 @@
-import type {
-    AbstractCloseEvent,
-    AbstractErrorEvent,
-    AbstractEventMap,
-    AbstractListener,
-    AbstractMessageEvent,
-    AbstractWebSocketConfig,
-    WebSocketSerializedState,
-    WebSocketSession,
-} from "@pluv/io";
-import { AbstractWebSocket } from "@pluv/io";
-import type { InferIOAuthorizeUser, IOAuthorize, JsonObject } from "@pluv/types";
-import crypto from "node:crypto";
-import type { WebSocket } from "ws";
-
-export interface NodeWebSocketEventMap {
-    close: AbstractCloseEvent;
-    message: AbstractMessageEvent;
-    error: AbstractErrorEvent;
-}
-
-export type NodeWebSocketConfig = AbstractWebSocketConfig;
-
-export class NodeWebSocket<
-    TAuthorize extends IOAuthorize<any, any> | null = null,
-> extends AbstractWebSocket<WebSocket> {
-    private _sessionId: string | null = null;
-    private _state: WebSocketSerializedState;
-    private _user: InferIOAuthorizeUser<TAuthorize> = null as InferIOAuthorizeUser<TAuthorize>;
-
-    public set presence(presence: JsonObject | null) {
-        this._state.presence = presence;
-    }
-
-    public get readyState(): 0 | 1 | 2 | 3 {
-        return this.webSocket.readyState;
-    }
-
-    public get session(): WebSocketSession<TAuthorize> {
-        const sessionId = this.sessionId;
-        const state = this._state;
-        const user = this._user;
-
-        return {
-            ...state,
-            id: sessionId,
-            user,
-            webSocket: this,
-        };
-    }
-
-    public get sessionId(): string {
-        if (this._sessionId) return this._sessionId;
-
-        const sessionId = this._sessionId ?? `p_${crypto.randomUUID()}`;
-
-        this._sessionId = sessionId;
-
-        return sessionId;
-    }
-
-    public get state(): WebSocketSerializedState {
-        return this._state;
-    }
-
-    public set state(state: WebSocketSerializedState) {
-        this._state = state;
-    }
-
-    public set user(user: InferIOAuthorizeUser<TAuthorize>) {
-        this._user = user;
-    }
-
-    constructor(webSocket: WebSocket, config: NodeWebSocketConfig) {
-        const { room } = config;
-
-        super(webSocket, config);
-
-        this._state = {
-            presence: null,
-            quit: false,
-            room,
-            timers: {
-                ping: new Date().getTime(),
-                presence: null,
-            },
-        };
-    }
-
-    public addEventListener<TType extends keyof AbstractEventMap>(
-        type: TType,
-        handler: AbstractListener<TType>,
-    ): void {
-        switch (type) {
-            case "close":
-                this.webSocket.on("close", async (code, buffer) => {
-                    const reason = buffer.toString("utf-8");
-
-                    await Promise.resolve((handler as AbstractListener<"close">)({ code, reason }));
-                });
-
-                return;
-            case "error":
-                this.webSocket.on("error", async (error) => {
-                    const message = error.message;
-
-                    await Promise.resolve(
-                        (handler as AbstractListener<"error">)({ error, message }),
-                    );
-                });
-
-                return;
-            case "message":
-                this.webSocket.on("message", async (data) => {
-                    await Promise.resolve((handler as AbstractListener<"message">)({ data }));
-                });
-
-                return;
-            default:
-        }
-    }
-
-    public close(code?: number | undefined, reason?: string | undefined): void {
-        const canClose = [this.CONNECTING, this.OPEN].some(
-            (readyState) => readyState === this.readyState,
-        );
-
-        if (!canClose) return;
-
-        this.webSocket.close(code, reason);
-    }
-
-    public send(message: string | ArrayBuffer | ArrayBufferView): void {
-        if (this.readyState !== this.OPEN) return;
-
-        this.webSocket.send(message, (error) => {
-            if (error) throw error;
-        });
-    }
-
-    public terminate(): void {
-        this.webSocket.terminate();
-    }
-}

package/src/index.ts

@@ -1,9 +0,0 @@
-export type { WebSocket } from "ws";
-export { infer } from "./infer";
-export type { InferCallback } from "./infer";
-export type { NodePlatform, NodePlatformConfig } from "./NodePlatform";
-export { platformNode } from "./platformNode";
-export type { PlatformNodeCreateIOParams } from "./platformNode";
-export type { NodeAuthorizeContext, NodeRegisterInput } from "./types";
-export { toRequest } from "./utils/toRequest";
-export type { ToRequestOptions } from "./utils/toRequest";

package/src/infer.ts

@@ -1,9 +0,0 @@
-import type { Json } from "@pluv/types";
-import type { identity } from "./utils";
-
-export type InferCallback<TMeta extends Record<string, Json> = {}> = (i: typeof identity) => {
-    meta?: (io: TMeta) => TMeta;
-};
-
-export const infer = <TMeta extends Record<string, Json> = {}>(callback: InferCallback<TMeta>) =>
-    callback;

package/src/platformNode.ts

@@ -1,61 +0,0 @@
-import type { CrdtLibraryType, NoopCrdtDocFactory } from "@pluv/crdt";
-import type { CreateIOParams, PluvContext, PluvIOAuthorize } from "@pluv/io";
-import type { BaseUser, Id, IOAuthorize, Json } from "@pluv/types";
-import type { IncomingMessage } from "node:http";
-import type { NodePlatformConfig } from "./NodePlatform";
-import { NodePlatform } from "./NodePlatform";
-import type { InferCallback } from "./infer";
-import type { NodeAuthorizeContext } from "./types";
-import { toRequest } from "./utils/toRequest";
-
-export type PlatformNodeCreateIOParams<
-    TMeta extends Record<string, Json> = {},
-    TContext extends Record<string, any> = {},
-    TUser extends BaseUser | null = null,
-    TCrdt extends CrdtLibraryType<any> = CrdtLibraryType<NoopCrdtDocFactory>,
-> = Id<
-    NodePlatformConfig<TMeta> &
-        Omit<
-            CreateIOParams<
-                NodePlatform<IOAuthorize<TUser, TContext>, TMeta>,
-                TContext,
-                TUser,
-                TCrdt
-            >,
-            "authorize" | "context" | "platform"
-        > & {
-            authorize?: PluvIOAuthorize<
-                NodePlatform<IOAuthorize<TUser, TContext>, TMeta>,
-                TUser,
-                NodeAuthorizeContext
-            >;
-            context?: PluvContext<NodePlatform<IOAuthorize<TUser, any>, TMeta>, TContext>;
-            types?: InferCallback<TMeta>;
-        }
->;
-
-export const platformNode = <
-    TMeta extends Record<string, Json> = {},
-    TContext extends Record<string, any> = {},
-    TUser extends BaseUser | null = null,
-    TCrdt extends CrdtLibraryType<any> = CrdtLibraryType<NoopCrdtDocFactory>,
->(
-    config: PlatformNodeCreateIOParams<TMeta, TContext, TUser, TCrdt> = {},
-): CreateIOParams<NodePlatform<IOAuthorize<TUser, TContext>, TMeta>, TContext, TUser, TCrdt> => {
-    const { authorize, context, crdt, debug, limits, origin } = config;
-
-    const resolvedAuthorize =
-        typeof authorize === "function"
-            ? (input: { request: Request | IncomingMessage }) =>
-                  authorize({ request: toRequest(input.request, { origin }) })
-            : authorize;
-
-    return {
-        authorize: resolvedAuthorize,
-        context,
-        crdt,
-        debug,
-        limits,
-        platform: () => new NodePlatform<IOAuthorize<TUser, TContext>, TMeta>(config),
-    };
-};

package/src/types.ts

@@ -1,5 +0,0 @@
-import type { IncomingMessage } from "node:http";
-
-export type NodeRegisterInput = { request: Request | IncomingMessage };
-
-export type NodeAuthorizeContext = { request: Request };

package/src/utils/identity.ts

@@ -1 +0,0 @@
-export const identity = <T extends unknown>(x: T): T => x;

package/src/utils/index.ts

@@ -1,3 +0,0 @@
-export { identity } from "./identity";
-export { toRequest } from "./toRequest";
-export type { ToRequestOptions } from "./toRequest";

package/src/utils/toRequest.ts

@@ -1,69 +0,0 @@
-import type { IncomingMessage } from "node:http";
-import { Readable } from "node:stream";
-
-const getHeader = (incoming: IncomingMessage, name: string): string | undefined => {
-    const value = incoming.headers[name];
-
-    if (Array.isArray(value)) return value[0];
-
-    return value;
-};
-
-const inferOrigin = (incoming: IncomingMessage): string => {
-    const host =
-        getHeader(incoming, "x-forwarded-host") ?? getHeader(incoming, "host") ?? "localhost";
-    const forwardedProto = getHeader(incoming, "x-forwarded-proto");
-    const protocol =
-        forwardedProto ??
-        ((incoming.socket as { encrypted?: boolean }).encrypted ? "https" : "http");
-
-    return `${protocol}://${host}`;
-};
-
-const toHeaders = (incoming: IncomingMessage): Headers => {
-    const headers = new Headers();
-
-    for (const [key, value] of Object.entries(incoming.headers)) {
-        if (value == null) continue;
-
-        if (Array.isArray(value)) {
-            for (const item of value) headers.append(key, item);
-
-            continue;
-        }
-
-        headers.append(key, value);
-    }
-
-    return headers;
-};
-
-export type ToRequestOptions = {
-    origin?: string;
-};
-
-export const toRequest = (
-    request: Request | IncomingMessage,
-    options: ToRequestOptions = {},
-): Request => {
-    if (request instanceof Request) return request;
-
-    const origin = options.origin ?? inferOrigin(request);
-    const url = new URL(request.url ?? "/", origin);
-    const method = request.method ?? "GET";
-    const headers = toHeaders(request);
-
-    if (method === "GET" || method === "HEAD") {
-        return new Request(url, {
-            headers,
-            method,
-        });
-    }
-
-    return new Request(url, {
-        body: Readable.toWeb(request) as ReadableStream,
-        duplex: "half",
-        headers,
-        method,
-    });
-};

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-	"extends": "@pluv/tsconfig/library.json",
-	"include": ["**/*.ts"],
-	"exclude": ["node_modules"],
-	"compilerOptions": {
-		"types": ["@types/node"]
-	}
-}

package/tsdown.config.ts

@@ -1,14 +0,0 @@
-import { defineConfig } from "tsdown";
-
-export default defineConfig({
-    format: ["esm"],
-    dts: true,
-    outDir: "dist",
-    entry: "src/index.ts",
-    target: "esnext",
-    sourcemap: true,
-    clean: true,
-    exports: {
-        all: true,
-    },
-});