@pluv/platform-node 0.0.0-experimental-20250527040415

package/dist/index.mjs

@@ -0,0 +1,334 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/createPluvHandler.ts
+import Url from "url";
+import { match } from "path-to-regexp";
+import { WebSocketServer } from "ws";
+var handle = (ws) => ({
+  invalidEndpoint: () => {
+    ws.close(1003, "Invalid WebSocket endpoint");
+    return { matched: false };
+  },
+  invalidRoom: () => {
+    ws.close(1003, "Invalid room name");
+    return { matched: true };
+  },
+  invalidToken: () => {
+    ws.close(1003, "Invalid authentication token");
+    return { matched: true };
+  }
+});
+var createPluvHandler = (config) => {
+  const { authorize, endpoint = "/api/pluv", io, server } = config;
+  if (io._defs.platform._config.registrationMode === "detached") {
+    throw new Error("Cannot use createPluvHandler in detached mode for Node.js");
+  }
+  const wsServer = new WebSocketServer({ server });
+  const rooms = /* @__PURE__ */ new Map();
+  const getRoom = (roomId) => {
+    Array.from(rooms.values()).forEach((room) => {
+      if (!room.getSize()) rooms.delete(room.id);
+    });
+    const existing = rooms.get(roomId);
+    if (existing) return existing;
+    const newRoom = io.createRoom(roomId, {
+      onDestroy: (event) => {
+        rooms.delete(event.room);
+      }
+    });
+    rooms.set(roomId, newRoom);
+    return newRoom;
+  };
+  const wsHandler = (ws, req) => __async(null, null, function* () {
+    var _a;
+    const url = req.url;
+    const onError = handle(ws);
+    if (!url) {
+      onError.invalidEndpoint();
+      return { matched: false };
+    }
+    const parsed = Url.parse(url, true);
+    const { pathname } = parsed;
+    if (!pathname) return onError.invalidEndpoint();
+    const matcher = match(`${endpoint}/room/:roomId`);
+    const matched = matcher(pathname);
+    if (!matched) return onError.invalidEndpoint();
+    const { roomId } = matched.params;
+    if (!roomId) return onError.invalidRoom();
+    const token = ((_a = parsed.query) == null ? void 0 : _a.token) || void 0;
+    if (Array.isArray(token)) return onError.invalidToken();
+    const room = getRoom(roomId);
+    yield room.register(ws, { req, token });
+    return { matched: true };
+  });
+  const createWsServer = () => {
+    return wsServer.on("connection", (ws, req) => __async(null, null, function* () {
+      yield wsHandler(ws, req);
+    }));
+  };
+  const handler = (req, res, next) => __async(null, null, function* () {
+    var _a, _b, _c, _d, _e, _f;
+    if (!authorize) return (_a = next == null ? void 0 : next()) != null ? _a : null;
+    if (req.method !== "GET") return (_b = next == null ? void 0 : next()) != null ? _b : null;
+    const url = req.url;
+    if (!url) return (_c = next == null ? void 0 : next()) != null ? _c : null;
+    const parsed = Url.parse(url, true);
+    const { pathname } = parsed;
+    if (!pathname) return (_d = next == null ? void 0 : next()) != null ? _d : null;
+    const matcher = match(`${endpoint}/authorize`);
+    const matched = matcher(pathname);
+    if (!matched) return (_e = next == null ? void 0 : next()) != null ? _e : null;
+    const room = ((_f = parsed.query) == null ? void 0 : _f.room) || void 0;
+    if (typeof room !== "string" || !room) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      return res.end("Room does not exist");
+    }
+    try {
+      const user = yield authorize({ req, room });
+      if (!user) throw new Error();
+      const token = yield io.createToken({
+        req,
+        room,
+        user
+      });
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      return res.end(token);
+    } catch (err) {
+      res.writeHead(403, { "Content-Type": "text/plain" });
+      return res.end(err instanceof Error ? err.message : "Unauthorized");
+    }
+  });
+  return {
+    createWsServer,
+    handler,
+    wsHandler
+  };
+};
+
+// src/infer.ts
+var infer = (callback) => callback;
+
+// src/NodePlatform.ts
+import { AbstractPlatform } from "@pluv/io";
+import crypto2 from "crypto";
+import { TextDecoder } from "util";
+
+// src/NodeWebSocket.ts
+import { AbstractWebSocket } from "@pluv/io";
+import crypto from "crypto";
+var NodeWebSocket = class extends AbstractWebSocket {
+  constructor(webSocket, config) {
+    const { room } = config;
+    super(webSocket, config);
+    this._sessionId = null;
+    this._user = null;
+    this._state = {
+      presence: null,
+      quit: false,
+      room,
+      timers: {
+        ping: (/* @__PURE__ */ new Date()).getTime(),
+        presence: null
+      }
+    };
+  }
+  set presence(presence) {
+    this._state.presence = presence;
+  }
+  get readyState() {
+    return this.webSocket.readyState;
+  }
+  get session() {
+    const sessionId = this.sessionId;
+    const state = this._state;
+    const user = this._user;
+    return __spreadProps(__spreadValues({}, state), {
+      id: sessionId,
+      user,
+      webSocket: this
+    });
+  }
+  get sessionId() {
+    var _a;
+    if (this._sessionId) return this._sessionId;
+    const sessionId = (_a = this._sessionId) != null ? _a : `p_${crypto.randomUUID()}`;
+    this._sessionId = sessionId;
+    return sessionId;
+  }
+  get state() {
+    return this._state;
+  }
+  set state(state) {
+    this._state = state;
+  }
+  set user(user) {
+    this._user = user;
+  }
+  addEventListener(type, handler) {
+    switch (type) {
+      case "close":
+        this.webSocket.on("close", (code, buffer) => __async(this, null, function* () {
+          const reason = buffer.toString("utf-8");
+          yield Promise.resolve(handler({ code, reason }));
+        }));
+        return;
+      case "error":
+        this.webSocket.on("error", (error) => __async(this, null, function* () {
+          const message = error.message;
+          yield Promise.resolve(
+            handler({ error, message })
+          );
+        }));
+        return;
+      case "message":
+        this.webSocket.on("message", (data) => __async(this, null, function* () {
+          yield Promise.resolve(handler({ data }));
+        }));
+        return;
+      default:
+    }
+  }
+  close(code, reason) {
+    const canClose = [this.CONNECTING, this.OPEN].some(
+      (readyState) => readyState === this.readyState
+    );
+    if (!canClose) return;
+    this.webSocket.close(code, reason);
+  }
+  send(message) {
+    if (this.readyState !== this.OPEN) return;
+    this.webSocket.send(message, (error) => {
+      if (error) throw error;
+    });
+  }
+  terminate() {
+    this.webSocket.terminate();
+  }
+};
+
+// src/NodePlatform.ts
+var NodePlatform = class _NodePlatform extends AbstractPlatform {
+  constructor(config = {}) {
+    const { roomContext, mode = "attached", persistence, pubSub } = config;
+    super(__spreadValues({
+      roomContext
+    }, persistence && pubSub ? { persistence, pubSub } : {}));
+    this.id = crypto2.randomUUID();
+    this._name = "platformNode";
+    this._config = {
+      authorize: {
+        secret: true
+      },
+      handleMode: "io",
+      registrationMode: mode,
+      requireAuth: false,
+      listeners: {
+        onRoomDeleted: true,
+        onRoomMessage: true,
+        onStorageUpdated: true,
+        onUserConnected: true,
+        onUserDisconnected: true
+      },
+      router: true
+    };
+  }
+  acceptWebSocket(webSocket) {
+    return Promise.resolve(void 0);
+  }
+  convertWebSocket(webSocket, config) {
+    const { room } = config;
+    return new NodeWebSocket(webSocket, {
+      persistence: this.persistence,
+      platform: this,
+      room
+    });
+  }
+  getLastPing(webSocket) {
+    return null;
+  }
+  getSerializedState(webSocket) {
+    return null;
+  }
+  getSessionId(webSocket) {
+    return null;
+  }
+  getWebSockets() {
+    return [];
+  }
+  initialize(config) {
+    return new _NodePlatform({
+      roomContext: config.roomContext,
+      mode: this._config.registrationMode,
+      persistence: this.persistence.initialize(config.roomContext),
+      pubSub: this.pubSub
+    })._initialize();
+  }
+  parseData(data) {
+    if (typeof data === "string") return JSON.parse(data);
+    const decoder = new TextDecoder("utf8");
+    return JSON.parse(decoder.decode(data));
+  }
+  randomUUID() {
+    return crypto2.randomUUID();
+  }
+  setSerializedState(webSocket, state) {
+    webSocket.state = state;
+    return webSocket.state;
+  }
+};
+
+// src/platformNode.ts
+var platformNode = (config = {}) => {
+  const { authorize, context, crdt, debug, limits } = config;
+  return {
+    authorize,
+    context,
+    crdt,
+    debug,
+    limits,
+    platform: () => new NodePlatform(config)
+  };
+};
+export {
+  createPluvHandler,
+  infer,
+  platformNode
+};

