@pluv/platform-node 0.17.3 → 0.19.0

package/.turbo/turbo-build.log

@@ -1,18 +1,18 @@
 
-> @pluv/platform-node@0.17.3 build /home/runner/work/pluv/pluv/packages/platform-node
+> @pluv/platform-node@0.19.0 build /home/runner/work/pluv/pluv/packages/platform-node
 > tsup src/index.ts --format esm,cjs --dts
 
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.0.2
-CLI Target: es6
-ESM Build start
-CJS Build start
-CJS dist/index.js 8.03 KB
-CJS ⚡️ Build success in 102ms
-ESM dist/index.mjs 6.20 KB
-ESM ⚡️ Build success in 102ms
-DTS Build start
-DTS ⚡️ Build success in 3957ms
-DTS dist/index.d.mts 2.77 KB
-DTS dist/index.d.ts  2.77 KB
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.1.0
+CLI Target: es6
+ESM Build start
+CJS Build start
+ESM dist/index.mjs 6.12 KB
+ESM ⚡️ Build success in 82ms
+CJS dist/index.js 7.93 KB
+CJS ⚡️ Build success in 86ms
+DTS Build start
+DTS ⚡️ Build success in 4070ms
+DTS dist/index.d.mts 2.92 KB
+DTS dist/index.d.ts  2.92 KB

package/CHANGELOG.md

@@ -1,5 +1,116 @@
 # @pluv/platform-node
 
+## 0.19.0
+
+### Patch Changes
+
+- @pluv/io@0.19.0
+- @pluv/types@0.19.0
+
+## 0.18.0
+
+### Minor Changes
+
+- 99b5ca9: ## Breaking Changes
+
+  - `@pluv/io` has been updated to introduce `PluvProcedure`, `PluvRouter` and `PluvServer`. This change is intended to improve the ergonomics of declaring events and simplifying inferences of event types.
+
+  ### Before:
+
+  ```ts
+  // backend/io.ts
+
+  import { createIO } from "@pluv/io";
+  import { createPluvHandler, platformNode } from "@pluv/platform-node";
+  import { z } from "zod";
+
+  export const io = createIO({
+    platform: platformNode(),
+  })
+    .event("SEND_MESSAGE", {
+      input: z.object({ message: z.string() }),
+      resolver: ({ message }) => ({ RECEIVE_MESSAGE: { message } }),
+    })
+    .event("DOUBLE_VALUE", {
+      input: z.object({ value: z.number() }),
+      resolver: ({ value }) => ({ VALUE_DOUBLED: { value: value * 2 } }),
+    });
+
+  const Pluv = createPluvHandler({
+    io,
+    /* ... */
+  });
+  ```
+
+  ```ts
+  // frontend/pluv.ts
+
+  import { createClient } from "@pluv/react";
+  import type { io } from "../backend/io";
+
+  const client = createClient<typeof io>({
+    /* ... */
+  });
+  ```
+
+  ### Now:
+
+  ```ts
+  import { createIO } from "@pluv/io";
+  import { createPluvHandler, platformNode } from "@pluv/platform-node";
+  import { z } from "zod";
+
+  const io = createIO({
+    platform: platformNode(),
+  });
+
+  const router = io.router({
+    SEND_MESSAGE: io.procedure
+      .input(z.object({ message: z.string() }))
+      .broadcast(({ message }) => ({
+        RECEIVE_MESSAGE: { message },
+      })),
+    DOUBLE_VALUE: io.procedure
+      .input(z.object({ value: z.number() }))
+      .broadcast(({ value }) => ({
+        VALUE_DOUBLED: { value: value * 2 },
+      })),
+  });
+
+  export const ioServer = io.server({ router });
+
+  const Pluv = createPluvHandler({
+    io: ioServer, // <- This uses the PluvServer now
+    /* ... */
+  });
+  ```
+
+  ```ts
+  // frontend/pluv.ts
+
+  import { createClient } from "@pluv/react";
+  import type { ioServer } from "../backend/io";
+
+  // This users the PluvServer type now
+  const client = createClient<typeof ioServer>({
+    /* ... */
+  });
+  ```
+
+  - `PluvRouter` instances can also be merged via the `mergeRouters` method, which effectively performs an `Object.assign` of the events object and returns a new `PluvRouter` with the correct types:
+
+  ```ts
+  const router = io.mergeRouters(router1, router2);
+  ```
+
+### Patch Changes
+
+- Updated dependencies [428c21c]
+- Updated dependencies [329dbcd]
+- Updated dependencies [99b5ca9]
+  - @pluv/io@0.18.0
+  - @pluv/types@0.18.0
+
 ## 0.17.3
 
 ### Patch Changes

