@pluv/platform-node 0.1.18 → 0.2.1

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @pluv/platform-node@0.1.18 build /home/runner/work/pluv/pluv/packages/platform-node
+> @pluv/platform-node@0.2.1 build /home/runner/work/pluv/pluv/packages/platform-node
 > tsup src/index.ts --format esm,cjs --dts
 
 CLI Building entry: src/index.ts
@@ -8,10 +8,10 @@
 CLI Target: es6
 ESM Build start
 CJS Build start
-CJS dist/index.js 4.69 KB
-CJS ⚡️ Build success in 89ms
-ESM dist/index.mjs 3.06 KB
-ESM ⚡️ Build success in 98ms
+ESM dist/index.mjs 6.15 KB
+ESM ⚡️ Build success in 53ms
+CJS dist/index.js 7.97 KB
+CJS ⚡️ Build success in 54ms
 DTS Build start
-DTS ⚡️ Build success in 6818ms
-DTS dist/index.d.ts 1.35 KB
+DTS ⚡️ Build success in 6291ms
+DTS dist/index.d.ts 2.72 KB

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @pluv/platform-node
 
+## 0.2.1
+
+### Patch Changes
+
+- Updated dependencies [8917309]
+  - @pluv/io@0.4.2
+
+## 0.2.0
+
+### Minor Changes
+
+- 5bbfb98: added createPluvHandler to automatically set-up a pluv server with reasonable defaults
+
+### Patch Changes
+
+- 5bbfb98: require ws as a peer dependency
+- b85a232: bumped dependencies
+- Updated dependencies [b85a232]
+  - @pluv/io@0.4.1
+  - @pluv/types@0.2.0
+
 ## 0.1.18
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,6 +1,8 @@
-import { WebSocket } from 'ws';
+import { AbstractWebSocket, AbstractEventMap, AbstractListener, AbstractWebSocketConfig, AbstractPersistance, AbstractPubSub, AbstractPlatform, ConvertWebSocketConfig, PluvIO } from '@pluv/io';
+import { MaybePromise, Maybe, InferIOAuthorizeUser, InferIOAuthorize, InferIOAuthorizeRequired } from '@pluv/types';
+import Http from 'http';
+import WS, { WebSocket } from 'ws';
 export { WebSocket } from 'ws';
