@pluv/platform-node 0.17.3 → 0.18.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @pluv/platform-node@0.17.3 build /home/runner/work/pluv/pluv/packages/platform-node
+> @pluv/platform-node@0.18.0 build /home/runner/work/pluv/pluv/packages/platform-node
 > tsup src/index.ts --format esm,cjs --dts
 
 CLI Building entry: src/index.ts
@@ -8,11 +8,11 @@
 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
+ESM dist/index.mjs 6.21 KB
+ESM ⚡️ Build success in 90ms
+CJS dist/index.js 8.01 KB
+CJS ⚡️ Build success in 92ms
 DTS Build start
-DTS ⚡️ Build success in 3957ms
-DTS dist/index.d.mts 2.77 KB
-DTS dist/index.d.ts  2.77 KB
+DTS ⚡️ Build success in 3353ms
+DTS dist/index.d.mts 2.92 KB
+DTS dist/index.d.ts  2.92 KB

package/CHANGELOG.md

@@ -1,5 +1,109 @@
 # @pluv/platform-node
 
+## 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,7 +84,7 @@ 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();
@@ -116,7 +116,7 @@ var createPluvHandler = (config) => {
     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 parsed = import_node_url.default.parse(url, true);
     const { pathname } = parsed;
     if (!pathname)
       return (_d = next == null ? void 0 : next()) != null ? _d : null;
@@ -203,9 +203,7 @@ var NodeWebSocket = class extends import_io.AbstractWebSocket {
     }
   }
   close(code, reason) {
-    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;
     this.webSocket.close(code, reason);

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;
@@ -167,9 +167,7 @@ var NodeWebSocket = class extends AbstractWebSocket {
     }
   }
   close(code, reason) {
-    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;
     this.webSocket.close(code, reason);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/platform-node",
-  "version": "0.17.3",
+  "version": "0.18.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.12.13",
     "@types/ws": "^8.5.10",
     "path-to-regexp": "^6.2.2",
-    "@pluv/io": "^0.17.3",
-    "@pluv/types": "^0.17.3"
+    "@pluv/io": "^0.18.0",
+    "@pluv/types": "^0.18.0"
   },
   "devDependencies": {
     "eslint": "^8.57.0",
     "tsup": "^8.0.2",
     "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.18.0",
+    "eslint-config-pluv": "^0.18.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);
 };