@krisanalfa/bunest-adapter 0.1.0 → 0.4.0

package/dist/index.js

@@ -16,11 +16,49 @@ var __legacyMetadataTS = (k, v) => {
 
 // lib/bun.adapter.ts
 import {
-  Logger
+  Logger as Logger2
 } from "@nestjs/common";
 var {randomUUIDv7 } = globalThis.Bun;
 import { AbstractHttpAdapter } from "@nestjs/core";
 
+// lib/bun.preflight-http-server.ts
+class BunPreflightHttpServer {
+  serverInstance;
+  constructor(serverInstance) {
+    this.serverInstance = serverInstance;
+  }
+  on(event, callback) {}
+  once() {}
+  removeListener() {}
+  async stop(force) {
+    await this.serverInstance.stop(force);
+  }
+  address() {
+    return this.serverInstance.address();
+  }
+  setWsOptions(options) {
+    this.serverInstance.setWsOptions(options);
+  }
+  registerWsOpenHandler(handler) {
+    this.serverInstance.registerWsOpenHandler(handler);
+  }
+  registerWsMessageHandler(handler) {
+    this.serverInstance.registerWsMessageHandler(handler);
+  }
+  registerWsCloseHandler(handler) {
+    this.serverInstance.registerWsCloseHandler(handler);
+  }
+  getBunServer() {
+    return this.serverInstance.getBunServer();
+  }
+  async close() {
+    await this.serverInstance.close();
+  }
+}
+
+// lib/bun.server-instance.ts
+import { Logger } from "@nestjs/common";
+
 // lib/bun.body-parser.middleware.ts
 var GET_CODE = 71;
 var HEAD_CODE = 72;
@@ -179,6 +217,7 @@ class BunCorsMiddleware {
 }
 
 // lib/bun.middleware-engine.ts
+var {peek } = globalThis.Bun;
 var EMPTY_HANDLERS = new Array(0);
 var noop = () => {};
 
@@ -258,6 +297,17 @@ class BunMiddlewareEngine {
     const keyPathLen = keyPath.length;
     return path === keyPath || pathLen > keyPathLen && path.charCodeAt(keyPathLen) === 47 && path.startsWith(keyPath);
   }
+  async executeHandler(handler, req, res, next) {
+    if (!handler)
+      return;
+    const result = handler(req, res, next);
+    if (result instanceof Promise) {
+      const peeked = peek(result);
+      if (peeked !== result)
+        return;
+      await result;
+    }
+  }
   async run(options) {
     try {
       const middlewares = this.getMiddlewareChain(options.method, options.path);
@@ -333,25 +383,18 @@ class BunMiddlewareEngine {
       if (err)
         throw err;
       if (index < chainLength) {
-        const handler = chain[index++];
-        const result = handler(req, res, next);
-        if (result instanceof Promise)
-          await result;
+        await this.executeHandler(chain[index++], req, res, next);
         return;
       }
       if (index === chainLength) {
         index++;
         if (!res.isEnded()) {
-          const result = requestHandler(req, res, next);
-          if (result instanceof Promise)
-            await result;
+          await this.executeHandler(requestHandler, req, res, next);
         }
         return;
       }
-      if (index > chainLength && !res.isEnded()) {
-        const result = this.notFoundHandler?.(req, res, noop);
-        if (result instanceof Promise)
-          await result;
+      if (!res.isEnded()) {
+        await this.executeHandler(this.notFoundHandler ?? undefined, req, res, () => Promise.resolve());
       }
     };
     await next();
@@ -359,8 +402,11 @@ class BunMiddlewareEngine {
   async handleError(error, req, res) {
     if (this.errorHandler !== null) {
       const result = this.errorHandler(error, req, res, noop);
-      if (result instanceof Promise)
-        await result;
+      if (result instanceof Promise) {
+        const peeked = peek(result);
+        if (peeked === result)
+          await result;
+      }
       return res;
     }
     throw error;
@@ -397,7 +443,10 @@ class BunRequest {
   }
   get socket() {
     return {
-      encrypted: this._parsedUrl.protocol === "https:"
+      encrypted: this._parsedUrl.protocol === "https:",
+      setKeepAlive: () => {},
+      setNoDelay: () => {},
+      setTimeout: () => {}
     };
   }
   get url() {
@@ -492,6 +541,18 @@ class BunRequest {
     cloned._settings = this._settings;
     return cloned;
   }
+  on(event, listener) {
+    return this;
+  }
+  once(event, listener) {
+    return this;
+  }
+  off(event, listener) {
+    return this;
+  }
+  emit(event, ...args) {
+    return true;
+  }
 }
 
 // lib/bun.response.ts
@@ -504,11 +565,14 @@ class BunResponse {
   response;
   cookieMap = new CookieMap;
   static textDecoder = new TextDecoder;
+  writable = true;
   headers = null;
   statusCode = 200;
   ended = false;
   cookieHeaders = null;
   chunks = [];
+  streamWriter = null;
+  textEncoder = new TextEncoder;
   constructor() {
     this.response = new Promise((r) => {
       this.resolve = r;
@@ -542,6 +606,16 @@ class BunResponse {
     if (this.ended)
       return;
     this.ended = true;
+    if (this.streamWriter) {
+      try {
+        if (body) {
+          const bytes = typeof body === "string" ? this.textEncoder.encode(body) : body instanceof Uint8Array ? body : this.textEncoder.encode(JSON.stringify(body));
+          this.streamWriter.write(bytes);
+        }
+        this.streamWriter.close();
+      } catch {}
+      return;
+    }
     this.applyCookieHeaders();
     if (this.chunks.length > 0) {
       const finalBody = this.combineChunks(body);
@@ -551,14 +625,19 @@ class BunResponse {
     this.sendResponse(body);
   }
   applyCookieHeaders() {
+    if (this.cookieMap.size === 0)
+      return;
     this.cookieHeaders ??= this.cookieMap.toSetCookieHeaders();
-    if (this.cookieHeaders.length > 0) {
-      this.setHeader("set-cookie", this.cookieHeaders.join(`
+    this.setHeader("set-cookie", this.cookieHeaders.join(`
 `));
-    }
   }
   sendResponse(body) {
     if (body !== null && typeof body === "object") {
+      const ctor = body.constructor;
+      if (ctor === Object || ctor === Array) {
+        this.resolve(this.buildJsonResponse(body));
+        return;
+      }
       if (body instanceof Uint8Array || body instanceof Blob) {
         this.resolve(this.createResponse(body));
         return;
@@ -642,10 +721,30 @@ class BunResponse {
   once(event, listener) {
     return this;
   }
+  emit(event, ...args) {
+    return true;
+  }
+  get writableEnded() {
+    return this.ended;
+  }
   write(chunk) {
     if (this.ended) {
       return false;
     }
+    const contentType = this.headers?.get("content-type") ?? "";
+    const isStreamingResponse = contentType.includes("text/event-stream") || contentType.includes("application/octet-stream");
+    if (isStreamingResponse && !this.streamWriter) {
+      this.initializeStreamingMode();
+    }
+    if (this.streamWriter) {
+      try {
+        const bytes = typeof chunk === "string" ? this.textEncoder.encode(chunk) : chunk instanceof Uint8Array ? chunk : chunk instanceof Buffer ? new Uint8Array(chunk) : this.textEncoder.encode(JSON.stringify(chunk));
+        this.streamWriter.write(bytes);
+        return true;
+      } catch {
+        return false;
+      }
+    }
     if (typeof chunk === "string") {
       this.chunks.push(chunk);
       return true;
@@ -668,6 +767,12 @@ class BunResponse {
     }
     return true;
   }
+  initializeStreamingMode() {
+    const { readable, writable } = new TransformStream;
+    this.streamWriter = writable.getWriter();
+    this.applyCookieHeaders();
+    this.resolve(this.createResponse(readable));
+  }
   getHeader(name) {
     return this.headers?.get(name.toLowerCase()) ?? null;
   }
@@ -711,9 +816,7 @@ class BunResponse {
     if (headers === null || headers.size === 0) {
       return Response.json(body, { status: this.statusCode });
     }
-    if (!headers.has("content-type")) {
-      headers.set("content-type", JSON_CONTENT_TYPE);
-    }
+    headers.set("content-type", JSON_CONTENT_TYPE);
     return Response.json(body, {
       status: this.statusCode,
       headers: Object.fromEntries(headers)
@@ -733,13 +836,9 @@ class BunResponse {
 
 // lib/bun.version-filter.middleware.ts
 import { VERSION_NEUTRAL, VersioningType } from "@nestjs/common";
-async function executeHandler(handler, req, res, next) {
-  const result = handler(req, res, next);
-  return result instanceof Promise ? await result : result;
-}
-function callNext(next) {
-  return next();
-}
+var CUSTOM_VERSIONING_PHASE_KEY = "_cvp";
+var CUSTOM_VERSIONING_CANDIDATES_KEY = "_cvc";
+var CUSTOM_VERSIONING_BEST_CANDIDATE_KEY = "_cvb";
 
 class BunVersionFilterMiddleware {
   static createFilter(handler, version, versioningOptions) {
@@ -767,24 +866,26 @@ class BunVersionFilterMiddleware {
   static computeAcceptsNeutral(version) {
     return version === VERSION_NEUTRAL || Array.isArray(version) && version.includes(VERSION_NEUTRAL);
   }
-  static getHeader(req, name) {
-    return req.headers.get(name) ?? undefined;
-  }
   static createCustomVersionFilter(handler, version, options) {
     const isVersionArray = Array.isArray(version);
     const versionSet = isVersionArray ? new Set(version) : null;
     const singleVersion = isVersionArray ? null : version;
-    return async (req, res, next) => {
+    return (req, res, next) => {
       const extracted = options.extractor(req);
-      const reqMeta = req;
-      reqMeta._customVersioningPhase ??= "discovery";
-      reqMeta._customVersioningCandidates ??= new Map;
-      const isDiscovery = reqMeta._customVersioningPhase === "discovery";
-      const extractedIsArray = Array.isArray(extracted);
-      const extractedVersions = extractedIsArray ? extracted : [extracted];
+      let phase = req.get(CUSTOM_VERSIONING_PHASE_KEY);
+      if (phase === undefined) {
+        phase = 0;
+        req.set(CUSTOM_VERSIONING_PHASE_KEY, phase);
+      }
+      let candidates = req.get(CUSTOM_VERSIONING_CANDIDATES_KEY);
+      if (!candidates) {
+        candidates = new Map;
+        req.set(CUSTOM_VERSIONING_CANDIDATES_KEY, candidates);
+      }
+      const extractedVersions = Array.isArray(extracted) ? extracted : [extracted];
       let match;
       let matchIndex = -1;
-      for (let i = 0;i < extractedVersions.length; i++) {
+      for (let i = 0, len = extractedVersions.length;i < len; i++) {
         const extractedVersion = extractedVersions[i];
         if (versionSet ? versionSet.has(extractedVersion) : extractedVersion === singleVersion) {
           match = extractedVersion;
@@ -793,44 +894,44 @@ class BunVersionFilterMiddleware {
         }
       }
       if (match) {
-        if (isDiscovery) {
-          reqMeta._customVersioningCandidates.set(match, {
-            priority: matchIndex,
-            execute: () => handler(req, res, next)
-          });
-          return callNext(next);
+        if (phase === 0) {
+          candidates.set(match, matchIndex);
+          next();
+          return;
         }
-        if (reqMeta._customVersioningBestCandidate === match) {
-          return executeHandler(handler, req, res, next);
+        if (req.get(CUSTOM_VERSIONING_BEST_CANDIDATE_KEY) === match) {
+          return handler(req, res, next);
         }
       }
-      return callNext(next);
+      next();
     };
   }
   static createMediaTypeVersionFilter(handler, version, options) {
     const acceptsNeutral = this.computeAcceptsNeutral(version);
     const versionMatches = this.createVersionMatcher(version);
-    const keyLength = options.key.length;
-    return async (req, res, next) => {
-      const acceptHeader = this.getHeader(req, "accept");
+    const key = options.key;
+    const keyLength = key.length;
+    return (req, res, next) => {
+      const acceptHeader = req.headers.get("accept");
       if (acceptHeader) {
         const semiIndex = acceptHeader.indexOf(";");
         if (semiIndex !== -1) {
           const versionPart = acceptHeader.substring(semiIndex + 1).trim();
-          const keyIndex = versionPart.indexOf(options.key);
+          const keyIndex = versionPart.indexOf(key);
           if (keyIndex !== -1) {
             const headerVersion = versionPart.substring(keyIndex + keyLength);
             if (versionMatches(headerVersion)) {
-              return executeHandler(handler, req, res, next);
+              return handler(req, res, next);
             }
-            return callNext(next);
+            next();
+            return;
           }
         }
       }
       if (acceptsNeutral) {
-        return executeHandler(handler, req, res, next);
+        return handler(req, res, next);
       }
-      return callNext(next);
+      next();
     };
   }
   static createHeaderVersionFilter(handler, version, options) {
@@ -840,21 +941,25 @@ class BunVersionFilterMiddleware {
     const hasNeutralDefault = defaultVersion === VERSION_NEUTRAL;
     const resolvedDefault = this.resolveDefaultVersion(version, defaultVersion);
     const headerName = options.header;
-    return async (req, res, next) => {
-      let headerVersion = this.getHeader(req, headerName)?.trim();
-      if (headerVersion === "")
-        headerVersion = undefined;
+    return (req, res, next) => {
+      let headerVersion = req.headers.get(headerName) ?? undefined;
+      if (headerVersion) {
+        headerVersion = headerVersion.trim();
+        if (headerVersion === "")
+          headerVersion = undefined;
+      }
       headerVersion ??= resolvedDefault;
       if (!headerVersion) {
         if ((hasNeutralDefault || !defaultVersion) && acceptsNeutral) {
-          return executeHandler(handler, req, res, next);
+          return handler(req, res, next);
         }
-        return callNext(next);
+        next();
+        return;
       }
       if (versionMatches(headerVersion)) {
-        return executeHandler(handler, req, res, next);
+        return handler(req, res, next);
       }
-      return callNext(next);
+      next();
     };
   }
   static resolveDefaultVersion(handlerVersion, defaultVersion) {
@@ -871,12 +976,15 @@ class BunVersionFilterMiddleware {
     return;
   }
   static selectBestCustomVersionCandidate(req) {
-    const { _customVersioningPhase: phase, _customVersioningCandidates: candidates } = req;
-    if (phase !== "discovery" || !candidates?.size)
+    const phase = req.get(CUSTOM_VERSIONING_PHASE_KEY);
+    if (phase !== 0)
+      return null;
+    const candidates = req.get(CUSTOM_VERSIONING_CANDIDATES_KEY);
+    if (!candidates?.size)
       return null;
     let bestVersion = null;
     let bestPriority = Infinity;
-    for (const [version, { priority }] of candidates) {
+    for (const [version, priority] of candidates) {
       if (priority < bestPriority) {
         bestPriority = priority;
         bestVersion = version;
@@ -885,17 +993,19 @@ class BunVersionFilterMiddleware {
     return bestVersion;
   }
   static setCustomVersioningExecutionPhase(req, bestVersion) {
-    const reqMeta = req;
-    reqMeta._customVersioningPhase = "execution";
-    reqMeta._customVersioningBestCandidate = bestVersion;
+    req.set(CUSTOM_VERSIONING_PHASE_KEY, 1);
+    req.set(CUSTOM_VERSIONING_BEST_CANDIDATE_KEY, bestVersion);
   }
   static hasCustomVersioningCandidates(req) {
-    const { _customVersioningPhase: phase, _customVersioningCandidates: candidates } = req;
-    return phase === "discovery" && !!candidates?.size;
+    const phase = req.get(CUSTOM_VERSIONING_PHASE_KEY);
+    if (phase !== 0)
+      return false;
+    const candidates = req.get(CUSTOM_VERSIONING_CANDIDATES_KEY);
+    return !!candidates?.size;
   }
 }
 
-// lib/bun.adapter.ts
+// lib/bun.server-instance.ts
 var REQUEST_METHOD_STRINGS = [
   "GET",
   "POST",
@@ -915,9 +1025,9 @@ var REQUEST_METHOD_STRINGS = [
   "UNLOCK"
 ];
 
-class BunAdapter extends AbstractHttpAdapter {
+class BunServerInstance {
   bunServeOptions;
-  logger = new Logger("BunAdapter", { timestamp: true });
+  logger = new Logger("BunServerInstance", { timestamp: true });
   middlewareEngine = new BunMiddlewareEngine;
   useVersioning = false;
   routes = Object.create(null);
@@ -926,175 +1036,176 @@ class BunAdapter extends AbstractHttpAdapter {
     res.setStatus(404);
     res.end({ message: "Not Found" });
   };
-  constructor(bunServeOptions = {
-    development: false,
-    id: randomUUIDv7()
-  }) {
-    super();
+  wsHandlers = {
+    onOpen: undefined,
+    onMessage: undefined,
+    onClose: undefined
+  };
+  wsMiddlewareEngine = new BunMiddlewareEngine;
+  wsOptions = {};
+  useWs = false;
+  useWsCors = false;
+  httpServer = null;
+  constructor(bunServeOptions) {
     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(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.");
-  }
-  useStaticAssets(...args) {
-    throw new Error("Not supported.");
-  }
-  setViewEngine(engine) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
-  render(response, view, options) {
-    throw new Error("Not supported.");
-  }
-  async close() {
-    await this.httpServer.stop();
+  listen(port, hostnameOrCallback, maybeCallback) {
+    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 wsHandlers = this.wsHandlers;
+    const bunServeOptions = this.bunServeOptions;
+    this.setupWebSocketIfNeeded(wsHandlers, bunServeOptions);
+    const fetch = async (request, server) => {
+      const bunRequest = new BunRequest(request);
+      if (await this.upgradeWebSocket(request, bunRequest, server)) {
+        return;
+      }
+      const routeHandler = middlewareEngine.findRouteHandler(bunRequest.method, bunRequest.pathname) ?? notFoundHandler;
+      const bunResponse = await middlewareEngine.run({
+        req: bunRequest,
+        res: new BunResponse,
+        method: bunRequest.method,
+        path: bunRequest.pathname,
+        requestHandler: routeHandler
+      });
+      return bunResponse.res();
+    };
+    this.httpServer = this.createServer(port, hostname, bunServeOptions, fetch);
+    callback?.();
+    return this.httpServer;
   }
-  initHttpServer(options) {
-    this.setHttpServer({
-      once: () => {},
-      address: () => ({ address: "0.0.0.0", port: 0 }),
-      removeListener: () => {},
-      stop: () => {}
-    });
-    if (options.httpsOptions) {
-      this.bunServeOptions.tls = {
-        key: options.httpsOptions.key,
-        cert: options.httpsOptions.cert,
-        passphrase: options.httpsOptions.passphrase,
-        ca: options.httpsOptions.ca,
-        ciphers: options.httpsOptions.ciphers,
-        secureOptions: options.httpsOptions.secureOptions,
-        rejectUnauthorized: options.httpsOptions.rejectUnauthorized,
-        requestCert: options.httpsOptions.requestCert
+  async stop(force) {
+    const server = this.httpServer;
+    if (!server) {
+      return;
+    }
+    await server.stop(force);
+  }
+  address() {
+    const server = this.httpServer;
+    if (!server) {
+      const hostname = this.bunServeOptions.hostname;
+      const port = this.bunServeOptions.port;
+      return {
+        address: typeof hostname === "string" ? hostname : "127.0.0.1",
+        port: typeof port === "number" ? port : 3000
       };
     }
+    return {
+      address: server.hostname ?? "127.0.0.1",
+      port: server.port ?? 3000
+    };
   }
-  getRequestHostname(request) {
-    return request.hostname;
+  setWsOptions(options) {
+    this.wsOptions = options;
   }
-  getRequestMethod(request) {
-    return request.method;
+  registerWsOpenHandler(handler) {
+    this.wsHandlers.onOpen = handler;
   }
-  getRequestUrl(request) {
-    return request.pathname;
+  registerWsMessageHandler(handler) {
+    this.wsHandlers.onMessage = handler;
   }
-  status(response, statusCode) {
-    response.setStatus(statusCode);
+  registerWsCloseHandler(handler) {
+    this.wsHandlers.onClose = handler;
   }
-  reply(response, body, statusCode) {
-    if (statusCode) {
-      response.setStatus(statusCode);
-    }
-    response.end(body);
+  getBunServer() {
+    return this.httpServer;
   }
-  end(response, message) {
-    response.end(message);
+  async close() {
+    await this.stop(true);
   }
-  redirect(response, statusCode, url) {
-    response.redirect(url, statusCode);
+  getMiddlewareEngine() {
+    return this.middlewareEngine;
   }
-  setErrorHandler(handler, prefix) {
-    this.middlewareEngine.useErrorHandler(handler);
-  }
-  setNotFoundHandler(handler, prefix) {
+  setNotFoundHandler(handler) {
     this.notFoundHandler = handler;
-    this.middlewareEngine.useNotFoundHandler(handler);
   }
-  isHeadersSent(response) {
-    return response.isEnded();
-  }
-  getHeader(response, name) {
-    return response.getHeader(name);
-  }
-  setHeader(response, name, value) {
-    response.setHeader(name, value);
-  }
-  appendHeader(response, name, value) {
-    response.appendHeader(name, value);
+  setUseVersioning(value) {
+    this.useVersioning = value;
   }
   registerParserMiddleware(prefix, rawBody) {
     this.logger.log(`Registering Body Parser Middleware with prefix: ${prefix || "/"} and rawBody: ${rawBody ? "true" : "false"}`);
     const bodyParser = new BunBodyParserMiddleware({ prefix, rawBody });
     this.middlewareEngine.useGlobal(bodyParser.run.bind(bodyParser));
   }
-  enableCors(options, prefix) {
-    this.logger.log(`Enabling CORS Middleware with prefix: ${prefix ?? "/"}`);
-    const corsMiddleware = new BunCorsMiddleware({ corsOptions: options, prefix });
-    this.middlewareEngine.useGlobal(corsMiddleware.run.bind(corsMiddleware));
-  }
   createMiddlewareFactory(requestMethod) {
     return (path, callback) => {
       const methodName = this.mapRequestMethodToString(requestMethod);
@@ -1106,73 +1217,121 @@ class BunAdapter extends AbstractHttpAdapter {
       this.middlewareEngine.useRoute(methodName, normalizedPath, callback);
     };
   }
-  getType() {
-    return "bun";
+  enableCors(corsOptions, prefix) {
+    this.logger.log(`Enabling CORS Middleware with prefix: ${prefix ?? "/"}`);
+    const corsMiddleware = new BunCorsMiddleware({ corsOptions, prefix });
+    this.middlewareEngine.useGlobal(corsMiddleware.run.bind(corsMiddleware));
   }
-  applyVersionFilter(handler, version, versioningOptions) {
-    this.logger.log(`Applying Version Filter Middleware for version: ${JSON.stringify(version)}`);
-    this.useVersioning = true;
-    return BunVersionFilterMiddleware.createFilter(handler, version, versioningOptions);
+  static isNumericPort(value) {
+    return typeof value === "number" || !isNaN(Number(value));
   }
-  listen(port, hostnameOrCallback, maybeCallback) {
-    const hostname = typeof hostnameOrCallback === "string" ? hostnameOrCallback : "localhost";
-    const callback = typeof hostnameOrCallback === "function" ? hostnameOrCallback : maybeCallback;
-    const middlewareEngine = this.middlewareEngine;
-    const notFoundHandler = this.notFoundHandler;
-    const fetch = async (request) => {
-      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: routeHandler
-      });
-      return bunResponse.res();
-    };
-    const omit = (obj, ...keys) => {
-      const result = { ...obj };
-      for (const key of keys) {
-        Reflect.deleteProperty(result, key);
+  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 provideCorsHeaders(bunRequest) {
+    const bunResponse = new BunResponse;
+    await this.wsMiddlewareEngine.run({
+      req: bunRequest,
+      res: bunResponse,
+      method: bunRequest.method,
+      path: bunRequest.pathname,
+      requestHandler: (req, res) => {
+        res.end();
+      }
+    });
+    const response = await bunResponse.res();
+    return response.headers;
+  }
+  async upgradeWebSocket(request, bunRequest, server) {
+    if (!this.useWs || !this.isWebSocketUpgradeRequest(request)) {
+      return false;
+    }
+    const headers = this.useWsCors ? await this.provideCorsHeaders(bunRequest) : undefined;
+    return server.upgrade(request, {
+      headers,
+      data: await this.wsOptions.clientDataFactory?.(bunRequest) ?? {}
+    });
+  }
+  setupWebSocketIfNeeded(wsHandlers, bunServeOptions) {
+    const useWs = !!wsHandlers.onOpen && !!wsHandlers.onMessage && !!wsHandlers.onClose;
+    if (!useWs)
+      return;
+    this.useWs = true;
+    const getServer = () => this.getBunServer();
+    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);
       }
-      return result;
     };
-    const server = typeof port === "number" || !isNaN(Number(port)) ? Bun.serve({
-      ...this.bunServeOptions,
+    const useWsCors = typeof this.wsOptions.cors !== "undefined";
+    if (!useWsCors)
+      return;
+    this.useWsCors = true;
+    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 BunServerInstance.isNumericPort(port) ? Bun.serve({
+      ...bunServeOptions,
       hostname,
       port,
       routes: this.routes,
       fetch
     }) : Bun.serve({
-      ...omit(this.bunServeOptions, "idleTimeout"),
+      ...BunServerInstance.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) => {
       const bunRequest = new BunRequest(request);
-      const bunResponse = new BunResponse;
-      await this.middlewareEngine.run({
+      if (path === "/" && await this.upgradeWebSocket(request, bunRequest, server)) {
+        return;
+      }
+      const bunResponse = await this.middlewareEngine.run({
         req: bunRequest,
-        res: bunResponse,
+        res: new BunResponse,
         method,
         path,
         requestHandler
@@ -1228,6 +1387,114 @@ class BunAdapter extends AbstractHttpAdapter {
     return { path, handler };
   }
 }
+
+// lib/bun.adapter.ts
+class BunAdapter extends AbstractHttpAdapter {
+  bunServeOptions;
+  logger = new Logger2("BunAdapter", { timestamp: true });
+  constructor(bunServeOptions = {
+    development: false,
+    id: randomUUIDv7()
+  }) {
+    super(new BunServerInstance(bunServeOptions));
+    this.bunServeOptions = bunServeOptions;
+  }
+  useStaticAssets(...args) {
+    throw new Error("Not supported.");
+  }
+  setViewEngine(engine) {
+    throw new Error("Not supported.");
+  }
+  render(response, view, options) {
+    throw new Error("Not supported.");
+  }
+  async close() {
+    await this.instance.close();
+  }
+  initHttpServer(options) {
+    this.configureTls(options);
+    const preflightServer = new BunPreflightHttpServer(this.instance);
+    this.setHttpServer(preflightServer);
+    return preflightServer;
+  }
+  getRequestHostname(request) {
+    return request.hostname;
+  }
+  getRequestMethod(request) {
+    return request.method;
+  }
+  getRequestUrl(request) {
+    return request.pathname;
+  }
+  status(response, statusCode) {
+    response.setStatus(statusCode);
+  }
+  reply(response, body, statusCode) {
+    if (statusCode) {
+      response.setStatus(statusCode);
+    }
+    response.end(body);
+  }
+  end(response, message) {
+    response.end(message);
+  }
+  redirect(response, statusCode, url) {
+    response.redirect(url, statusCode);
+  }
+  setErrorHandler(handler, prefix) {
+    this.instance.getMiddlewareEngine().useErrorHandler(handler);
+  }
+  setNotFoundHandler(handler, prefix) {
+    this.instance.setNotFoundHandler(handler);
+    this.instance.getMiddlewareEngine().useNotFoundHandler(handler);
+  }
+  isHeadersSent(response) {
+    return response.isEnded();
+  }
+  getHeader(response, name) {
+    return response.getHeader(name);
+  }
+  setHeader(response, name, value) {
+    response.setHeader(name, value);
+  }
+  appendHeader(response, name, value) {
+    response.appendHeader(name, value);
+  }
+  registerParserMiddleware(prefix, rawBody) {
+    this.instance.registerParserMiddleware(prefix, rawBody);
+  }
+  enableCors(options, prefix) {
+    this.instance.enableCors(options, prefix);
+  }
+  createMiddlewareFactory(requestMethod) {
+    return this.instance.createMiddlewareFactory(requestMethod);
+  }
+  getType() {
+    return "bun";
+  }
+  applyVersionFilter(handler, version, versioningOptions) {
+    this.logger.log(`Applying Version Filter Middleware for version: ${JSON.stringify(version)}`);
+    this.instance.setUseVersioning(true);
+    return BunVersionFilterMiddleware.createFilter(handler, version, versioningOptions);
+  }
+  listen(port, hostnameOrCallback, maybeCallback) {
+    this.setHttpServer(this.instance.listen(port, hostnameOrCallback, maybeCallback));
+  }
+  configureTls(options) {
+    if (options.httpsOptions) {
+      this.bunServeOptions.tls = {
+        key: options.httpsOptions.key,
+        cert: options.httpsOptions.cert,
+        passphrase: options.httpsOptions.passphrase,
+        ca: options.httpsOptions.ca,
+        ciphers: options.httpsOptions.ciphers,
+        secureOptions: options.httpsOptions.secureOptions,
+        rejectUnauthorized: options.httpsOptions.rejectUnauthorized,
+        requestCert: options.httpsOptions.requestCert
+      };
+    }
+  }
+}
 // lib/bun.file.interceptor.ts
 import { Injectable } from "@nestjs/common";
 import { basename, join } from "path";
@@ -1263,12 +1530,160 @@ 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 Logger3 } 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 Logger3(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,
+  BunServerInstance,
   BunResponse,
   BunRequest,
+  BunPreflightHttpServer,
   BunFileInterceptor,
   BunAdapter
 };
 
-//# debugId=43ACC6E0AFE16AD764756E2164756E21
+//# debugId=813882D1C572F1EC64756E2164756E21
 //# sourceMappingURL=index.js.map