crossws 0.1.0 → 0.1.2

package/dist/adapters/node.mjs

@@ -3,7 +3,8 @@ import { v as validationExports, g as getDefaultExportFromCjs, e as extension$1,
 import require$$0 from 'events';
 import require$$2 from 'http';
 import require$$1 from 'crypto';
-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';
+import { W as WebSocketError } from '../shared/crossws.6f7f02b3.mjs';
 import 'https';
 import 'net';
 import 'tls';
@@ -612,53 +613,68 @@ function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
 const _WebSocketServer = /*@__PURE__*/getDefaultExportFromCjs(websocketServer);
 
 const node = defineWebSocketAdapter(
-  (hooks, opts = {}) => {
-    const wss = opts.wss || new _WebSocketServer({
+  (hooks, options = {}) => {
+    const crossws = createCrossWS(hooks, options);
+    const wss = options.wss || new _WebSocketServer({
       noServer: true,
-      ...opts.serverOptions
+      ...options.serverOptions
     });
     wss.on("connection", (ws, req) => {
-      const peer = new NodeWebSocketPeer({ node: { ws, req, server: wss } });
-      hooks.open?.(peer);
+      const peer = new NodeWSPeer({ node: { ws, req, server: wss } });
+      crossws.open(peer);
       ws.on("message", (data, isBinary) => {
-        hooks["node:message"]?.(peer, data, isBinary);
+        crossws.$("node:message", peer, data, isBinary);
         if (Array.isArray(data)) {
           data = Buffer.concat(data);
         }
-        hooks.message?.(peer, new WebSocketMessage(data, isBinary));
+        crossws.message(peer, new WSMessage(data, isBinary));
       });
       ws.on("error", (error) => {
-        hooks["node:error"]?.(peer, error);
-        hooks.error?.(peer, new WebSocketError(error));
+        crossws.$("node:error", peer, error);
+        crossws.error(peer, new WebSocketError(error));
       });
       ws.on("close", (code, reason) => {
-        hooks["node:close"]?.(peer, code, reason);
-        hooks.close?.(peer, {
+        crossws.$("node:close", peer, code, reason);
+        crossws.close(peer, {
           code,
           reason: reason?.toString()
         });
       });
       ws.on("open", () => {
-        hooks["node:open"]?.(peer);
+        crossws.$("node:open", peer);
       });
       ws.on("ping", (data) => {
-        hooks["node:ping"]?.(peer, data);
+        crossws.$("node:ping", peer, data);
       });
       ws.on("pong", (data) => {
-        hooks["node:pong"]?.(peer, data);
+        crossws.$("node:pong", peer, data);
       });
       ws.on(
         "unexpected-response",
         (req2, res) => {
-          hooks["node:unexpected-response"]?.(peer, req2, res);
+          crossws.$("node:unexpected-response", peer, req2, res);
         }
       );
       ws.on("upgrade", (req2) => {
-        hooks["node:upgrade"]?.(peer, req2);
+        crossws.$("node:upgrade", peer, req2);
       });
     });
+    wss.on("headers", function(outgoingHeaders, req) {
+      const upgradeHeaders = req._upgradeHeaders;
+      if (upgradeHeaders) {
+        const _headers = new Headers(upgradeHeaders);
+        for (const [key, value] of _headers) {
+          outgoingHeaders.push(`${key}: ${value}`);
+        }
+      }
+    });
     return {
-      handleUpgrade: (req, socket, head) => {
+      handleUpgrade: async (req, socket, head) => {
+        const { headers } = await crossws.upgrade({
+          url: req.url || "",
+          headers: req.headers
+        });
+        req._upgradeHeaders = headers;
         wss.handleUpgrade(req, socket, head, (ws) => {
           wss.emit("connection", ws, req);
         });
@@ -666,7 +682,7 @@ const node = defineWebSocketAdapter(
     };
   }
 );
-class NodeWebSocketPeer extends WebSocketPeerBase {
+class NodeWSPeer extends WSPeer {
   get id() {
     const socket = this.ctx.node.req.socket;
     if (!socket) {
@@ -675,11 +691,21 @@ class NodeWebSocketPeer extends WebSocketPeerBase {
     const addr = socket.remoteFamily === "IPv6" ? `[${socket.remoteAddress}]` : socket.remoteAddress;
     return `${addr}:${socket.remotePort}`;
   }
+  get url() {
+    return this.ctx.node.req.url || "/";
+  }
+  get headers() {
+    return this.ctx.node.req.headers;
+  }
   get readyState() {
     return this.ctx.node.ws.readyState;
   }
-  send(message, compress) {
-    this.ctx.node.ws.send(message, { compress });
+  send(message, options) {
+    this.ctx.node.ws.send(toBufferLike(message), {
+      compress: options?.compress,
+      binary: options?.binary,
+      ...options
+    });
     return 0;
   }
 }

package/dist/adapters/uws.cjs

@@ -0,0 +1,146 @@
+'use strict';
+
+const peer = require('../shared/crossws.6009d265.cjs');
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const uws = peer.defineWebSocketAdapter(
+  (hooks, options = {}) => {
+    const crossws = peer.createCrossWS(hooks, options);
+    const getWSPeer = (ws) => {
+      const userData = ws.getUserData();
+      if (userData._peer) {
+        return userData._peer;
+      }
+      const peer = new UWSWSPeer({ uws: { ws, userData } });
+      userData._peer = peer;
+      return peer;
+    };
+    const websocket = {
+      ...options.uws,
+      close(ws, code, message) {
+        const peer = getWSPeer(ws);
+        crossws.$("uws:close", peer, ws, code, message);
+        crossws.close(peer, { code, reason: message?.toString() });
+      },
+      drain(ws) {
+        const peer = getWSPeer(ws);
+        crossws.$("uws:drain", peer, ws);
+      },
+      message(ws, message, isBinary) {
+        const peer$1 = getWSPeer(ws);
+        crossws.$("uws:message", peer$1, ws, message, isBinary);
+        const msg = new peer.WSMessage(message, isBinary);
+        crossws.message(peer$1, msg);
+      },
+      open(ws) {
+        const peer = getWSPeer(ws);
+        crossws.$("uws:open", peer, ws);
+        crossws.open(peer);
+      },
+      ping(ws, message) {
+        const peer = getWSPeer(ws);
+        crossws.$("uws:ping", peer, ws, message);
+      },
+      pong(ws, message) {
+        const peer = getWSPeer(ws);
+        crossws.$("uws:pong", peer, ws, message);
+      },
+      subscription(ws, topic, newCount, oldCount) {
+        const peer = getWSPeer(ws);
+        crossws.$("uws:subscription", peer, ws, topic, newCount, oldCount);
+      },
+      async upgrade(res, req, context) {
+        let aborted = false;
+        res.onAborted(() => {
+          aborted = true;
+        });
+        const { headers } = await crossws.upgrade({
+          get url() {
+            return req.getUrl();
+          },
+          get headers() {
+            return _getHeaders(req);
+          }
+        });
+        res.writeStatus("101 Switching Protocols");
+        for (const [key, value] of new Headers(headers)) {
+          res.writeHeader(key, value);
+        }
+        if (aborted) {
+          return;
+        }
+        res.cork(() => {
+          res.upgrade(
+            {
+              req,
+              res,
+              context
+            },
+            req.getHeader("sec-websocket-key"),
+            req.getHeader("sec-websocket-protocol"),
+            req.getHeader("sec-websocket-extensions"),
+            context
+          );
+        });
+      }
+    };
+    return {
+      websocket
+    };
+  }
+);
+class UWSWSPeer extends peer.WSPeer {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_headers");
+    __publicField(this, "_decoder", new TextDecoder());
+  }
+  get id() {
+    try {
+      const addr = this._decoder.decode(
+        this.ctx.uws.ws?.getRemoteAddressAsText()
+      );
+      return addr.replace(/(0000:)+/, "");
+    } catch {
+    }
+  }
+  // TODO
+  // get readyState() {}
+  get url() {
+    return this.ctx.uws.userData.req.getUrl();
+  }
+  get headers() {
+    if (!this._headers) {
+      this._headers = _getHeaders(this.ctx.uws.userData.req);
+    }
+    return this._headers;
+  }
+  send(message, options) {
+    return this.ctx.uws.ws.send(
+      peer.toBufferLike(message),
+      options?.binary,
+      options?.compress
+    );
+  }
+  subscribe(topic) {
+    this.ctx.uws.ws.subscribe(topic);
+  }
+  publish(topic, message, options) {
+    this.ctx.uws.ws.publish(topic, message, options?.binary, options?.compress);
+    return 0;
+  }
+}
+function _getHeaders(req) {
+  const headers = [];
+  req.forEach((key, value) => {
+    headers.push([key, value]);
+  });
+  return headers;
+}
+
+module.exports = uws;

package/dist/adapters/uws.d.cts

@@ -0,0 +1,19 @@
+import { CrossWSOptions, WebSocketAdapter } from '../index.cjs';
+import { WebSocketBehavior, HttpRequest, HttpResponse } from 'uWebSockets.js';
+
+type UserData = {
+    _peer?: any;
+    req: HttpRequest;
+    res: HttpResponse;
+    context: any;
+};
+type WebSocketHandler = WebSocketBehavior<UserData>;
+interface AdapterOptions extends CrossWSOptions {
+    uws?: Exclude<WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
+}
+interface Adapter {
+    websocket: WebSocketHandler;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, _default as default };

package/dist/adapters/uws.d.mts

@@ -0,0 +1,19 @@
+import { CrossWSOptions, WebSocketAdapter } from '../index.mjs';
+import { WebSocketBehavior, HttpRequest, HttpResponse } from 'uWebSockets.js';
+
+type UserData = {
+    _peer?: any;
+    req: HttpRequest;
+    res: HttpResponse;
+    context: any;
+};
+type WebSocketHandler = WebSocketBehavior<UserData>;
+interface AdapterOptions extends CrossWSOptions {
+    uws?: Exclude<WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
+}
+interface Adapter {
+    websocket: WebSocketHandler;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, _default as default };

package/dist/adapters/uws.d.ts

@@ -0,0 +1,19 @@
+import { CrossWSOptions, WebSocketAdapter } from '../index.js';
+import { WebSocketBehavior, HttpRequest, HttpResponse } from 'uWebSockets.js';
+
+type UserData = {
+    _peer?: any;
+    req: HttpRequest;
+    res: HttpResponse;
+    context: any;
+};
+type WebSocketHandler = WebSocketBehavior<UserData>;
+interface AdapterOptions extends CrossWSOptions {
+    uws?: Exclude<WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
+}
+interface Adapter {
+    websocket: WebSocketHandler;
+}
+declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+
+export { type Adapter, type AdapterOptions, _default as default };

package/dist/adapters/uws.mjs

@@ -0,0 +1,144 @@
+import { d as defineWebSocketAdapter, c as createCrossWS, W as WSMessage, a as WSPeer, t as toBufferLike } from '../shared/crossws.a6b0a7cc.mjs';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const uws = defineWebSocketAdapter(
+  (hooks, options = {}) => {
+    const crossws = createCrossWS(hooks, options);
+    const getWSPeer = (ws) => {
+      const userData = ws.getUserData();
+      if (userData._peer) {
+        return userData._peer;
+      }
+      const peer = new UWSWSPeer({ uws: { ws, userData } });
+      userData._peer = peer;
+      return peer;
+    };
+    const websocket = {
+      ...options.uws,
+      close(ws, code, message) {
+        const peer = getWSPeer(ws);
+        crossws.$("uws:close", peer, ws, code, message);
+        crossws.close(peer, { code, reason: message?.toString() });
+      },
+      drain(ws) {
+        const peer = getWSPeer(ws);
+        crossws.$("uws:drain", peer, ws);
+      },
+      message(ws, message, isBinary) {
+        const peer = getWSPeer(ws);
+        crossws.$("uws:message", peer, ws, message, isBinary);
+        const msg = new WSMessage(message, isBinary);
+        crossws.message(peer, msg);
+      },
+      open(ws) {
+        const peer = getWSPeer(ws);
+        crossws.$("uws:open", peer, ws);
+        crossws.open(peer);
+      },
+      ping(ws, message) {
+        const peer = getWSPeer(ws);
+        crossws.$("uws:ping", peer, ws, message);
+      },
+      pong(ws, message) {
+        const peer = getWSPeer(ws);
+        crossws.$("uws:pong", peer, ws, message);
+      },
+      subscription(ws, topic, newCount, oldCount) {
+        const peer = getWSPeer(ws);
+        crossws.$("uws:subscription", peer, ws, topic, newCount, oldCount);
+      },
+      async upgrade(res, req, context) {
+        let aborted = false;
+        res.onAborted(() => {
+          aborted = true;
+        });
+        const { headers } = await crossws.upgrade({
+          get url() {
+            return req.getUrl();
+          },
+          get headers() {
+            return _getHeaders(req);
+          }
+        });
+        res.writeStatus("101 Switching Protocols");
+        for (const [key, value] of new Headers(headers)) {
+          res.writeHeader(key, value);
+        }
+        if (aborted) {
+          return;
+        }
+        res.cork(() => {
+          res.upgrade(
+            {
+              req,
+              res,
+              context
+            },
+            req.getHeader("sec-websocket-key"),
+            req.getHeader("sec-websocket-protocol"),
+            req.getHeader("sec-websocket-extensions"),
+            context
+          );
+        });
+      }
+    };
+    return {
+      websocket
+    };
+  }
+);
+class UWSWSPeer extends WSPeer {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_headers");
+    __publicField(this, "_decoder", new TextDecoder());
+  }
+  get id() {
+    try {
+      const addr = this._decoder.decode(
+        this.ctx.uws.ws?.getRemoteAddressAsText()
+      );
+      return addr.replace(/(0000:)+/, "");
+    } catch {
+    }
+  }
+  // TODO
+  // get readyState() {}
+  get url() {
+    return this.ctx.uws.userData.req.getUrl();
+  }
+  get headers() {
+    if (!this._headers) {
+      this._headers = _getHeaders(this.ctx.uws.userData.req);
+    }
+    return this._headers;
+  }
+  send(message, options) {
+    return this.ctx.uws.ws.send(
+      toBufferLike(message),
+      options?.binary,
+      options?.compress
+    );
+  }
+  subscribe(topic) {
+    this.ctx.uws.ws.subscribe(topic);
+  }
+  publish(topic, message, options) {
+    this.ctx.uws.ws.publish(topic, message, options?.binary, options?.compress);
+    return 0;
+  }
+}
+function _getHeaders(req) {
+  const headers = [];
+  req.forEach((key, value) => {
+    headers.push([key, value]);
+  });
+  return headers;
+}
+
+export { uws as default };

package/dist/index.cjs

@@ -1,13 +1,15 @@
 'use strict';
 
-const peer = require('./shared/crossws.21e14e0d.cjs');
+const peer = require('./shared/crossws.6009d265.cjs');
+const error = require('./shared/crossws.deae10fd.cjs');
 
 function defineWebSocketHooks(hooks) {
   return hooks;
 }
 
-exports.WebSocketError = peer.WebSocketError;
-exports.WebSocketMessage = peer.WebSocketMessage;
-exports.WebSocketPeerBase = peer.WebSocketPeerBase;
+exports.WSMessage = peer.WSMessage;
+exports.WSPeer = peer.WSPeer;
+exports.createCrossWS = peer.createCrossWS;
 exports.defineWebSocketAdapter = peer.defineWebSocketAdapter;
+exports.WebSocketError = error.WebSocketError;
 exports.defineWebSocketHooks = defineWebSocketHooks;

package/dist/index.d.cts

@@ -2,40 +2,65 @@ declare class WebSocketError extends Error {
     constructor(...args: any[]);
 }
 
-declare class WebSocketMessage {
-    readonly rawData: string | ArrayBuffer | Uint8Array;
+declare class WSMessage {
+    readonly rawData: any;
     readonly isBinary?: boolean | undefined;
-    constructor(rawData: string | ArrayBuffer | Uint8Array, isBinary?: boolean | undefined);
+    constructor(rawData: any, isBinary?: boolean | undefined);
     text(): string;
     toString(): string;
 }
 
 type ReadyState = 0 | 1 | 2 | 3;
-interface WebSocketContext {
+interface WSRequest {
+    readonly url: string;
+    readonly headers: HeadersInit;
 }
-declare abstract class WebSocketPeerBase<T extends WebSocketContext = WebSocketContext> {
-    ctx: T;
-    constructor(ctx: T);
+declare abstract class WSPeer<AdapterContext = any> implements WSRequest {
+    ctx: AdapterContext;
+    _subscriptions: Set<string>;
+    constructor(ctx: AdapterContext);
     get id(): string | undefined;
+    get url(): string;
+    get headers(): HeadersInit;
     get readyState(): ReadyState | -1;
-    abstract send(message: string | ArrayBuffer | Uint8Array, compress?: boolean): number;
+    abstract send(message: any, options?: {
+        compress?: boolean;
+    }): number;
+    publish(topic: string, message: any, options?: {
+        compress?: boolean;
+    }): void;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
     toString(): string;
 }
 
-type WSHook<ArgsT extends Array<any> = []> = (peer: WebSocketPeerBase, ...args: ArgsT) => void | Promise<void>;
-declare function defineWebSocketHooks(hooks: Partial<WebSocketHooks>): Partial<WebSocketHooks>;
+type MaybePromise<T> = T | Promise<T>;
+type _UserHooks = WebSocketHooks & AdapterHooks;
+type UserHooks = Partial<_UserHooks>;
+declare function defineWebSocketHooks<T extends UserHooks = UserHooks>(hooks: T): T;
+type UserHookName = Exclude<keyof _UserHooks, "$">;
+type CatchAllHandler = <Name extends UserHookName>(name: Name, ...args: Parameters<_UserHooks[Name]>) => MaybePromise<void>;
 interface WebSocketHooks {
+    /** Catch-all handler */
+    $: CatchAllHandler;
+    /** Upgrading */
+    upgrade: (req: WSRequest) => MaybePromise<void | {
+        headers?: HeadersInit;
+    }>;
     /** A message is received */
-    message: WSHook<[WebSocketMessage]>;
+    message: (peer: WSPeer, message: WSMessage) => MaybePromise<void>;
     /** A socket is opened */
-    open: WSHook<[]>;
+    open: (peer: WSPeer) => MaybePromise<void>;
     /** A socket is closed */
-    close: WSHook<[{
+    close: (peer: WSPeer, details: {
         code?: number;
         reason?: string;
-    }]>;
+    }) => MaybePromise<void>;
     /** An error occurs */
-    error: WSHook<[WebSocketError]>;
+    error: (peer: WSPeer, error: WebSocketError) => MaybePromise<void>;
+}
+type WSHook<ArgsT extends Array<any> = []> = (peer: WSPeer, ...args: ArgsT) => MaybePromise<void>;
+interface AdapterHooks {
     "bun:message": WSHook<[ws: any, message: any]>;
     "bun:open": WSHook<[ws: any]>;
     "bun:close": WSHook<[ws: any]>;
@@ -59,9 +84,32 @@ interface WebSocketHooks {
     "node:pong": WSHook<[data: Buffer]>;
     "node:unexpected-response": WSHook<[req: any, res: any]>;
     "node:upgrade": WSHook<[req: any]>;
+    "uws:open": WSHook<[ws: any]>;
+    "uws:message": WSHook<[ws: any, message: any, isBinary: boolean]>;
+    "uws:close": WSHook<[ws: any, code: number, message: any]>;
+    "uws:ping": WSHook<[ws: any, message: any]>;
+    "uws:pong": WSHook<[ws: any, message: any]>;
+    "uws:drain": WSHook<[ws: any]>;
+    "uws:upgrade": WSHook<[res: any, req: any, context: any]>;
+    "uws:subscription": WSHook<[
+        ws: any,
+        topic: any,
+        newCount: number,
+        oldCount: number
+    ]>;
 }
 
-type WebSocketAdapter<RT = any, OT = any> = (hooks: Partial<WebSocketHooks>, opts: OT) => RT;
+type WebSocketAdapter<RT = any, OT = any> = (hooks: Partial<WebSocketHooks & AdapterHooks>, opts: OT) => RT;
 declare function defineWebSocketAdapter<RT, OT>(factory: WebSocketAdapter<RT, OT>): WebSocketAdapter<RT, OT>;
 
-export { type WebSocketAdapter, type WebSocketContext, WebSocketError, type WebSocketHooks, WebSocketMessage, WebSocketPeerBase, defineWebSocketAdapter, defineWebSocketHooks };
+interface CrossWS extends WebSocketHooks {
+    upgrade: (req: WSRequest) => Promise<{
+        headers: HeadersInit;
+    }>;
+}
+interface CrossWSOptions {
+    resolve?: (info: WSRequest | WSPeer) => UserHooks | Promise<UserHooks>;
+}
+declare function createCrossWS(hooks: UserHooks, options: CrossWSOptions): CrossWS;
+
+export { type AdapterHooks, type CrossWS, type CrossWSOptions, type UserHooks, WSMessage, WSPeer, type WSRequest, type WebSocketAdapter, WebSocketError, type WebSocketHooks, type _UserHooks, createCrossWS, defineWebSocketAdapter, defineWebSocketHooks };