package/README.md

@@ -52,9 +52,8 @@ import { platformNode } from "@pluv/platform-node";
 import Http from "http";
 import WebSocket from "ws";
 
-export const io = createIO({
-    platform: platformNode(),
-});
+export const io = createIO({ platform: platformNode() });
+export const ioServer = io.server();
 
 const server = Http.createServer();
 const wsServer = new WebSocket.Server({ server });
@@ -65,7 +64,7 @@ const parseRoomId = (url: string): string => {
 
 wsServer.on("connection", async (ws, req) => {
   const roomId = parseRoomId(req.url);
-  const room = io.getRoom(roomId);
+  const room = ioServer.getRoom(roomId);
 
   await room.register(ws);
 });

package/dist/index.d.mts

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

package/dist/index.d.ts

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

package/dist/index.js

@@ -56,9 +56,9 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/createPluvHandler.ts
+var import_node_url = __toESM(require("url"));
 var import_path_to_regexp = require("path-to-regexp");
-var import_url = __toESM(require("url"));
-var import_ws = __toESM(require("ws"));
+var import_ws = require("ws");
 var handle = (ws) => ({
   invalidEndpoint: () => {
     ws.close(1011, "Invalid WebSocket endpoint");
@@ -75,7 +75,7 @@ var handle = (ws) => ({
 });
 var createPluvHandler = (config) => {
   const { authorize, endpoint = "/api/pluv", io, server } = config;
-  const wsServer = new import_ws.default.Server({ server });
+  const wsServer = new import_ws.Server({ server });
   const wsHandler = (ws, req) => __async(void 0, null, function* () {
     var _a;
     const url = req.url;
@@ -84,20 +84,16 @@ var createPluvHandler = (config) => {
       onError.invalidEndpoint();
       return { matched: false };
     }
-    const parsed = import_url.default.parse(url, true);
+    const parsed = import_node_url.default.parse(url, true);
     const { pathname } = parsed;
-    if (!pathname)
-      return onError.invalidEndpoint();
+    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();
+    if (!matched) return onError.invalidEndpoint();
     const { roomId } = matched.params;
-    if (!roomId)
-      return onError.invalidRoom();
+    if (!roomId) return onError.invalidRoom();
     const token = ((_a = parsed.query) == null ? void 0 : _a.token) || void 0;
-    if (Array.isArray(token))
-      return onError.invalidToken();
+    if (Array.isArray(token)) return onError.invalidToken();
     const room = io.getRoom(roomId, { req });
     yield room.register(ws, { req, token });
     return { matched: true };
@@ -109,21 +105,16 @@ var createPluvHandler = (config) => {
   };
   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;
+    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);
+    if (!url) return (_c = next == null ? void 0 : next()) != null ? _c : null;
+    const parsed = import_node_url.default.parse(url, true);
     const { pathname } = parsed;
-    if (!pathname)
-      return (_d = next == null ? void 0 : next()) != null ? _d : null;
+    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;
+    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" });
@@ -131,8 +122,7 @@ var createPluvHandler = (config) => {
     }
     try {
       const user = yield authorize({ res, req, roomId });
-      if (!user)
-        throw new Error();
+      if (!user) throw new Error();
       const token = yield io.createToken({
         req,
         room: roomId,
@@ -203,11 +193,8 @@ var NodeWebSocket = class extends import_io.AbstractWebSocket {
     }
   }
   close(code, reason) {
-    const canClose = [this.CONNECTING, this.OPEN].some(
-      (readyState) => readyState === this.readyState
-    );
-    if (!canClose)
-      return;
+    const canClose = [this.CONNECTING, this.OPEN].some((readyState) => readyState === this.readyState);
+    if (!canClose) return;
     this.webSocket.close(code, reason);
   }
   initialize() {
@@ -216,11 +203,9 @@ var NodeWebSocket = class extends import_io.AbstractWebSocket {
     });
   }
   send(message) {
-    if (this.readyState !== this.OPEN)
-      return;
+    if (this.readyState !== this.OPEN) return;
     this.webSocket.send(message, (error) => {
-      if (error)
-        throw error;
+      if (error) throw error;
     });
   }
   terminate() {
@@ -238,8 +223,7 @@ var NodePlatform = class extends import_io2.AbstractPlatform {
     return new NodeWebSocket(webSocket, config);
   }
   parseData(data) {
-    if (typeof data === "string")
-      return JSON.parse(data);
+    if (typeof data === "string") return JSON.parse(data);
     const decoder = new import_util.TextDecoder("utf8");
     return JSON.parse(decoder.decode(data));
   }

package/dist/index.mjs

@@ -20,9 +20,9 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/createPluvHandler.ts
-import { match } from "path-to-regexp";
 import Url from "url";
-import WS from "ws";
+import { match } from "path-to-regexp";
+import { Server as WsServer } from "ws";
 var handle = (ws) => ({
   invalidEndpoint: () => {
     ws.close(1011, "Invalid WebSocket endpoint");
@@ -39,7 +39,7 @@ var handle = (ws) => ({
 });
 var createPluvHandler = (config) => {
   const { authorize, endpoint = "/api/pluv", io, server } = config;
-  const wsServer = new WS.Server({ server });
+  const wsServer = new WsServer({ server });
   const wsHandler = (ws, req) => __async(void 0, null, function* () {
     var _a;
     const url = req.url;
@@ -50,18 +50,14 @@ var createPluvHandler = (config) => {
     }
     const parsed = Url.parse(url, true);
     const { pathname } = parsed;
-    if (!pathname)
-      return onError.invalidEndpoint();
+    if (!pathname) return onError.invalidEndpoint();
     const matcher = match(`${endpoint}/room/:roomId`);
     const matched = matcher(pathname);
-    if (!matched)
-      return onError.invalidEndpoint();
+    if (!matched) return onError.invalidEndpoint();
     const { roomId } = matched.params;
-    if (!roomId)
-      return onError.invalidRoom();
+    if (!roomId) return onError.invalidRoom();
     const token = ((_a = parsed.query) == null ? void 0 : _a.token) || void 0;
-    if (Array.isArray(token))
-      return onError.invalidToken();
+    if (Array.isArray(token)) return onError.invalidToken();
     const room = io.getRoom(roomId, { req });
     yield room.register(ws, { req, token });
     return { matched: true };
@@ -73,21 +69,16 @@ var createPluvHandler = (config) => {
   };
   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;
+    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;
+    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;
+    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;
+    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" });
@@ -95,8 +86,7 @@ var createPluvHandler = (config) => {
     }
     try {
       const user = yield authorize({ res, req, roomId });
-      if (!user)
-        throw new Error();
+      if (!user) throw new Error();
       const token = yield io.createToken({
         req,
         room: roomId,
@@ -167,11 +157,8 @@ var NodeWebSocket = class extends AbstractWebSocket {
     }
   }
   close(code, reason) {
-    const canClose = [this.CONNECTING, this.OPEN].some(
-      (readyState) => readyState === this.readyState
-    );
-    if (!canClose)
-      return;
+    const canClose = [this.CONNECTING, this.OPEN].some((readyState) => readyState === this.readyState);
+    if (!canClose) return;
     this.webSocket.close(code, reason);
   }
   initialize() {
@@ -180,11 +167,9 @@ var NodeWebSocket = class extends AbstractWebSocket {
     });
   }
   send(message) {
-    if (this.readyState !== this.OPEN)
-      return;
+    if (this.readyState !== this.OPEN) return;
     this.webSocket.send(message, (error) => {
-      if (error)
-        throw error;
+      if (error) throw error;
     });
   }
   terminate() {
@@ -202,8 +187,7 @@ var NodePlatform = class extends AbstractPlatform {
     return new NodeWebSocket(webSocket, config);
   }
   parseData(data) {
-    if (typeof data === "string")
-      return JSON.parse(data);
+    if (typeof data === "string") return JSON.parse(data);
     const decoder = new TextDecoder("utf8");
     return JSON.parse(decoder.decode(data));
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/platform-node",
-  "version": "0.17.3",
+  "version": "0.19.0",
   "description": "@pluv/io adapter for node.js",
   "author": "leedavidcs",
   "license": "MIT",
@@ -17,19 +17,19 @@
     "access": "public"
   },
   "dependencies": {
-    "@types/node": "^20.12.7",
+    "@types/node": "^20.14.9",
     "@types/ws": "^8.5.10",
-    "path-to-regexp": "^6.2.2",
-    "@pluv/io": "^0.17.3",
-    "@pluv/types": "^0.17.3"
+    "path-to-regexp": "^7.0.0",
+    "@pluv/io": "^0.19.0",
+    "@pluv/types": "^0.19.0"
   },
   "devDependencies": {
     "eslint": "^8.57.0",
-    "tsup": "^8.0.2",
+    "tsup": "^8.1.0",
     "typescript": "^5.4.5",
-    "ws": "^8.16.0",
-    "@pluv/tsconfig": "^0.17.3",
-    "eslint-config-pluv": "^0.17.3"
+    "ws": "^8.17.0",
+    "@pluv/tsconfig": "^0.19.0",
+    "eslint-config-pluv": "^0.19.0"
   },
   "peerDependencies": {
     "ws": "^8.0.0"

package/src/NodePlatform.ts

@@ -13,20 +13,14 @@ export type NodePlatformOptions =
           pubSub: AbstractPubSub;
       };
 
-export class NodePlatform extends AbstractPlatform<
-    WebSocket,
-    { req: IncomingMessage }
-> {
+export class NodePlatform extends AbstractPlatform<WebSocket, { req: IncomingMessage }> {
     constructor(options: NodePlatformOptions = {}) {
         const { persistance, pubSub } = options;
 
         super(persistance && pubSub ? { persistance, pubSub } : {});
     }
 
-    public convertWebSocket(
-        webSocket: WebSocket,
-        config: ConvertWebSocketConfig,
-    ): NodeWebSocket {
+    public convertWebSocket(webSocket: WebSocket, config: ConvertWebSocketConfig): NodeWebSocket {
         return new NodeWebSocket(webSocket, config);
     }
 

package/src/NodeWebSocket.ts

@@ -32,10 +32,7 @@ export class NodeWebSocket extends AbstractWebSocket {
         this.webSocket = webSocket;
     }
 
-    public addEventListener<TType extends keyof AbstractEventMap>(
-        type: TType,
-        handler: AbstractListener<TType>,
-    ): void {
+    public addEventListener<TType extends keyof AbstractEventMap>(type: TType, handler: AbstractListener<TType>): void {
         switch (type) {
             case "close":
                 this.webSocket.on("close", async (code, reason) => {
@@ -74,9 +71,7 @@ export class NodeWebSocket extends AbstractWebSocket {
     }
 
     public close(code?: number | undefined, reason?: string | undefined): void {
-        const canClose = [this.CONNECTING, this.OPEN].some(
-            (readyState) => readyState === this.readyState,
-        );
+        const canClose = [this.CONNECTING, this.OPEN].some((readyState) => readyState === this.readyState);
 
         if (!canClose) return;
 

package/src/createPluvHandler.ts

@@ -1,35 +1,36 @@
-import type { PluvIO } from "@pluv/io";
-import {
+import type { PluvServer } from "@pluv/io";
+import type {
     InferIOAuthorize,
     InferIOAuthorizeRequired,
     InferIOAuthorizeUser,
     Maybe,
     MaybePromise,
 } from "@pluv/types";
-import Http from "http";
+import type { Server as HttpServer, IncomingMessage, ServerResponse } from "node:http";
+import Url from "node:url";
 import { match } from "path-to-regexp";
-import Url from "url";
-import WS from "ws";
+import type { WebSocket } from "ws";
+import { Server as WsServer } from "ws";
 import { NodePlatform } from "./NodePlatform";
 
 export interface AuthorizeFunctionContext {
-    req: Http.IncomingMessage;
-    res: Http.ServerResponse;
+    req: IncomingMessage;
+    res: ServerResponse;
     roomId: string;
 }
-export type AuthorizeFunction<TPluv extends PluvIO<NodePlatform>> = (
+export type AuthorizeFunction<TPluvServer extends PluvServer<NodePlatform, any, any, any>> = (
     ctx: AuthorizeFunctionContext,
-) => MaybePromise<Maybe<InferIOAuthorizeUser<InferIOAuthorize<TPluv>>>>;
+) => MaybePromise<Maybe<InferIOAuthorizeUser<InferIOAuthorize<TPluvServer>>>>;
 
-export type CreatePluvHandlerConfig<TPluv extends PluvIO<NodePlatform>> = {
+export type CreatePluvHandlerConfig<TPluvServer extends PluvServer<NodePlatform, any, any, any>> = {
     endpoint?: string;
-    io: TPluv;
-    server: Http.Server;
-} & (InferIOAuthorizeRequired<InferIOAuthorize<TPluv>> extends true
-    ? { authorize: AuthorizeFunction<TPluv> }
+    io: TPluvServer;
+    server: HttpServer;
+} & (InferIOAuthorizeRequired<InferIOAuthorize<TPluvServer>> extends true
+    ? { authorize: AuthorizeFunction<TPluvServer> }
     : { authorize?: undefined });
 
-const handle = (ws: WS.WebSocket) => ({
+const handle = (ws: WebSocket) => ({
     invalidEndpoint: () => {
         ws.close(1011, "Invalid WebSocket endpoint");
 
@@ -47,40 +48,28 @@ const handle = (ws: WS.WebSocket) => ({
     },
 });
 
-export type RequestHandler = (
-    req: Http.IncomingMessage,
-    res: Http.ServerResponse,
-    next?: () => void,
-) => void;
+export type RequestHandler = (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
 
 export interface WebSocketHandlerResult {
     matched: boolean;
 }
 
-export type WebSocketHandler = (
-    ws: WS.WebSocket,
-    req: Http.IncomingMessage,
-) => Promise<WebSocketHandlerResult>;
+export type WebSocketHandler = (ws: WebSocket, req: IncomingMessage) => Promise<WebSocketHandlerResult>;
 
 export interface CreatePluvHandlerResult {
-    createWsServer: () => WS.Server;
+    createWsServer: () => WsServer;
     handler: RequestHandler;
     wsHandler: WebSocketHandler;
 }
 
-export const createPluvHandler = <
-    TPluv extends PluvIO<NodePlatform, any, any, any, any, any, any>,
->(
-    config: CreatePluvHandlerConfig<TPluv>,
+export const createPluvHandler = <TPluvServer extends PluvServer<NodePlatform, any, any, any>>(
+    config: CreatePluvHandlerConfig<TPluvServer>,
 ): CreatePluvHandlerResult => {
     const { authorize, endpoint = "/api/pluv", io, server } = config;
 
-    const wsServer = new WS.Server({ server });
+    const wsServer = new WsServer({ server });
 
-    const wsHandler = async (
-        ws: WS.WebSocket,
-        req: Http.IncomingMessage,
-    ): Promise<WebSocketHandlerResult> => {
+    const wsHandler = async (ws: WebSocket, req: IncomingMessage): Promise<WebSocketHandlerResult> => {
         const url = req.url;
         const onError = handle(ws);
 
@@ -122,10 +111,10 @@ export const createPluvHandler = <
     };
 
     const handler = async (
-        req: Http.IncomingMessage,
-        res: Http.ServerResponse,
+        req: IncomingMessage,
+        res: ServerResponse,
         next?: () => void,
-    ): Promise<Http.ServerResponse | null> => {
+    ): Promise<ServerResponse | null> => {
         if (!authorize) return next?.() ?? null;
         if (req.method !== "GET") return next?.() ?? null;
 

package/src/index.ts

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

package/src/platformNode.ts

@@ -1,8 +1,6 @@
 import type { NodePlatformOptions } from "./NodePlatform";
 import { NodePlatform } from "./NodePlatform";
 
-export const platformNode = (
-    options: NodePlatformOptions = {},
-): NodePlatform => {
+export const platformNode = (options: NodePlatformOptions = {}): NodePlatform => {
     return new NodePlatform(options);
 };