@krisanalfa/bunest-adapter 0.0.1 → 0.3.0

package/dist/index.js

@@ -15,10 +15,10 @@ var __legacyMetadataTS = (k, v) => {
 };
 
 // lib/bun.adapter.ts
+var {randomUUIDv7 } = globalThis.Bun;
 import {
   Logger
 } from "@nestjs/common";
-var {randomUUIDv7 } = globalThis.Bun;
 import { AbstractHttpAdapter } from "@nestjs/core";
 
 // lib/bun.body-parser.middleware.ts
@@ -207,6 +207,57 @@ class BunMiddlewareEngine {
   useNotFoundHandler(handler) {
     this.notFoundHandler = handler;
   }
+  findRouteHandler(method, path) {
+    const exactHandler = this.findExactRouteHandler(method, path);
+    if (exactHandler)
+      return exactHandler;
+    return this.findPrefixRouteHandler(method, path);
+  }
+  findExactRouteHandler(method, path) {
+    const exactKey = `${method}:${path}`;
+    const exactMiddleware = this.routeMiddleware.get(exactKey);
+    if (exactMiddleware && exactMiddleware.length > 0) {
+      return exactMiddleware[exactMiddleware.length - 1];
+    }
+    const allExactKey = `ALL:${path}`;
+    const allExactMiddleware = this.routeMiddleware.get(allExactKey);
+    if (allExactMiddleware && allExactMiddleware.length > 0) {
+      return allExactMiddleware[allExactMiddleware.length - 1];
+    }
+    return null;
+  }
+  findPrefixRouteHandler(method, path) {
+    const methodMap = this.routeMiddlewareByMethod.get(method);
+    const allMethodMap = this.routeMiddlewareByMethod.get("ALL");
+    if (!methodMap && !allMethodMap)
+      return null;
+    const mapsToCheck = [];
+    if (methodMap)
+      mapsToCheck.push(methodMap);
+    if (allMethodMap)
+      mapsToCheck.push(allMethodMap);
+    return this.findBestMatchInMaps(mapsToCheck, path);
+  }
+  findBestMatchInMaps(maps, path) {
+    let bestMatch = null;
+    let bestMatchLength = 0;
+    const pathLen = path.length;
+    for (const map of maps) {
+      for (const [keyPath, middleware] of map) {
+        if (middleware.length === 0 || keyPath.length <= bestMatchLength)
+          continue;
+        if (this.isPrefixMatch(path, pathLen, keyPath)) {
+          bestMatch = middleware[middleware.length - 1];
+          bestMatchLength = keyPath.length;
+        }
+      }
+    }
+    return bestMatch;
+  }
+  isPrefixMatch(path, pathLen, keyPath) {
+    const keyPathLen = keyPath.length;
+    return path === keyPath || pathLen > keyPathLen && path.charCodeAt(keyPathLen) === 47 && path.startsWith(keyPath);
+  }
   async run(options) {
     try {
       const middlewares = this.getMiddlewareChain(options.method, options.path);
@@ -290,14 +341,17 @@ class BunMiddlewareEngine {
       }
       if (index === chainLength) {
         index++;
-        const result = requestHandler(req, res, next);
+        if (!res.isEnded()) {
+          const result = requestHandler(req, res, next);
+          if (result instanceof Promise)
+            await result;
+        }
+        return;
+      }
+      if (index > chainLength && !res.isEnded()) {
+        const result = this.notFoundHandler?.(req, res, noop);
         if (result instanceof Promise)
           await result;
-        if (index > chainLength) {
-          const result2 = this.notFoundHandler?.(req, res, noop);
-          if (result2 instanceof Promise)
-            await result2;
-        }
       }
     };
     await next();
@@ -313,6 +367,59 @@ class BunMiddlewareEngine {
   }
 }
 
+// lib/bun.preflight-http-server.ts
+class BunPreflightHttpServer {
+  adapter;
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  on(event, callback) {}
+  once() {}
+  removeListener() {}
+  async stop(force) {
+    const server = this.adapter.getBunHttpServerInstance();
+    if (server instanceof BunPreflightHttpServer) {
+      return;
+    }
+    await server.stop(force);
+  }
+  address() {
+    const server = this.adapter.getBunHttpServerInstance();
+    if (server instanceof BunPreflightHttpServer) {
+      const options = this.adapter.getBunServerOptions();
+      return {
+        address: options.hostname ?? "127.0.0.1",
+        port: options.port ?? 3000
+      };
+    }
+    return {
+      address: server.hostname,
+      port: server.port
+    };
+  }
+  setWsOptions(options) {
+    this.adapter.setWsOptions(options);
+  }
+  registerWsOpenHandler(handler) {
+    this.adapter.getWsHandlers().onOpen = handler;
+  }
+  registerWsMessageHandler(handler) {
+    this.adapter.getWsHandlers().onMessage = handler;
+  }
+  registerWsCloseHandler(handler) {
+    this.adapter.getWsHandlers().onClose = handler;
+  }
+  getWsHandlers() {
+    return this.adapter.getWsHandlers();
+  }
+  getBunServer() {
+    return this.adapter.getBunHttpServerInstance();
+  }
+  async close() {
+    await this.stop(true);
+  }
+}
+
 // lib/bun.request.ts
 import { parse } from "qs";
 var NULL_PROTO = Object.getPrototypeOf(Object.create(null));
@@ -341,8 +448,16 @@ class BunRequest {
     this.method = nativeRequest.method;
     this.params = nativeRequest.params;
   }
+  get socket() {
+    return {
+      encrypted: this._parsedUrl.protocol === "https:"
+    };
+  }
   get url() {
-    return this._url;
+    return this._parsedUrl.pathname + this._parsedUrl.search;
+  }
+  original() {
+    return this.nativeRequest;
   }
   get pathname() {
     return this._pathname ??= this._parsedUrl.pathname;
@@ -441,20 +556,22 @@ class BunResponse {
   resolve;
   response;
   cookieMap = new CookieMap;
-  _headers = null;
+  static textDecoder = new TextDecoder;
+  headers = null;
   statusCode = 200;
   ended = false;
-  _cookieHeaderCache = null;
+  cookieHeaders = null;
+  chunks = [];
   constructor() {
     this.response = new Promise((r) => {
       this.resolve = r;
     });
   }
   get headersMap() {
-    return this._headers ??= new Map;
+    return this.headers ??= new Map;
   }
   cookie(...args) {
-    this._cookieHeaderCache = null;
+    this.cookieHeaders = null;
     if (args.length === 1) {
       this.cookieMap.set(args[0]);
     } else {
@@ -478,10 +595,22 @@ class BunResponse {
     if (this.ended)
       return;
     this.ended = true;
-    this._cookieHeaderCache ??= this.cookieMap.toSetCookieHeaders().join("; ");
-    if (this._cookieHeaderCache.length > 0) {
-      this.setHeader("set-cookie", this._cookieHeaderCache);
+    this.applyCookieHeaders();
+    if (this.chunks.length > 0) {
+      const finalBody = this.combineChunks(body);
+      this.resolve(this.createResponse(finalBody));
+      return;
+    }
+    this.sendResponse(body);
+  }
+  applyCookieHeaders() {
+    this.cookieHeaders ??= this.cookieMap.toSetCookieHeaders();
+    if (this.cookieHeaders.length > 0) {
+      this.setHeader("set-cookie", this.cookieHeaders.join(`
+`));
     }
+  }
+  sendResponse(body) {
     if (body !== null && typeof body === "object") {
       if (body instanceof Uint8Array || body instanceof Blob) {
         this.resolve(this.createResponse(body));
@@ -500,11 +629,100 @@ class BunResponse {
     }
     this.resolve(this.buildJsonResponse(body));
   }
+  combineChunks(finalChunk) {
+    const hasStrings = this.chunks.some((chunk) => typeof chunk === "string");
+    const finalIsString = typeof finalChunk === "string";
+    if (hasStrings || finalIsString) {
+      return this.combineAsString(finalChunk);
+    }
+    return this.combineAsBinary(finalChunk);
+  }
+  combineAsString(finalChunk) {
+    const decoder = BunResponse.textDecoder;
+    const parts = this.chunks.map((chunk) => typeof chunk === "string" ? chunk : decoder.decode(chunk));
+    if (finalChunk !== undefined && finalChunk !== null) {
+      if (typeof finalChunk === "string") {
+        parts.push(finalChunk);
+      } else if (finalChunk instanceof Uint8Array) {
+        parts.push(decoder.decode(finalChunk));
+      } else if (typeof finalChunk === "object") {
+        parts.push(JSON.stringify(finalChunk));
+      } else {
+        parts.push(String(finalChunk));
+      }
+    }
+    return parts.join("");
+  }
+  combineAsBinary(finalChunk) {
+    const binaryChunks = this.chunks;
+    let totalLength = 0;
+    for (const chunk of binaryChunks) {
+      totalLength += chunk.length;
+    }
+    if (finalChunk instanceof Uint8Array) {
+      totalLength += finalChunk.length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of binaryChunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    if (finalChunk instanceof Uint8Array) {
+      result.set(finalChunk, offset);
+    }
+    return result;
+  }
   setHeader(name, value) {
     this.headersMap.set(name.toLowerCase(), value);
   }
+  writeHead(statusCode, headers) {
+    this.statusCode = statusCode;
+    if (headers) {
+      for (const [name, value] of Object.entries(headers)) {
+        this.setHeader(name, value);
+      }
+    }
+  }
+  on(event, listener) {
+    return this;
+  }
+  off(event, listener) {
+    return this;
+  }
+  destroyed = false;
+  destroy(error) {}
+  once(event, listener) {
+    return this;
+  }
+  write(chunk) {
+    if (this.ended) {
+      return false;
+    }
+    if (typeof chunk === "string") {
+      this.chunks.push(chunk);
+      return true;
+    }
+    if (chunk instanceof Uint8Array) {
+      this.chunks.push(chunk);
+      return true;
+    }
+    if (chunk instanceof Buffer) {
+      this.chunks.push(new Uint8Array(chunk));
+      return true;
+    }
+    if (chunk != null) {
+      if (typeof chunk === "object") {
+        this.chunks.push(JSON.stringify(chunk));
+      } else {
+        this.chunks.push(String(chunk));
+      }
+      return true;
+    }
+    return true;
+  }
   getHeader(name) {
-    return this._headers?.get(name.toLowerCase()) ?? null;
+    return this.headers?.get(name.toLowerCase()) ?? null;
   }
   appendHeader(name, value) {
     const key = name.toLowerCase();
@@ -513,7 +731,7 @@ class BunResponse {
     headers.set(key, existing ? `${existing}, ${value}` : value);
   }
   removeHeader(name) {
-    this._headers?.delete(name.toLowerCase());
+    this.headers?.delete(name.toLowerCase());
   }
   setStatus(code) {
     this.statusCode = code;
@@ -542,7 +760,7 @@ class BunResponse {
     return this.createResponse(body.getStream());
   }
   buildJsonResponse(body) {
-    const headers = this._headers;
+    const headers = this.headers;
     if (headers === null || headers.size === 0) {
       return Response.json(body, { status: this.statusCode });
     }
@@ -555,7 +773,7 @@ class BunResponse {
     });
   }
   createResponse(body) {
-    const headers = this._headers;
+    const headers = this.headers;
     if (headers === null || headers.size === 0) {
       return new Response(body, { status: this.statusCode });
     }
@@ -761,70 +979,103 @@ class BunAdapter extends AbstractHttpAdapter {
     res.setStatus(404);
     res.end({ message: "Not Found" });
   };
+  wsHandlers = {
+    onOpen: undefined,
+    onMessage: undefined,
+    onClose: undefined
+  };
+  wsMiddlewareEngine = new BunMiddlewareEngine;
+  wsOptions = {};
+  useWs = false;
+  useWsCors = false;
+  wsCorsHeaders;
   constructor(bunServeOptions = {
     development: false,
     id: randomUUIDv7()
   }) {
     super();
     this.bunServeOptions = bunServeOptions;
+    this.setInstance({
+      use: (maybePath, maybeHandler) => {
+        if (typeof maybePath === "string") {
+          let path = maybePath;
+          const handler = maybeHandler;
+          if (!handler) {
+            throw new Error("Handler must be provided when path is a string.");
+          }
+          if (path.includes("/*")) {
+            path = path.substring(0, path.indexOf("/*"));
+          }
+          this.logger.log(`Registering middleware for path: ${path}`);
+          this.middlewareEngine.useRoute("ALL", path, handler);
+        } else {
+          const handler = maybePath;
+          this.middlewareEngine.useGlobal(handler);
+        }
+      }
+    });
   }
   use(middleware) {
     this.middlewareEngine.useGlobal(middleware);
   }
+  createHttpMethodHandler(httpMethod) {
+    return (pathOrHandler, maybeHandler) => {
+      const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
+      this.delegateRouteHandler(httpMethod, path, handler);
+    };
+  }
   get(pathOrHandler, maybeHandler) {
-    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
-    this.delegateRouteHandler("GET", path, handler);
+    this.createHttpMethodHandler("GET")(pathOrHandler, maybeHandler);
   }
   post(pathOrHandler, maybeHandler) {
-    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
-    this.delegateRouteHandler("POST", path, handler);
+    this.createHttpMethodHandler("POST")(pathOrHandler, maybeHandler);
   }
   put(pathOrHandler, maybeHandler) {
-    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
-    this.delegateRouteHandler("PUT", path, handler);
+    this.createHttpMethodHandler("PUT")(pathOrHandler, maybeHandler);
   }
   patch(pathOrHandler, maybeHandler) {
-    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
-    this.delegateRouteHandler("PATCH", path, handler);
+    this.createHttpMethodHandler("PATCH")(pathOrHandler, maybeHandler);
   }
   delete(pathOrHandler, maybeHandler) {
-    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
-    this.delegateRouteHandler("DELETE", path, handler);
+    this.createHttpMethodHandler("DELETE")(pathOrHandler, maybeHandler);
   }
   head(pathOrHandler, maybeHandler) {
-    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
-    this.delegateRouteHandler("HEAD", path, handler);
+    this.createHttpMethodHandler("HEAD")(pathOrHandler, maybeHandler);
   }
   options(pathOrHandler, maybeHandler) {
-    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
-    this.delegateRouteHandler("OPTIONS", path, handler);
+    this.createHttpMethodHandler("OPTIONS")(pathOrHandler, maybeHandler);
+  }
+  createUnsupportedMethod() {
+    return (pathOrHandler, maybeHandler) => {
+      throw new Error("Not supported.");
+    };
   }
   all(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   propfind(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   proppatch(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   mkcol(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   copy(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   move(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   lock(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   unlock(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   search(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   useStaticAssets(...args) {
     throw new Error("Not supported.");
@@ -839,12 +1090,15 @@ class BunAdapter extends AbstractHttpAdapter {
     await this.httpServer.stop();
   }
   initHttpServer(options) {
-    this.setHttpServer({
-      once: () => {},
-      address: () => ({ address: "0.0.0.0", port: 0 }),
-      removeListener: () => {},
-      stop: () => {}
+    const preflightServer = new BunPreflightHttpServer({
+      getBunHttpServerInstance: () => this.getHttpServer(),
+      getBunServerOptions: () => this.bunServeOptions,
+      getWsHandlers: () => this.wsHandlers,
+      setWsOptions: (wsOptions) => {
+        this.wsOptions = wsOptions;
+      }
     });
+    this.setHttpServer(preflightServer);
     if (options.httpsOptions) {
       this.bunServeOptions.tls = {
         key: options.httpsOptions.key,
@@ -857,6 +1111,7 @@ class BunAdapter extends AbstractHttpAdapter {
         requestCert: options.httpsOptions.requestCert
       };
     }
+    return preflightServer;
   }
   getRequestHostname(request) {
     return request.hostname;
@@ -931,58 +1186,150 @@ class BunAdapter extends AbstractHttpAdapter {
     return BunVersionFilterMiddleware.createFilter(handler, version, versioningOptions);
   }
   listen(port, hostnameOrCallback, maybeCallback) {
-    const hostname = typeof hostnameOrCallback === "string" ? hostnameOrCallback : "localhost";
+    const hostname = typeof hostnameOrCallback === "string" ? hostnameOrCallback : this.bunServeOptions.hostname ?? "127.0.0.1";
     const callback = typeof hostnameOrCallback === "function" ? hostnameOrCallback : maybeCallback;
     const middlewareEngine = this.middlewareEngine;
     const notFoundHandler = this.notFoundHandler;
-    const fetch = async (request) => {
+    const wsHandlers = this.wsHandlers;
+    const bunServeOptions = this.bunServeOptions;
+    this.setupWebSocketIfNeeded(wsHandlers, bunServeOptions);
+    const fetch = async (request, server2) => {
+      if (await this.upgradeWebSocket(request, server2)) {
+        return;
+      }
       const bunRequest = new BunRequest(request);
       const bunResponse = new BunResponse;
+      const routeHandler = middlewareEngine.findRouteHandler(bunRequest.method, bunRequest.pathname) ?? notFoundHandler;
       await middlewareEngine.run({
         req: bunRequest,
         res: bunResponse,
         method: bunRequest.method,
         path: bunRequest.pathname,
-        requestHandler: notFoundHandler
+        requestHandler: routeHandler
       });
       return bunResponse.res();
     };
-    const omit = (obj, ...keys) => {
-      const result = { ...obj };
-      for (const key of keys) {
-        Reflect.deleteProperty(result, key);
+    const server = this.createServer(port, hostname, bunServeOptions, fetch);
+    callback?.();
+    this.setHttpServer(server);
+  }
+  static isNumericPort(value) {
+    return typeof value === "number" || !isNaN(Number(value));
+  }
+  static omitKeys(obj, ...keys) {
+    const result = { ...obj };
+    for (const key of keys) {
+      Reflect.deleteProperty(result, key);
+    }
+    return result;
+  }
+  isWebSocketUpgradeRequest(request) {
+    const upgradeHeader = request.headers.get("upgrade");
+    const connectionHeader = request.headers.get("connection");
+    return !!(upgradeHeader?.toLowerCase() === "websocket" && connectionHeader?.toLowerCase().includes("upgrade"));
+  }
+  async handleWebSocketCors(request) {
+    if (this.wsCorsHeaders) {
+      return this.wsCorsHeaders;
+    }
+    const bunRequest = new BunRequest(request);
+    const bunResponse = new BunResponse;
+    await this.wsMiddlewareEngine.run({
+      req: bunRequest,
+      res: bunResponse,
+      method: bunRequest.method,
+      path: bunRequest.pathname,
+      requestHandler: (req, res) => {
+        res.end();
       }
-      return result;
-    };
-    const server = typeof port === "number" || !isNaN(Number(port)) ? Bun.serve({
-      ...this.bunServeOptions,
+    });
+    const response = await bunResponse.res();
+    this.wsCorsHeaders = response.headers;
+    return this.wsCorsHeaders;
+  }
+  async upgradeWebSocket(request, server) {
+    if (!this.useWs || !this.isWebSocketUpgradeRequest(request)) {
+      return false;
+    }
+    if (!this.useWsCors) {
+      return server.upgrade(request, {
+        data: this.wsOptions.clientDataFactory ? this.wsOptions.clientDataFactory(new BunRequest(request)) : {}
+      });
+    }
+    const headers = await this.handleWebSocketCors(request);
+    return server.upgrade(request, {
+      headers,
+      data: this.wsOptions.clientDataFactory ? this.wsOptions.clientDataFactory(new BunRequest(request)) : {}
+    });
+  }
+  setupWebSocketIfNeeded(wsHandlers, bunServeOptions) {
+    const useWs = !!wsHandlers.onOpen && !!wsHandlers.onMessage && !!wsHandlers.onClose;
+    this.useWs = useWs;
+    if (useWs) {
+      const getServer = this.getHttpServer.bind(this);
+      const onMessage = wsHandlers.onMessage;
+      const onOpen = wsHandlers.onOpen;
+      const onClose = wsHandlers.onClose;
+      bunServeOptions.websocket = {
+        ...this.wsOptions,
+        message: (ws, message) => {
+          ws.data.onMessageInternal?.(message);
+          onMessage?.(ws, message, getServer());
+        },
+        open: (ws) => {
+          onOpen?.(ws);
+        },
+        close: (ws, code, reason) => {
+          ws.data.onCloseInternal?.();
+          ws.data.onDisconnect?.(ws);
+          onClose?.(ws, code, reason);
+        }
+      };
+    }
+    const useWsCors = typeof this.wsOptions.cors !== "undefined";
+    this.useWsCors = useWsCors;
+    if (useWsCors) {
+      const corsMiddleware = new BunCorsMiddleware({
+        corsOptions: this.wsOptions.cors === true ? undefined : this.wsOptions.cors
+      });
+      this.wsMiddlewareEngine.useGlobal(corsMiddleware.run.bind(corsMiddleware));
+    }
+  }
+  createServer(port, hostname, bunServeOptions, fetch) {
+    return BunAdapter.isNumericPort(port) ? Bun.serve({
+      ...bunServeOptions,
       hostname,
       port,
       routes: this.routes,
       fetch
     }) : Bun.serve({
-      ...omit(this.bunServeOptions, "idleTimeout"),
+      ...BunAdapter.omitKeys(bunServeOptions, "idleTimeout", "port", "hostname"),
       unix: port,
       routes: this.routes,
       fetch
     });
-    if (typeof port === "string" && isNaN(Number(port))) {
-      this.logger.log(`Bun server listening on unix socket: ${port}`);
-    }
-    callback?.();
-    Object.defineProperty(server, "address", {
-      configurable: true,
-      enumerable: true,
-      get: () => ({ address: server.hostname, port: server.port })
-    });
-    this.setHttpServer(server);
   }
   delegateRouteHandler(method, path, handler) {
+    this.ensureRouteExists(path);
+    const requestHandler = this.prepareRequestHandler(method, path, handler);
+    this.routes[path][method] = this.createRouteFetchHandler(path, method, requestHandler);
+  }
+  ensureRouteExists(path) {
     if (!(path in this.routes)) {
       this.routes[path] = Object.create(null);
     }
-    const requestHandler = !this.useVersioning ? handler : this.createChainedHandlerForVersioningResolution(this.createVersioningHandlers(method, path, handler), this.notFoundHandler);
-    this.routes[path][method] = async (request) => {
+  }
+  prepareRequestHandler(method, path, handler) {
+    if (!this.useVersioning) {
+      return handler;
+    }
+    return this.createChainedHandlerForVersioningResolution(this.createVersioningHandlers(method, path, handler), this.notFoundHandler);
+  }
+  createRouteFetchHandler(path, method, requestHandler) {
+    return async (request, server) => {
+      if (path === "/" && await this.upgradeWebSocket(request, server)) {
+        return;
+      }
       const bunRequest = new BunRequest(request);
       const bunResponse = new BunResponse;
       await this.middlewareEngine.run({
@@ -1078,12 +1425,159 @@ BunFileInterceptor = __legacyDecorateClassTS([
     typeof HttpAdapterHost === "undefined" ? Object : HttpAdapterHost
   ])
 ], BunFileInterceptor);
+// lib/bun.ws-adapter.ts
+import {
+  AbstractWsAdapter
+} from "@nestjs/websockets";
+import { EMPTY, Subject, mergeMap } from "rxjs";
+import { Logger as Logger2 } from "@nestjs/common";
+import { isNil } from "@nestjs/common/utils/shared.utils.js";
+var WS_READY_STATE_OPEN = 1;
+var defaultMessageParser = (data) => {
+  if (typeof data === "string") {
+    return JSON.parse(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return JSON.parse(new TextDecoder().decode(data));
+  }
+  if (Buffer.isBuffer(data)) {
+    return JSON.parse(data.toString("utf8"));
+  }
+  return JSON.parse(Buffer.concat(data).toString("utf8"));
+};
+
+class BunWsAdapter extends AbstractWsAdapter {
+  logger = new Logger2(BunWsAdapter.name);
+  nestApp;
+  messageParser = defaultMessageParser;
+  onOpenHandler;
+  globalHandlersInitialized = false;
+  constructor(appOrHttpServer) {
+    super(appOrHttpServer);
+    if (!appOrHttpServer || !("getHttpAdapter" in appOrHttpServer)) {
+      throw new Error("BunWsAdapter requires a NestApplication instance in the constructor.");
+    }
+    this.nestApp = appOrHttpServer;
+  }
+  create(_port, options) {
+    if (options?.messageParser) {
+      this.messageParser = options.messageParser;
+    }
+    const server = this.nestApp.getHttpAdapter().getHttpServer();
+    const wsOptions = this.extractWsOptions(options);
+    server.setWsOptions(wsOptions);
+    this.initializeGlobalHandlers(server);
+    return server;
+  }
+  extractWsOptions(options) {
+    if (!options) {
+      return {};
+    }
+    const wsOptions = { ...options };
+    delete wsOptions.messageParser;
+    return wsOptions;
+  }
+  async close(server) {
+    await server.close();
+  }
+  bindClientConnect(server, callback) {
+    this.onOpenHandler = callback;
+  }
+  bindClientDisconnect(client, callback) {
+    const existingHandler = client.data.onDisconnect;
+    client.data.onDisconnect = (ws) => {
+      existingHandler?.(ws);
+      callback(client);
+    };
+  }
+  bindMessageHandlers(client, handlers, transform) {
+    const handlerMap = this.buildHandlerMap(handlers);
+    const message$ = new Subject;
+    let isActive = true;
+    const existingOnMessage = client.data.onMessageInternal;
+    client.data.onMessageInternal = (data) => {
+      existingOnMessage?.(data);
+      if (isActive) {
+        message$.next(data);
+      }
+    };
+    const subscription = message$.pipe(mergeMap((data) => this.processMessage(data, handlerMap, transform))).subscribe({
+      next: (response) => {
+        this.sendResponse(client, response, isActive);
+      },
+      error: (err) => {
+        this.logger.error("Message processing error", err instanceof Error ? err.stack : err);
+      }
+    });
+    const existingOnClose = client.data.onCloseInternal;
+    client.data.onCloseInternal = () => {
+      existingOnClose?.();
+      isActive = false;
+      this.cleanupClient(message$, subscription);
+    };
+  }
+  initializeGlobalHandlers(server) {
+    if (this.globalHandlersInitialized) {
+      return;
+    }
+    this.globalHandlersInitialized = true;
+    server.registerWsOpenHandler((ws) => {
+      this.onOpenHandler?.(ws);
+    });
+    server.registerWsMessageHandler(() => {});
+    server.registerWsCloseHandler(() => {});
+  }
+  buildHandlerMap(handlers) {
+    const map = new Map;
+    for (const handler of handlers) {
+      map.set(handler.message, handler);
+    }
+    return map;
+  }
+  processMessage(data, handlerMap, transform) {
+    try {
+      const parsed = this.messageParser(data);
+      if (typeof parsed.event !== "string") {
+        return EMPTY;
+      }
+      const handler = handlerMap.get(parsed.event);
+      if (!handler) {
+        return EMPTY;
+      }
+      const result = handler.callback(parsed.data, parsed.event);
+      return transform(result).pipe(mergeMap((value) => isNil(value) ? EMPTY : [value]));
+    } catch (error) {
+      this.logger.warn("Failed to parse WebSocket message", error instanceof Error ? error.message : String(error));
+      return EMPTY;
+    }
+  }
+  sendResponse(client, response, isActive) {
+    if (!isActive || client.readyState !== WS_READY_STATE_OPEN) {
+      return;
+    }
+    if (response instanceof ArrayBuffer) {
+      client.send(response);
+      return;
+    }
+    if (ArrayBuffer.isView(response)) {
+      client.send(response.buffer);
+      return;
+    }
+    client.send(JSON.stringify(response));
+  }
+  cleanupClient(message$, subscription) {
+    message$.complete();
+    subscription.unsubscribe();
+  }
+}
 export {
+  BunWsAdapter,
   BunResponse,
   BunRequest,
+  BunPreflightHttpServer,
   BunFileInterceptor,
   BunAdapter
 };
 
-//# debugId=E15070B5DB09928264756E2164756E21
+//# debugId=1BD5D75380392B3E64756E2164756E21
 //# sourceMappingURL=index.js.map