crossws 0.3.5 → 0.4.1

package/dist/adapters/uws.mjs

@@ -1,15 +1,16 @@
-import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.DfCzGthR.mjs';
-import { a as adapterUtils, A as AdapterHookable } from '../shared/crossws.D9ehKjSh.mjs';
-import 'uncrypto';
+import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.WpyOHUXc.mjs';
+import { a as adapterUtils, A as AdapterHookable, g as getPeers } from '../shared/crossws.CPlNx7g8.mjs';
+import { S as StubRequest } from '../shared/crossws.B31KJMcF.mjs';
 
 const uwsAdapter = (options = {}) => {
   const hooks = new AdapterHookable(options);
-  const peers = /* @__PURE__ */ new Set();
+  const globalPeers = /* @__PURE__ */ new Map();
   return {
-    ...adapterUtils(peers),
+    ...adapterUtils(globalPeers),
     websocket: {
       ...options.uws,
       close(ws, code, message) {
+        const peers = getPeers(globalPeers, ws.getUserData().namespace);
         const peer = getPeer(ws, peers);
         peer._internal.ws.readyState = 2;
         peers.delete(peer);
@@ -20,10 +21,12 @@ const uwsAdapter = (options = {}) => {
         peer._internal.ws.readyState = 3;
       },
       message(ws, message, isBinary) {
+        const peers = getPeers(globalPeers, ws.getUserData().namespace);
         const peer = getPeer(ws, peers);
         hooks.callHook("message", peer, new Message(message, peer));
       },
       open(ws) {
+        const peers = getPeers(globalPeers, ws.getUserData().namespace);
         const peer = getPeer(ws, peers);
         peers.add(peer);
         hooks.callHook("open", peer);
@@ -33,9 +36,8 @@ const uwsAdapter = (options = {}) => {
         res.onAborted(() => {
           aborted = true;
         });
-        const { upgradeHeaders, endResponse, context } = await hooks.upgrade(
-          new UWSReqProxy(req)
-        );
+        const webReq = new UWSReqProxy(req);
+        const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(webReq);
         if (endResponse) {
           res.writeStatus(`${endResponse.status} ${endResponse.statusText}`);
           for (const [key, value] of endResponse.headers) {
@@ -70,12 +72,14 @@ const uwsAdapter = (options = {}) => {
             {
               req,
               res,
+              webReq,
               protocol,
               extensions,
-              context
+              context,
+              namespace
             },
             key,
-            protocol,
+            "",
             extensions,
             uwsContext
           );
@@ -93,7 +97,8 @@ function getPeer(uws, peers) {
     peers,
     uws,
     ws: new UwsWebSocketProxy(uws),
-    request: new UWSReqProxy(uwsData.req),
+    request: uwsData.webReq,
+    namespace: uwsData.namespace,
     uwsData
   });
   uwsData.peer = peer;
@@ -138,30 +143,23 @@ class UWSPeer extends Peer {
     this._internal.uws.close();
   }
 }
-class UWSReqProxy {
-  _headers;
-  _rawHeaders = [];
-  url;
-  constructor(_req) {
+class UWSReqProxy extends StubRequest {
+  constructor(req) {
+    const rawHeaders = [];
     let host = "localhost";
     let proto = "http";
-    _req.forEach((key, value) => {
+    req.forEach((key, value) => {
       if (key === "host") {
         host = value;
       } else if (key === "x-forwarded-proto" && value === "https") {
         proto = "https";
       }
-      this._rawHeaders.push([key, value]);
+      rawHeaders.push([key, value]);
     });
-    const query = _req.getQuery();
-    const pathname = _req.getUrl();
-    this.url = `${proto}://${host}${pathname}${query ? `?${query}` : ""}`;
-  }
-  get headers() {
-    if (!this._headers) {
-      this._headers = new Headers(this._rawHeaders);
-    }
-    return this._headers;
+    const query = req.getQuery();
+    const pathname = req.getUrl();
+    const url = `${proto}://${host}${pathname}${query ? `?${query}` : ""}`;
+    super(url, { headers: rawHeaders });
   }
 }
 class UwsWebSocketProxy {

package/dist/index.d.mts

@@ -2,11 +2,14 @@ import { W as WebSocket } from './shared/crossws.BQXMA5bH.mjs';
 
 declare const kNodeInspect: unique symbol;
 
+interface PeerContext extends Record<string, unknown> {
+}
 interface AdapterInternal {
     ws: unknown;
-    request: UpgradeRequest;
+    request: Request;
+    namespace: string;
     peers?: Set<Peer>;
-    context?: Peer["context"];
+    context?: PeerContext;
 }
 declare abstract class Peer<Internal extends AdapterInternal = AdapterInternal> {
     #private;
@@ -14,7 +17,8 @@ declare abstract class Peer<Internal extends AdapterInternal = AdapterInternal>
     protected _topics: Set<string>;
     protected _id?: string;
     constructor(internal: Internal);
-    get context(): Record<string, unknown>;
+    get context(): PeerContext;
+    get namespace(): string;
     /**
      * Unique random [uuid v4](https://developer.mozilla.org/en-US/docs/Glossary/UUID) identifier for the peer.
      */
@@ -22,7 +26,7 @@ declare abstract class Peer<Internal extends AdapterInternal = AdapterInternal>
     /** IP address of the peer */
     get remoteAddress(): string | undefined;
     /** upgrade request */
-    get request(): UpgradeRequest;
+    get request(): Request;
     /**
      * Get the [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) instance.
      *
@@ -54,15 +58,19 @@ declare abstract class Peer<Internal extends AdapterInternal = AdapterInternal>
     toString(): string;
     [Symbol.toPrimitive](): string;
     [Symbol.toStringTag](): "WebSocket";
-    [kNodeInspect](): Record<string, unknown>;
+    [kNodeInspect](): unknown;
 }
 
 interface AdapterInstance {
-    readonly peers: Set<Peer>;
-    readonly publish: Peer["publish"];
+    readonly peers: Map<string, Set<Peer>>;
+    readonly publish: (topic: string, data: unknown, options?: {
+        compress?: boolean;
+        namespace?: string;
+    }) => void;
 }
 interface AdapterOptions {
     resolve?: ResolveHooks;
+    getNamespace?: (request: Request) => string;
     hooks?: Partial<Hooks>;
 }
 type Adapter<AdapterT extends AdapterInstance = AdapterInstance, Options extends AdapterOptions = AdapterOptions> = (options?: Options) => AdapterT;
@@ -118,28 +126,33 @@ declare class Message implements Partial<MessageEvent> {
     get data(): unknown;
     toString(): string;
     [Symbol.toPrimitive](): string;
-    [kNodeInspect](): {
-        data: unknown;
-    };
+    [kNodeInspect](): unknown;
 }
 
 declare function defineHooks<T extends Partial<Hooks> = Partial<Hooks>>(hooks: T): T;
-type ResolveHooks = (info: RequestInit | Peer) => Partial<Hooks> | Promise<Partial<Hooks>>;
+type ResolveHooks = (request: Request & {
+    readonly context?: PeerContext;
+}) => Partial<Hooks> | Promise<Partial<Hooks>>;
 type MaybePromise<T> = T | Promise<T>;
-type UpgradeRequest = Request | {
-    url: string;
-    headers: Headers;
-};
 interface Hooks {
-    /** Upgrading */
     /**
+     * Upgrading a request to a WebSocket connection.
+     *
+     * - You can throw a Response to abort the upgrade.
+     * - You can return { headers } to modify the response.
+     * - You can return { namespace } to change the pub/sub namespace.
+     * - You can return { context } to provide a custom peer context.
      *
      * @param request
      * @throws {Response}
      */
-    upgrade: (request: UpgradeRequest & {
-        context: Peer["context"];
-    }) => MaybePromise<Response | ResponseInit | void>;
+    upgrade: (request: Request & {
+        readonly context?: Record<string, unknown>;
+    }) => MaybePromise<{
+        headers?: HeadersInit;
+        namespace?: string;
+        context?: PeerContext;
+    } | Response | void>;
     /** A message is received */
     message: (peer: Peer, message: Message) => MaybePromise<void>;
     /** A socket is opened */
@@ -154,4 +167,4 @@ interface Hooks {
 }
 
 export { Message, Peer, WSError, defineHooks, defineWebSocketAdapter };
-export type { Adapter, AdapterInstance, AdapterInternal, AdapterOptions, Hooks, ResolveHooks };
+export type { Adapter, AdapterInstance, AdapterInternal, AdapterOptions, Hooks, PeerContext, ResolveHooks };

package/dist/index.mjs

@@ -1 +1 @@
-export { d as defineHooks, b as defineWebSocketAdapter } from './shared/crossws.D9ehKjSh.mjs';
+export { d as defineHooks, b as defineWebSocketAdapter } from './shared/crossws.CPlNx7g8.mjs';

package/dist/server/bun.d.mts

@@ -0,0 +1,24 @@
+import { ServerPlugin, Server } from 'srvx/types';
+import { W as WSOptions, S as ServerWithWSOptions } from '../shared/crossws.95-eYp2D.mjs';
+import '../index.mjs';
+import '../shared/crossws.BQXMA5bH.mjs';
+import '../adapters/bun.mjs';
+import 'bun';
+import '../adapters/deno.mjs';
+import '../adapters/node.mjs';
+import 'node:http';
+import 'node:stream';
+import 'events';
+import 'node:https';
+import 'node:tls';
+import 'node:url';
+import 'node:zlib';
+import '../adapters/sse.mjs';
+import '../adapters/cloudflare.mjs';
+import '@cloudflare/workers-types';
+import 'cloudflare:workers';
+
+declare function plugin(wsOpts: WSOptions): ServerPlugin;
+declare function serve(options: ServerWithWSOptions): Server;
+
+export { plugin, serve };

package/dist/server/bun.mjs

@@ -0,0 +1,37 @@
+import { serve as serve$1 } from 'srvx/bun';
+import bunAdapter from '../adapters/bun.mjs';
+import '../shared/crossws.WpyOHUXc.mjs';
+import '../shared/crossws.CPlNx7g8.mjs';
+
+function plugin(wsOpts) {
+  return (server) => {
+    const ws = bunAdapter({
+      hooks: wsOpts,
+      resolve: wsOpts.resolve,
+      ...wsOpts.options?.bun
+    });
+    server.options.middleware.unshift((req, next) => {
+      if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+        return ws.handleUpgrade(
+          req,
+          req.runtime.bun.server
+        );
+      }
+      return next();
+    });
+    server.options.bun ??= {};
+    if (server.options.bun.websocket) {
+      throw new Error("websocket handlers for bun already set!");
+    }
+    server.options.bun.websocket = ws.websocket;
+  };
+}
+function serve(options) {
+  if (options.websocket) {
+    options.plugins ||= [];
+    options.plugins.push(plugin(options.websocket));
+  }
+  return serve$1(options);
+}
+
+export { plugin, serve };

package/dist/server/cloudflare.d.mts

@@ -0,0 +1,24 @@
+import { ServerPlugin, Server } from 'srvx/types';
+import { W as WSOptions, S as ServerWithWSOptions } from '../shared/crossws.95-eYp2D.mjs';
+import '../index.mjs';
+import '../shared/crossws.BQXMA5bH.mjs';
+import '../adapters/bun.mjs';
+import 'bun';
+import '../adapters/deno.mjs';
+import '../adapters/node.mjs';
+import 'node:http';
+import 'node:stream';
+import 'events';
+import 'node:https';
+import 'node:tls';
+import 'node:url';
+import 'node:zlib';
+import '../adapters/sse.mjs';
+import '../adapters/cloudflare.mjs';
+import '@cloudflare/workers-types';
+import 'cloudflare:workers';
+
+declare function plugin(wsOpts: WSOptions): ServerPlugin;
+declare function serve(options: ServerWithWSOptions): Server;
+
+export { plugin, serve };

package/dist/server/cloudflare.mjs

@@ -0,0 +1,36 @@
+import { serve as serve$1 } from 'srvx/cloudflare';
+import cloudflareAdapter from '../adapters/cloudflare.mjs';
+import 'cloudflare:workers';
+import '../shared/crossws.WpyOHUXc.mjs';
+import '../shared/crossws.CPlNx7g8.mjs';
+import '../shared/crossws.B31KJMcF.mjs';
+import '../shared/crossws.By9qWDAI.mjs';
+
+function plugin(wsOpts) {
+  return (server) => {
+    const ws = cloudflareAdapter({
+      hooks: wsOpts,
+      resolve: wsOpts.resolve,
+      ...wsOpts.options?.cloudflare
+    });
+    server.options.middleware.unshift((req, next) => {
+      if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+        return ws.handleUpgrade(
+          req,
+          req.runtime.cloudflare.env,
+          req.runtime.cloudflare.context
+        );
+      }
+      return next();
+    });
+  };
+}
+function serve(options) {
+  if (options.websocket) {
+    options.plugins ||= [];
+    options.plugins.push(plugin(options.websocket));
+  }
+  return serve$1(options);
+}
+
+export { plugin, serve };

package/dist/server/default.d.mts

@@ -0,0 +1,24 @@
+import { ServerPlugin, Server } from 'srvx/types';
+import { W as WSOptions, S as ServerWithWSOptions } from '../shared/crossws.95-eYp2D.mjs';
+import '../index.mjs';
+import '../shared/crossws.BQXMA5bH.mjs';
+import '../adapters/bun.mjs';
+import 'bun';
+import '../adapters/deno.mjs';
+import '../adapters/node.mjs';
+import 'node:http';
+import 'node:stream';
+import 'events';
+import 'node:https';
+import 'node:tls';
+import 'node:url';
+import 'node:zlib';
+import '../adapters/sse.mjs';
+import '../adapters/cloudflare.mjs';
+import '@cloudflare/workers-types';
+import 'cloudflare:workers';
+
+declare function plugin(wsOpts: WSOptions): ServerPlugin;
+declare function serve(options: ServerWithWSOptions): Server;
+
+export { plugin, serve };

package/dist/server/default.mjs

@@ -0,0 +1,32 @@
+import { serve as serve$1 } from 'srvx';
+import sseAdapter from '../adapters/sse.mjs';
+import '../shared/crossws.WpyOHUXc.mjs';
+import '../shared/crossws.CPlNx7g8.mjs';
+
+function plugin(wsOpts) {
+  const ws = sseAdapter({
+    hooks: wsOpts,
+    resolve: wsOpts.resolve,
+    ...wsOpts.options?.sse
+  });
+  console.warn(
+    "[crossws] Using SSE adapter for WebSocket support. This requires a custom WebSocket client (https://crossws.h3.dev/adapters/sse)."
+  );
+  return (server) => {
+    server.options.middleware.unshift((req, next) => {
+      if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+        return ws.fetch(req);
+      }
+      return next();
+    });
+  };
+}
+function serve(options) {
+  if (options.websocket) {
+    options.plugins ||= [];
+    options.plugins.push(plugin(options.websocket));
+  }
+  return serve$1(options);
+}
+
+export { plugin, serve };

package/dist/server/deno.d.mts

@@ -0,0 +1,24 @@
+import { ServerPlugin, Server } from 'srvx/types';
+import { W as WSOptions, S as ServerWithWSOptions } from '../shared/crossws.95-eYp2D.mjs';
+import '../index.mjs';
+import '../shared/crossws.BQXMA5bH.mjs';
+import '../adapters/bun.mjs';
+import 'bun';
+import '../adapters/deno.mjs';
+import '../adapters/node.mjs';
+import 'node:http';
+import 'node:stream';
+import 'events';
+import 'node:https';
+import 'node:tls';
+import 'node:url';
+import 'node:zlib';
+import '../adapters/sse.mjs';
+import '../adapters/cloudflare.mjs';
+import '@cloudflare/workers-types';
+import 'cloudflare:workers';
+
+declare function plugin(wsOpts: WSOptions): ServerPlugin;
+declare function serve(options: ServerWithWSOptions): Server;
+
+export { plugin, serve };

package/dist/server/deno.mjs

@@ -0,0 +1,30 @@
+import { serve as serve$1 } from 'srvx/deno';
+import denoAdapter from '../adapters/deno.mjs';
+import '../shared/crossws.WpyOHUXc.mjs';
+import '../shared/crossws.CPlNx7g8.mjs';
+import '../shared/crossws.By9qWDAI.mjs';
+
+function plugin(wsOpts) {
+  return (server) => {
+    const ws = denoAdapter({
+      hooks: wsOpts,
+      resolve: wsOpts.resolve,
+      ...wsOpts.options?.deno
+    });
+    server.options.middleware.unshift((req, next) => {
+      if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+        return ws.handleUpgrade(req, req.runtime.deno.info);
+      }
+      return next();
+    });
+  };
+}
+function serve(options) {
+  if (options.websocket) {
+    options.plugins ||= [];
+    options.plugins.push(plugin(options.websocket));
+  }
+  return serve$1(options);
+}
+
+export { plugin, serve };

package/dist/server/node.d.mts

@@ -0,0 +1,24 @@
+import { ServerPlugin, Server } from 'srvx/types';
+import { W as WSOptions, S as ServerWithWSOptions } from '../shared/crossws.95-eYp2D.mjs';
+import '../index.mjs';
+import '../shared/crossws.BQXMA5bH.mjs';
+import '../adapters/bun.mjs';
+import 'bun';
+import '../adapters/deno.mjs';
+import '../adapters/node.mjs';
+import 'node:http';
+import 'node:stream';
+import 'events';
+import 'node:https';
+import 'node:tls';
+import 'node:url';
+import 'node:zlib';
+import '../adapters/sse.mjs';
+import '../adapters/cloudflare.mjs';
+import '@cloudflare/workers-types';
+import 'cloudflare:workers';
+
+declare function plugin(wsOpts: WSOptions): ServerPlugin;
+declare function serve(options: ServerWithWSOptions): Server;
+
+export { plugin, serve };

package/dist/server/node.mjs

@@ -0,0 +1,49 @@
+import { NodeRequest, serve as serve$1 } from 'srvx/node';
+import nodeAdapter from '../adapters/node.mjs';
+import '../shared/crossws.WpyOHUXc.mjs';
+import '../shared/crossws.CPlNx7g8.mjs';
+import '../shared/crossws.By9qWDAI.mjs';
+import '../shared/crossws.CipVM6lf.mjs';
+import 'stream';
+import 'events';
+import 'http';
+import 'crypto';
+import 'buffer';
+import 'zlib';
+import 'https';
+import 'net';
+import 'tls';
+import 'url';
+import '../shared/crossws.B31KJMcF.mjs';
+
+function plugin(wsOpts) {
+  return (server) => {
+    const ws = nodeAdapter({
+      hooks: wsOpts,
+      resolve: wsOpts.resolve,
+      ...wsOpts.options?.deno
+    });
+    const originalServe = server.serve;
+    server.serve = () => {
+      server.node?.server.on("upgrade", (req, socket, head) => {
+        ws.handleUpgrade(
+          req,
+          socket,
+          head,
+          // @ts-expect-error (upgrade is not typed)
+          new NodeRequest({ req, upgrade: { socket, head } })
+        );
+      });
+      return originalServe.call(server);
+    };
+  };
+}
+function serve(options) {
+  if (options.websocket) {
+    options.plugins ||= [];
+    options.plugins.push(plugin(options.websocket));
+  }
+  return serve$1(options);
+}
+
+export { plugin, serve };

package/dist/shared/crossws.95-eYp2D.d.mts

@@ -0,0 +1,23 @@
+import { ServerRequest, ServerOptions } from 'srvx/types';
+import { Hooks } from '../index.mjs';
+import { BunOptions } from '../adapters/bun.mjs';
+import { DenoOptions } from '../adapters/deno.mjs';
+import { NodeOptions } from '../adapters/node.mjs';
+import { SSEOptions } from '../adapters/sse.mjs';
+import { CloudflareOptions } from '../adapters/cloudflare.mjs';
+
+type WSOptions = Partial<Hooks> & {
+    resolve?: (req: ServerRequest) => Partial<Hooks> | Promise<Partial<Hooks>>;
+    options?: {
+        bun?: BunOptions;
+        deno?: DenoOptions;
+        node?: NodeOptions;
+        sse?: SSEOptions;
+        cloudflare?: CloudflareOptions;
+    };
+};
+type ServerWithWSOptions = ServerOptions & {
+    websocket?: WSOptions;
+};
+
+export type { ServerWithWSOptions as S, WSOptions as W };

package/dist/shared/crossws.B31KJMcF.mjs

@@ -0,0 +1,83 @@
+const StubRequest = /* @__PURE__ */ (() => {
+  class StubRequest2 {
+    url;
+    _signal;
+    _headers;
+    _init;
+    constructor(url, init = {}) {
+      this.url = url;
+      this._init = init;
+    }
+    get headers() {
+      if (!this._headers) {
+        this._headers = new Headers(this._init?.headers);
+      }
+      return this._headers;
+    }
+    clone() {
+      return new StubRequest2(this.url, this._init);
+    }
+    // --- dummy ---
+    get method() {
+      return "GET";
+    }
+    get signal() {
+      return this._signal ??= new AbortSignal();
+    }
+    get cache() {
+      return "default";
+    }
+    get credentials() {
+      return "same-origin";
+    }
+    get destination() {
+      return "";
+    }
+    get integrity() {
+      return "";
+    }
+    get keepalive() {
+      return false;
+    }
+    get redirect() {
+      return "follow";
+    }
+    get mode() {
+      return "cors";
+    }
+    get referrer() {
+      return "about:client";
+    }
+    get referrerPolicy() {
+      return "";
+    }
+    get body() {
+      return null;
+    }
+    get bodyUsed() {
+      return false;
+    }
+    arrayBuffer() {
+      return Promise.resolve(new ArrayBuffer(0));
+    }
+    blob() {
+      return Promise.resolve(new Blob());
+    }
+    bytes() {
+      return Promise.resolve(new Uint8Array());
+    }
+    formData() {
+      return Promise.resolve(new FormData());
+    }
+    json() {
+      return Promise.resolve(JSON.parse(""));
+    }
+    text() {
+      return Promise.resolve("");
+    }
+  }
+  Object.setPrototypeOf(StubRequest2.prototype, globalThis.Request.prototype);
+  return StubRequest2;
+})();
+
+export { StubRequest as S };