package/eslint.config.mjs

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

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@pluv/platform-node",
+  "version": "0.0.0-experimental-20250527040415",
+  "description": "@pluv/io adapter for node.js",
+  "author": "leedavidcs",
+  "license": "MIT",
+  "homepage": "https://github.com/pluv-io/pluv",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pluv-io/pluv.git",
+    "directory": "packages/platform-node"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@types/node": "^22.15.21",
+    "@types/ws": "^8.18.1",
+    "path-to-regexp": "^8.2.0",
+    "@pluv/io": "^0.0.0-experimental-20250527040415",
+    "@pluv/types": "^0.0.0-experimental-20250527040415"
+  },
+  "devDependencies": {
+    "eslint": "^9.27.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "ws": "^8.18.2",
+    "@pluv/tsconfig": "^0.0.0-experimental-20250527040415",
+    "eslint-config-pluv": "^0.0.0-experimental-20250527040415"
+  },
+  "peerDependencies": {
+    "ws": "^8.0.0"
+  },
+  "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 --max-warnings 0",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  }
+}

package/src/NodePlatform.ts

@@ -0,0 +1,144 @@
+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 type { IncomingMessage } from "node:http";
+import { TextDecoder } from "node:util";
+import type { WebSocket } from "ws";
+import { NodeWebSocket } from "./NodeWebSocket";
+
+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;
+} & (
+    | { 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>,
+    { req: IncomingMessage },
+    NodePlatformRoomContext<TMeta>,
+    {
+        authorize: {
+            secret: true;
+        };
+        handleMode: "io";
+        requireAuth: false;
+        registrationMode: WebSocketRegistrationMode;
+        listeners: {
+            onRoomDeleted: true;
+            onRoomMessage: true;
+            onStorageUpdated: true;
+            onUserConnected: true;
+            onUserDisconnected: true;
+        };
+        router: true;
+    }
+> {
+    public readonly id = crypto.randomUUID();
+    public readonly _config;
+    public readonly _name = "platformNode";
+
+    constructor(config: NodePlatformConfig<TMeta> = {}) {
+        const { roomContext, mode = "attached", persistence, pubSub } = config;
+
+        super({
+            roomContext,
+            ...(persistence && pubSub ? { persistence, pubSub } : {}),
+        });
+
+        this._config = {
+            authorize: {
+                secret: true as const,
+            },
+            handleMode: "io" as const,
+            registrationMode: mode,
+            requireAuth: false as const,
+            listeners: {
+                onRoomDeleted: true as const,
+                onRoomMessage: 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({
+            roomContext: config.roomContext,
+            mode: this._config.registrationMode,
+            persistence: this.persistence.initialize(config.roomContext),
+            pubSub: this.pubSub,
+        } 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

@@ -0,0 +1,144 @@
+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();
+    }
+}