crossws 0.1.0 → 0.1.2

package/README.md

@@ -1,15 +1,19 @@
 # ⛨ CrossWS
 
-[![npm version][npm-version-src]][npm-version-href]
-[![bundle][bundle-src]][bundle-href]
+<!-- automd:badges -->
 
-<!-- [![npm downloads][npm-downloads-src]][npm-downloads-href] -->
+[![npm version](https://flat.badgen.net/npm/v/crossws)](https://npmjs.com/package/crossws)
+[![npm downloads](https://flat.badgen.net/npm/dm/crossws)](https://npmjs.com/package/crossws)
 
-<!-- [![Codecov][codecov-src]][codecov-href] -->
+<!-- /automd -->
 
-👉 Elegant, typed, and simple interface to implement platform-agnostic WebSocket servers
+Elegant, typed, and simple interface to implement platform-agnostic WebSocket servers.
 
-🧩 Seamlessly integrates with, [Node.js](https://nodejs.org/en), [Bun](https://bun.sh/), [Deno](https://deno.com/) and [Cloudflare Workers](https://workers.cloudflare.com/)!
+👉 [📖 documentation](https://crossws.unjs.io)
+
+## Features
+
+🧩 Seamlessly integrates with, [Bun](https://bun.sh/), [Deno](https://deno.com/), [Cloudflare Workers](https://workers.cloudflare.com/) and [Node.js](https://nodejs.org/en) ([ws](https://github.com/websockets/ws) || [uWebSockets](https://github.com/uNetworking/uWebSockets.js)).
 
 🚀 High-performance server hooks, avoiding heavy per-connection events API ([why](https://bun.sh/docs/api/websockets#lcYFjkFYJC-summary))
 
@@ -19,268 +23,41 @@
 
 🔍 Developer-friendly object logging
 
-> [!WARNING]
+> [!IMPORTANT]
 > This project and API are under development.
 
-## Install
-
-```sh
-# npm
-npm install crossws
-
-# yarn
-yarn add crossws
-
-# pnpm
-pnpm install crossws
-
-# bun
-bun install crossws
-```
-
-## Unified Hooks
-
-CrossWS provides a cross-platform API to define WebSocket servers. An implementation with these hooks works across runtimes without needing you to go into details of any of them (while you always have the power to control low-level hooks). You can only define the life-cycle hooks that you only need and only those will be called run runtime.
-
-> [!NOTE]
-> For type support and IDE auto-completion, you can use `defineWebSocketHooks` utility or `WebSocketHooks` type export from the main.
-
-```ts
-import { defineWebSocketHooks } from "crossws";
-
-const websocketHooks = defineWebSocketHooks({
-  open(peer) {
-    console.log("[ws] open", peer);
-  },
-
-  message(peer, message) {
-    console.log("[ws] message", peer, message);
-    if (message.text().includes("ping")) {
-      peer.send("pong");
-    }
-  },
-
-  close(peer, event) {
-    console.log("[ws] close", peer, event);
-  },
-
-  error(peer, error) {
-    console.log("[ws] error", peer, error);
-  },
-
-  // ... platform hooks such as bun:drain ...
-});
-```
-
-### Peer Object
-
-Websocket hooks always accept a peer instance as the first argument. `peer`, keeps the state of the connected client.
-
-**Properties:**
-
-- `peer.id?`: The peer address or unique id (might be `undefined`)
-- `peer.readyState`: The connection status ([MDN](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/readyState))
-- `peer.ctx[name]`: Keeps the state of native client connection
-
-**Methods:**
-
-- `send(message, compress)`: Send a message to the connected client
-
-> [!TIP]
-> You can safely log a peer instance to the console using `console.log` it will be automatically stringified with useful information including the remote address and connection status!
-
-### Message Object
-
-on `message` hook, you receive a message object containing an incoming message from the client.
-
-**Properties:**
-
-- `message.rawData`: Raw message data
-- `message.isBinary`: Indicates if the message is binary (might be `undefined`)
-
-**Methods:**
-
-- `message.text()`: Get stringified version of the message
-
-> [!TIP]
-> You can safely log `message` object to the console using `console.log` it will be automatically stringified!
-
-## Error handling
-
-You can catch errors using `error` hook. The second argument is error wrapped into a `WebSocketError` class.
-
-## Universal WebSocket client
-
-CrossWS also exposes a universal way to use [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) API in order to connect to the server. For all runtimes, except Node.js, native implementation is used, and for Node.js, a bundled version of [`ws.WebSocket`](https://www.npmjs.com/package/ws) is bundled.
-
-```js
-import WebSocket from "crossws/websocket";
-```
-
-> [!NOTE]
-> Using export conditions, the correct version will be always used so you don't have to worry about picking the right build!
-
-## Integrations
-
-CrossWS allows integrating your WebSocket hooks with different runtimes and platforms using built-in adapters. Each runtime has a specific method of integrating WebSocket. Once integrated, your custom hooks (such as `message` and `close`) will work consistently even if you change the runtime!
-
-### Integration with **Node.js**
-
-To integrate CrossWS with your Node.js HTTP server, you need to connect the `upgrade` event to the `handleUpgrade` method returned from the adapter. Behind the scenes, CrossWS uses an embedded version of [ws](https://github.com/websockets/ws).
+## Contribution
 
-```ts
-// Initialize Server
-import { createServer } from "node:http";
-
-const server = createServer((req, res) => {
-  res.end(
-    `<script>new WebSocket("ws://localhost:3000").addEventListener('open', (e) => e.target.send("Hello from client!"));</script>`,
-  );
-}).listen(3000);
-
-// Initialize WebSocket Hooks
-import nodeWSAdapter from "crossws/adapters/node";
-
-const { handleUpgrade } = nodeWSAdapter({ message: console.log });
-server.on("upgrade", handleUpgrade);
-```
-
-**Node-specific hooks:**
-
-- `node:open (peer)`
-- `node:message (peer, data, isBinary)`
-- `node:close (peer, code, reason)`
-- `node:error (peer, error)`
-- `node:ping (peer)`
-- `node:pong (peer)`
-- `node:unexpected-response (peer, req, res)`
-- `node:upgrade (peer, req)`
-
-See [playground/node.ts](./playground/node.ts) for demo and [src/adapters/node.ts](./src/adapters/node.ts) for implementation.
-
-### Integration with **Bun**
-
-To integrate CrossWS with your Bun server, you need to check for `server.upgrade` and also pass the `websocket` object returned from the adapter to server options. CrossWS leverages native Bun WebSocket API.
-
-```ts
-import bunAdapter from "./dist/adapters/bun";
-
-const { websocket } = bunAdapter({ message: console.log });
-
-Bun.serve({
-  port: 3000,
-  websocket,
-  fetch(req, server) {
-    if (server.upgrade(req)) {
-      return;
-    }
-    return new Response(
-      `<script>new WebSocket("ws://localhost:3000").addEventListener('open', (e) => e.target.send("Hello from client!"));</script>`,
-      { headers: { "content-type": "text/html" } },
-    );
-  },
-});
-```
-
-**Bun-specific hooks:**
-
-- `bun:message (peer, ws,message)`
-- `bun:open (peer, ws)`
-- `bun:close (peer, ws)`
-- `bun:drain (peer)`
-- `bun:error (peer, ws, error)`
-- `bun:ping (peer, ws, data)`
-- `bun:pong (peer, ws, data)`
-
-See [playground/bun.ts](./playground/bun.ts) for demo and [src/adapters/bun.ts](./src/adapters/bun.ts) for implementation.
-
-### Integration with **Deno**
-
-To integrate CrossWS with your Deno server, you need to check for the `upgrade` header and then call `handleUpgrade` method from the adapter passing the incoming request object. The returned value is the server upgrade response.
-
-```ts
-import denoAdapter from "crossws/adapters/deno";
-
-const { handleUpgrade } = denoAdapter({ message: console.log });
-
-Deno.serve({ port: 3000 }, (req) => {
-  if (req.headers.get("upgrade") === "websocket") {
-    return handleUpgrade(req);
-  }
-  return new Response(
-    `<script>new WebSocket("ws://localhost:3000").addEventListener("open", (e) => e.target.send("Hello from client!"));</script>`,
-    { headers: { "content-type": "text/html" } },
-  );
-});
-```
-
-**Deno-specific hooks:**
-
-- `deno:open (peer)`
-- `deno:message (peer, event)`
-- `deno:close (peer)`
-- `deno:error (peer, error)`
-
-See [playground/deno.ts](./playground/deno.ts) for demo and [src/adapters/deno.ts](./src/adapters/deno.ts) for implementation.
-
-### Integration with **Cloudflare Workers**
-
-To integrate CrossWS with your Cloudflare Workers, you need to check for the `upgrade` header
-
-```ts
-import cloudflareAdapter from "crossws/adapters/cloudflare";
-
-const { handleUpgrade } = cloudflareAdapter({ message: console.log });
-
-export default {
-  async fetch(request, env, context) {
-    if (request.headers.get("upgrade") === "websocket") {
-      return handleUpgrade(request, env, context);
-    }
-    return new Response(
-      `<script>new WebSocket("ws://localhost:3000").addEventListener("open", (e) => e.target.send("Hello from client!"));</script>`,
-      { headers: { "content-type": "text/html" } },
-    );
-  },
-};
-```
-
-**Cloudflare-specific hooks:**
-
-- `cloudflare:accept(peer)`
-- `cloudflare:message(peer, event)`
-- `cloudflare:error(peer, event)`
-- `cloudflare:close(peer, event)`
-
-See [playground/cloudflare.ts](./playground/cloudflare.ts) for demo and [src/adapters/cloudflare.ts](./src/adapters/cloudflare.ts) for implementation.
-
-### Integration with other runtimes
-
-You can define your custom adapters using `defineWebSocketAdapter` wrapper.
-
-See other adapter implementations in [./src/adapters](./src/adapters/) to get an idea of how adapters can be implemented and feel free to directly make a Pull Request to support your environment in CrossWS!
-
-## Development
+<details>
+  <summary>Local development</summary>
 
 - Clone this repository
 - Install the latest LTS version of [Node.js](https://nodejs.org/en/)
 - Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable`
 - Install dependencies using `pnpm install`
-- Run interactive tests using `pnpm dev`
+- Run examples using `pnpm play:` scripts
+
+</details>
+
+<!-- /automd -->
 
 ## License
 
-Made with 💛
+<!-- automd:contributors license=MIT author="pi0" -->
+
+Published under the [MIT](https://github.com/unjs/crossws/blob/main/LICENSE) license.
+Made by [@pi0](https://github.com/pi0) and [community](https://github.com/unjs/crossws/graphs/contributors) 💛
+<br><br>
+<a href="https://github.com/unjs/crossws/graphs/contributors">
+<img src="https://contrib.rocks/image?repo=unjs/crossws" />
+</a>
+
+<!-- /automd -->
+
+<!-- automd:with-automd -->
 
-Published under [MIT License](./LICENSE).
+---
 
-<!-- Badges -->
+_🤖 auto updated with [automd](https://automd.unjs.io)_
 
-[npm-version-src]: https://img.shields.io/npm/v/crossws?style=flat&colorA=18181B&colorB=F0DB4F
-[npm-version-href]: https://npmjs.com/package/crossws
-[npm-downloads-src]: https://img.shields.io/npm/dm/crossws?style=flat&colorA=18181B&colorB=F0DB4F
-[npm-downloads-href]: https://npmjs.com/package/crossws
-[codecov-src]: https://img.shields.io/codecov/c/gh/unjs/crossws/main?style=flat&colorA=18181B&colorB=F0DB4F
-[codecov-href]: https://codecov.io/gh/unjs/crossws
-[bundle-src]: https://img.shields.io/bundlephobia/minzip/crossws?style=flat&colorA=18181B&colorB=F0DB4F
-[bundle-href]: https://bundlephobia.com/result?p=crossws
+<!-- /automd -->

package/adapters/bun.d.ts

@@ -1 +1,2 @@
 export * from "../dist/adapters/bun";
+export { default } from "../dist/adapters/bun";

package/adapters/cloudflare.d.ts

@@ -1 +1,2 @@
 export * from "../dist/adapters/cloudflare";
+export { default } from "../dist/adapters/cloudflare";

package/adapters/deno.d.ts

@@ -1 +1,2 @@
 export * from "../dist/adapters/deno";
+export { default } from "../dist/adapters/deno";

package/adapters/node.d.ts

@@ -1 +1,2 @@
 export * from "../dist/adapters/node";
+export { default } from "../dist/adapters/node";

package/adapters/uws.d.ts

@@ -0,0 +1,2 @@
+export * from "../dist/adapters/uws";
+export { default } from "../dist/adapters/uws";

package/dist/adapters/bun.cjs

@@ -1,58 +1,63 @@
 'use strict';
 
-const peer = require('../shared/crossws.21e14e0d.cjs');
+const peer = require('../shared/crossws.6009d265.cjs');
 
 const bun = peer.defineWebSocketAdapter(
-  (hooks, opts = {}) => {
-    const getPeer = (ws) => {
+  (hooks, options = {}) => {
+    const crossws = peer.createCrossWS(hooks, options);
+    const getWSPeer = (ws) => {
       if (ws.data?._peer) {
         return ws.data._peer;
       }
-      const peer = new WebSocketPeer({ bun: { ws } });
+      const peer = new BunWSPeer({ bun: { ws } });
       ws.data = ws.data || {};
       ws.data._peer = peer;
       return peer;
     };
     return {
+      async handleUpgrade(req, server) {
+        const { headers } = await crossws.upgrade({
+          url: req.url,
+          headers: req.headers
+        });
+        return server.upgrade(req, {
+          data: { req, server },
+          headers
+        });
+      },
       websocket: {
         message: (ws, message) => {
-          const peer$1 = getPeer(ws);
-          hooks["bun:message"]?.(peer$1, ws, message);
-          hooks.message?.(peer$1, new peer.WebSocketMessage(message));
+          const peer$1 = getWSPeer(ws);
+          crossws.$("bun:message", peer$1, ws, message);
+          crossws.message(peer$1, new peer.WSMessage(message));
         },
         open: (ws) => {
-          const peer = getPeer(ws);
-          hooks["bun:open"]?.(peer, ws);
-          hooks.open?.(peer);
+          const peer = getWSPeer(ws);
+          crossws.$("bun:open", peer, ws);
+          crossws.open(peer);
         },
         close: (ws) => {
-          const peer = getPeer(ws);
-          hooks["bun:close"]?.(peer, ws);
-          hooks.close?.(peer, {});
+          const peer = getWSPeer(ws);
+          crossws.$("bun:close", peer, ws);
+          crossws.close(peer, {});
         },
         drain: (ws) => {
-          const peer = getPeer(ws);
-          hooks["bun:drain"]?.(peer);
-        },
-        // @ts-expect-error types unavailable but mentioned in docs
-        error: (ws, error) => {
-          const peer$1 = getPeer(ws);
-          hooks["bun:error"]?.(peer$1, ws, error);
-          hooks.error?.(peer$1, new peer.WebSocketError(error));
+          const peer = getWSPeer(ws);
+          crossws.$("bun:drain", peer);
         },
         ping(ws, data) {
-          const peer = getPeer(ws);
-          hooks["bun:ping"]?.(peer, ws, data);
+          const peer = getWSPeer(ws);
+          crossws.$("bun:ping", peer, ws, data);
         },
         pong(ws, data) {
-          const peer = getPeer(ws);
-          hooks["bun:pong"]?.(peer, ws, data);
+          const peer = getWSPeer(ws);
+          crossws.$("bun:pong", peer, ws, data);
         }
       }
     };
   }
 );
-class WebSocketPeer extends peer.WebSocketPeerBase {
+class BunWSPeer extends peer.WSPeer {
   get id() {
     let addr = this.ctx.bun.ws.remoteAddress;
     if (addr.includes(":")) {
@@ -63,9 +68,27 @@ class WebSocketPeer extends peer.WebSocketPeerBase {
   get readyState() {
     return this.ctx.bun.ws.readyState;
   }
-  send(message) {
-    this.ctx.bun.ws.send(message);
-    return 0;
+  get url() {
+    return this.ctx.bun.ws.data.req?.url || "/";
+  }
+  get headers() {
+    return this.ctx.bun.ws.data.req?.headers || new Headers();
+  }
+  send(message, options) {
+    return this.ctx.bun.ws.send(peer.toBufferLike(message), options?.compress);
+  }
+  publish(topic, message, options) {
+    return this.ctx.bun.ws.publish(
+      topic,
+      peer.toBufferLike(message),
+      options?.compress
+    );
+  }
+  subscribe(topic) {
+    this.ctx.bun.ws.subscribe(topic);
+  }
+  unsubscribe(topic) {
+    this.ctx.bun.ws.unsubscribe(topic);
   }
 }
 

package/dist/adapters/bun.d.cts

@@ -1,12 +1,16 @@
-import { WebSocketAdapter } from '../index.cjs';
+import { CrossWSOptions, WebSocketAdapter, WSPeer } from '../index.cjs';
+import { WebSocketHandler, Server } from 'bun';
 
-interface AdapterOptions {
+interface AdapterOptions extends CrossWSOptions {
 }
-type WebSocketHooks = Extract<Parameters<typeof Bun.serve<ContextData>>[0], {
-    websocket: any;
-}>["websocket"];
+type ContextData = {
+    _peer?: WSPeer;
+    req?: Request;
+    server?: Server;
+};
 interface Adapter {
-    websocket: WebSocketHooks;
+    websocket: WebSocketHandler<ContextData>;
+    handleUpgrade(req: Request, server: Server): Promise<boolean>;
 }
 declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
 

package/dist/adapters/bun.d.mts

@@ -1,12 +1,16 @@
-import { WebSocketAdapter } from '../index.mjs';
+import { CrossWSOptions, WebSocketAdapter, WSPeer } from '../index.mjs';
+import { WebSocketHandler, Server } from 'bun';
 
-interface AdapterOptions {
+interface AdapterOptions extends CrossWSOptions {
 }
-type WebSocketHooks = Extract<Parameters<typeof Bun.serve<ContextData>>[0], {
-    websocket: any;
-}>["websocket"];
+type ContextData = {
+    _peer?: WSPeer;
+    req?: Request;
+    server?: Server;
+};
 interface Adapter {
-    websocket: WebSocketHooks;
+    websocket: WebSocketHandler<ContextData>;
+    handleUpgrade(req: Request, server: Server): Promise<boolean>;
 }
 declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
 

package/dist/adapters/bun.d.ts

@@ -1,12 +1,16 @@
-import { WebSocketAdapter } from '../index.js';
+import { CrossWSOptions, WebSocketAdapter, WSPeer } from '../index.js';
+import { WebSocketHandler, Server } from 'bun';
 
-interface AdapterOptions {
+interface AdapterOptions extends CrossWSOptions {
 }
-type WebSocketHooks = Extract<Parameters<typeof Bun.serve<ContextData>>[0], {
-    websocket: any;
-}>["websocket"];
+type ContextData = {
+    _peer?: WSPeer;
+    req?: Request;
+    server?: Server;
+};
 interface Adapter {
-    websocket: WebSocketHooks;
+    websocket: WebSocketHandler<ContextData>;
+    handleUpgrade(req: Request, server: Server): Promise<boolean>;
 }
 declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
 

package/dist/adapters/bun.mjs

@@ -1,56 +1,61 @@
-import { d as defineWebSocketAdapter, a as WebSocketMessage, W as WebSocketError, b as WebSocketPeerBase } from '../shared/crossws.9536f626.mjs';
+import { d as defineWebSocketAdapter, c as createCrossWS, W as WSMessage, a as WSPeer, t as toBufferLike } from '../shared/crossws.a6b0a7cc.mjs';
 
 const bun = defineWebSocketAdapter(
-  (hooks, opts = {}) => {
-    const getPeer = (ws) => {
+  (hooks, options = {}) => {
+    const crossws = createCrossWS(hooks, options);
+    const getWSPeer = (ws) => {
       if (ws.data?._peer) {
         return ws.data._peer;
       }
-      const peer = new WebSocketPeer({ bun: { ws } });
+      const peer = new BunWSPeer({ bun: { ws } });
       ws.data = ws.data || {};
       ws.data._peer = peer;
       return peer;
     };
     return {
+      async handleUpgrade(req, server) {
+        const { headers } = await crossws.upgrade({
+          url: req.url,
+          headers: req.headers
+        });
+        return server.upgrade(req, {
+          data: { req, server },
+          headers
+        });
+      },
       websocket: {
         message: (ws, message) => {
-          const peer = getPeer(ws);
-          hooks["bun:message"]?.(peer, ws, message);
-          hooks.message?.(peer, new WebSocketMessage(message));
+          const peer = getWSPeer(ws);
+          crossws.$("bun:message", peer, ws, message);
+          crossws.message(peer, new WSMessage(message));
         },
         open: (ws) => {
-          const peer = getPeer(ws);
-          hooks["bun:open"]?.(peer, ws);
-          hooks.open?.(peer);
+          const peer = getWSPeer(ws);
+          crossws.$("bun:open", peer, ws);
+          crossws.open(peer);
         },
         close: (ws) => {
-          const peer = getPeer(ws);
-          hooks["bun:close"]?.(peer, ws);
-          hooks.close?.(peer, {});
+          const peer = getWSPeer(ws);
+          crossws.$("bun:close", peer, ws);
+          crossws.close(peer, {});
         },
         drain: (ws) => {
-          const peer = getPeer(ws);
-          hooks["bun:drain"]?.(peer);
-        },
-        // @ts-expect-error types unavailable but mentioned in docs
-        error: (ws, error) => {
-          const peer = getPeer(ws);
-          hooks["bun:error"]?.(peer, ws, error);
-          hooks.error?.(peer, new WebSocketError(error));
+          const peer = getWSPeer(ws);
+          crossws.$("bun:drain", peer);
         },
         ping(ws, data) {
-          const peer = getPeer(ws);
-          hooks["bun:ping"]?.(peer, ws, data);
+          const peer = getWSPeer(ws);
+          crossws.$("bun:ping", peer, ws, data);
         },
         pong(ws, data) {
-          const peer = getPeer(ws);
-          hooks["bun:pong"]?.(peer, ws, data);
+          const peer = getWSPeer(ws);
+          crossws.$("bun:pong", peer, ws, data);
         }
       }
     };
   }
 );
-class WebSocketPeer extends WebSocketPeerBase {
+class BunWSPeer extends WSPeer {
   get id() {
     let addr = this.ctx.bun.ws.remoteAddress;
     if (addr.includes(":")) {
@@ -61,9 +66,27 @@ class WebSocketPeer extends WebSocketPeerBase {
   get readyState() {
     return this.ctx.bun.ws.readyState;
   }
-  send(message) {
-    this.ctx.bun.ws.send(message);
-    return 0;
+  get url() {
+    return this.ctx.bun.ws.data.req?.url || "/";
+  }
+  get headers() {
+    return this.ctx.bun.ws.data.req?.headers || new Headers();
+  }
+  send(message, options) {
+    return this.ctx.bun.ws.send(toBufferLike(message), options?.compress);
+  }
+  publish(topic, message, options) {
+    return this.ctx.bun.ws.publish(
+      topic,
+      toBufferLike(message),
+      options?.compress
+    );
+  }
+  subscribe(topic) {
+    this.ctx.bun.ws.subscribe(topic);
+  }
+  unsubscribe(topic) {
+    this.ctx.bun.ws.unsubscribe(topic);
   }
 }