-import { AbstractWebSocket, AbstractEventMap, AbstractListener, AbstractWebSocketConfig, AbstractPersistance, AbstractPubSub, AbstractPlatform, ConvertWebSocketConfig } from '@pluv/io';
 
 type NodeWebSocketConfig = AbstractWebSocketConfig;
 declare class NodeWebSocket extends AbstractWebSocket {
@@ -28,6 +30,33 @@ declare class NodePlatform extends AbstractPlatform<WebSocket> {
     randomUUID(): string;
 }
 
+interface AuthorizeFunctionContext {
+    req: Http.IncomingMessage;
+    res: Http.ServerResponse;
+    roomId: string;
+}
+type AuthorizeFunction<TPluv extends PluvIO<NodePlatform>> = (ctx: AuthorizeFunctionContext) => MaybePromise<Maybe<InferIOAuthorizeUser<InferIOAuthorize<TPluv>>>>;
+type CreatePluvHandlerConfig<TPluv extends PluvIO<NodePlatform>> = {
+    endpoint?: string;
+    io: TPluv;
+    server: Http.Server;
+} & (InferIOAuthorizeRequired<InferIOAuthorize<TPluv>> extends true ? {
+    authorize: AuthorizeFunction<TPluv>;
+} : {
+    authorize?: undefined;
+});
+type RequestHandler = (req: Http.IncomingMessage, res: Http.ServerResponse, next?: () => void) => void;
+interface WebSocketHandlerResult {
+    matched: boolean;
+}
+type WebSocketHandler = (ws: WS.WebSocket, req: Http.IncomingMessage) => Promise<WebSocketHandlerResult>;
+interface CreatePluvHandlerResult {
+    createWsServer: () => WS.Server<WS.WebSocket>;
+    handler: RequestHandler;
+    wsHandler: WebSocketHandler;
+}
+declare const createPluvHandler: <TPluv extends PluvIO<NodePlatform, any, any, any, any, any, any>>(config: CreatePluvHandlerConfig<TPluv>) => CreatePluvHandlerResult;
+
 declare const platformNode: (options?: NodePlatformOptions) => NodePlatform;
 
-export { NodePlatformOptions, platformNode };
+export { AuthorizeFunction, AuthorizeFunctionContext, CreatePluvHandlerConfig, NodePlatformOptions, createPluvHandler, platformNode };

package/dist/index.js

@@ -50,10 +50,104 @@ var __async = (__this, __arguments, generator) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  createPluvHandler: () => createPluvHandler,
   platformNode: () => platformNode
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/createPluvHandler.ts
+var import_path_to_regexp = require("path-to-regexp");
+var import_url = __toESM(require("url"));
+var import_ws = __toESM(require("ws"));
+var handle = (ws) => ({
+  invalidEndpoint: () => {
+    ws.close(1011, "Invalid WebSocket endpoint");
+    return { matched: false };
+  },
+  invalidRoom: () => {
+    ws.close(1011, "Invalid room name");
+    return { matched: true };
+  },
+  invalidToken: () => {
+    ws.close(1011, "Invalid authentication token");
+    return { matched: true };
+  }
+});
+var createPluvHandler = (config) => {
+  const { authorize, endpoint = "/api/pluv", io, server } = config;
+  const wsServer = new import_ws.default.Server({ server });
+  const wsHandler = (ws, req) => __async(void 0, null, function* () {
+    var _a;
+    const url = req.url;
+    const onError = handle(ws);
+    if (!url) {
+      onError.invalidEndpoint();
+      return { matched: false };
+    }
+    const parsed = import_url.default.parse(url, true);
+    const { pathname } = parsed;
+    if (!pathname)
+      return onError.invalidEndpoint();
+    const matcher = (0, import_path_to_regexp.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 = io.getRoom(roomId);
+    yield room.register(ws, { token });
+    return { matched: true };
+  });
+  const createWsServer = () => {
+    return wsServer.on("connection", (ws, req) => __async(void 0, null, function* () {
+      yield wsHandler(ws, req);
+    }));
+  };
+  const handler = (req, res, next) => __async(void 0, 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 = import_url.default.parse(url, true);
+    const { pathname } = parsed;
+    if (!pathname)
+      return (_d = next == null ? void 0 : next()) != null ? _d : null;
+    const matcher = (0, import_path_to_regexp.match)(`${endpoint}/authorize`);
+    const matched = matcher(pathname);
+    if (!matched)
+      return (_e = next == null ? void 0 : next()) != null ? _e : null;
+    const roomId = ((_f = parsed.query) == null ? void 0 : _f.room) || void 0;
+    if (typeof roomId !== "string" || !roomId) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      return res.end("Room does not exist");
+    }
+    try {
+      const user = yield authorize({ res, req, roomId });
+      if (!user)
+        throw new Error();
+      const token = yield io.createToken({ room: roomId, 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/NodePlatform.ts
 var import_io2 = require("@pluv/io");
 var import_crypto = __toESM(require("crypto"));
@@ -157,5 +251,6 @@ var platformNode = (options = {}) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  createPluvHandler,
   platformNode
 });

package/dist/index.mjs

@@ -19,6 +19,99 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
+// src/createPluvHandler.ts
+import { match } from "path-to-regexp";
+import Url from "url";
+import WS from "ws";
+var handle = (ws) => ({
+  invalidEndpoint: () => {
+    ws.close(1011, "Invalid WebSocket endpoint");
+    return { matched: false };
+  },
+  invalidRoom: () => {
+    ws.close(1011, "Invalid room name");
+    return { matched: true };
+  },
+  invalidToken: () => {
+    ws.close(1011, "Invalid authentication token");
+    return { matched: true };
+  }
+});
+var createPluvHandler = (config) => {
+  const { authorize, endpoint = "/api/pluv", io, server } = config;
+  const wsServer = new WS.Server({ server });
+  const wsHandler = (ws, req) => __async(void 0, 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 = io.getRoom(roomId);
+    yield room.register(ws, { token });
+    return { matched: true };
+  });
+  const createWsServer = () => {
+    return wsServer.on("connection", (ws, req) => __async(void 0, null, function* () {
+      yield wsHandler(ws, req);
+    }));
+  };
+  const handler = (req, res, next) => __async(void 0, 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 roomId = ((_f = parsed.query) == null ? void 0 : _f.room) || void 0;
+    if (typeof roomId !== "string" || !roomId) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      return res.end("Room does not exist");
+    }
+    try {
+      const user = yield authorize({ res, req, roomId });
+      if (!user)
+        throw new Error();
+      const token = yield io.createToken({ room: roomId, 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/NodePlatform.ts
 import { AbstractPlatform } from "@pluv/io";
 import crypto from "crypto";
@@ -121,5 +214,6 @@ var platformNode = (options = {}) => {
   return new NodePlatform(options);
 };
 export {
+  createPluvHandler,
   platformNode
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/platform-node",
-  "version": "0.1.18",
+  "version": "0.2.1",
   "description": "@pluv/io adapter for node.js",
   "author": "leedavidcs",
   "license": "MIT",
@@ -17,16 +17,21 @@
     "access": "public"
   },
   "dependencies": {
-    "@types/node": "^18.16.3",
+    "@types/node": "^20.1.7",
     "@types/ws": "^8.5.4",
-    "@pluv/io": "^0.4.0",
+    "path-to-regexp": "^6.2.1",
+    "@pluv/io": "^0.4.2",
     "@pluv/types": "^0.2.0"
   },
   "devDependencies": {
     "tsup": "^6.7.0",
     "typescript": "^5.0.4",
+    "ws": "^8.13.0",
     "@pluv/tsconfig": "^0.1.6",
-    "eslint-config-pluv": "^0.1.11"
+    "eslint-config-pluv": "^0.1.12"
+  },
+  "peerDependencies": {
+    "ws": "^8.0.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/createPluvHandler.ts

@@ -0,0 +1,173 @@
+import type { PluvIO } from "@pluv/io";
+import {
+    InferIOAuthorize,
+    InferIOAuthorizeRequired,
+    InferIOAuthorizeUser,
+    Maybe,
+    MaybePromise,
+} from "@pluv/types";
+import Http from "http";
+import { match } from "path-to-regexp";
+import Url from "url";
+import WS from "ws";
+import { NodePlatform } from "./NodePlatform";
+
+export interface AuthorizeFunctionContext {
+    req: Http.IncomingMessage;
+    res: Http.ServerResponse;
+    roomId: string;
+}
+export type AuthorizeFunction<TPluv extends PluvIO<NodePlatform>> = (
+    ctx: AuthorizeFunctionContext
+) => MaybePromise<Maybe<InferIOAuthorizeUser<InferIOAuthorize<TPluv>>>>;
+
+export type CreatePluvHandlerConfig<TPluv extends PluvIO<NodePlatform>> = {
+    endpoint?: string;
+    io: TPluv;
+    server: Http.Server;
+} & (InferIOAuthorizeRequired<InferIOAuthorize<TPluv>> extends true
+    ? { authorize: AuthorizeFunction<TPluv> }
+    : { authorize?: undefined });
+
+const handle = (ws: WS.WebSocket) => ({
+    invalidEndpoint: () => {
+        ws.close(1011, "Invalid WebSocket endpoint");
+
+        return { matched: false };
+    },
+    invalidRoom: () => {
+        ws.close(1011, "Invalid room name");
+
+        return { matched: true };
+    },
+    invalidToken: () => {
+        ws.close(1011, "Invalid authentication token");
+
+        return { matched: true };
+    },
+});
+
+export type RequestHandler = (
+    req: Http.IncomingMessage,
+    res: Http.ServerResponse,
+    next?: () => void
+) => void;
+
+export interface WebSocketHandlerResult {
+    matched: boolean;
+}
+
+export type WebSocketHandler = (
+    ws: WS.WebSocket,
+    req: Http.IncomingMessage
+) => Promise<WebSocketHandlerResult>;
+
+export interface CreatePluvHandlerResult {
+    createWsServer: () => WS.Server<WS.WebSocket>;
+    handler: RequestHandler;
+    wsHandler: WebSocketHandler;
+}
+
+export const createPluvHandler = <
+    TPluv extends PluvIO<NodePlatform, any, any, any, any, any, any>
+>(
+    config: CreatePluvHandlerConfig<TPluv>
+): CreatePluvHandlerResult => {
+    const { authorize, endpoint = "/api/pluv", io, server } = config;
+
+    const wsServer = new WS.Server({ server });
+
+    const wsHandler = async (
+        ws: WS.WebSocket,
+        req: Http.IncomingMessage
+    ): Promise<WebSocketHandlerResult> => {
+        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<{ roomId: string }>(`${endpoint}/room/:roomId`);
+        const matched = matcher(pathname);
+
+        if (!matched) return onError.invalidEndpoint();
+
+        const { roomId } = matched.params;
+
+        if (!roomId) return onError.invalidRoom();
+
+        const token = parsed.query?.token || undefined;
+
+        if (Array.isArray(token)) return onError.invalidToken();
+
+        const room = io.getRoom(roomId);
+
+        await room.register(ws, { token });
+
+        return { matched: true };
+    };
+
+    const createWsServer = () => {
+        return wsServer.on("connection", async (ws, req) => {
+            await wsHandler(ws, req);
+        });
+    };
+
+    const handler = async (
+        req: Http.IncomingMessage,
+        res: Http.ServerResponse,
+        next?: () => void
+    ): Promise<Http.ServerResponse | null> => {
+        if (!authorize) return next?.() ?? null;
+        if (req.method !== "GET") return next?.() ?? null;
+
+        const url = req.url;
+
+        if (!url) return next?.() ?? null;
+
+        const parsed = Url.parse(url, true);
+        const { pathname } = parsed;
+
+        if (!pathname) return next?.() ?? null;
+
+        const matcher = match<{}>(`${endpoint}/authorize`);
+        const matched = matcher(pathname);
+
+        if (!matched) return next?.() ?? null;
+
+        const roomId = parsed.query?.room || undefined;
+
+        if (typeof roomId !== "string" || !roomId) {
+            res.writeHead(404, { "Content-Type": "text/plain" });
+            return res.end("Room does not exist");
+        }
+
+        try {
+            const user = await authorize({ res, req, roomId });
+
+            if (!user) throw new Error();
+
+            const token = await io.createToken({ room: roomId, 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,
+    };
+};

package/src/index.ts

@@ -1,3 +1,9 @@
+export type {
+    AuthorizeFunction,
+    AuthorizeFunctionContext,
+    CreatePluvHandlerConfig,
+} from "./createPluvHandler";
+export { createPluvHandler } from "./createPluvHandler";
 export type { WebSocket } from "ws";
 export type { NodePlatformOptions } from "./NodePlatform";
 export { platformNode } from "./platformNode";