@krisanalfa/bunest-adapter 0.3.0 → 0.5.0

package/dist/index.js

@@ -15,12 +15,52 @@ var __legacyMetadataTS = (k, v) => {
 };
 
 // lib/bun.adapter.ts
-var {randomUUIDv7 } = globalThis.Bun;
 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";
+import { join } from "path";
+import { readdir } from "fs/promises";
+
 // lib/bun.body-parser.middleware.ts
 var GET_CODE = 71;
 var HEAD_CODE = 72;
@@ -179,6 +219,7 @@ class BunCorsMiddleware {
 }
 
 // lib/bun.middleware-engine.ts
+var {peek } = globalThis.Bun;
 var EMPTY_HANDLERS = new Array(0);
 var noop = () => {};
 
@@ -258,6 +299,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 +385,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,67 +404,17 @@ 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;
   }
 }
 
-// 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));
@@ -436,25 +431,34 @@ class BunRequest {
   _file = null;
   _files = null;
   _settings = null;
-  _url;
+  _connection = null;
+  _socket = null;
+  _url = null;
   _parsedUrl;
   method;
   params;
   constructor(nativeRequest) {
     this.nativeRequest = nativeRequest;
-    this._url = nativeRequest.url;
-    this._parsedUrl = new URL(this._url);
+    this._parsedUrl = new URL(nativeRequest.url);
     this._nativeHeaders = nativeRequest.headers;
     this.method = nativeRequest.method;
     this.params = nativeRequest.params;
   }
+  get connection() {
+    return this._connection ??= {
+      encrypted: this._parsedUrl.protocol === "https:" || this.nativeRequest.url.startsWith("https://")
+    };
+  }
   get socket() {
-    return {
-      encrypted: this._parsedUrl.protocol === "https:"
+    return this._socket ??= {
+      encrypted: this._parsedUrl.protocol === "https:" || this.nativeRequest.url.startsWith("https://"),
+      setKeepAlive: () => {},
+      setNoDelay: () => {},
+      setTimeout: () => {}
     };
   }
   get url() {
-    return this._parsedUrl.pathname + this._parsedUrl.search;
+    return this._url ??= this._parsedUrl.pathname + this._parsedUrl.search;
   }
   original() {
     return this.nativeRequest;
@@ -535,16 +539,32 @@ class BunRequest {
   }
   clone() {
     const cloned = new BunRequest(this.nativeRequest.clone());
+    cloned._hostname = this._hostname;
     cloned._pathname = this._pathname;
+    cloned._query = this._query;
     cloned._body = this._body;
     cloned._rawBody = this._rawBody;
     cloned._file = this._file;
     cloned._files = this._files;
     cloned._headers = this._headers;
-    cloned._query = this._query;
     cloned._settings = this._settings;
+    cloned._connection = this._connection;
+    cloned._socket = this._socket;
+    cloned._url = this._url;
     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
@@ -557,11 +577,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;
@@ -595,6 +618,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);
@@ -604,14 +637,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;
@@ -695,10 +733,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;
@@ -721,6 +779,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;
   }
@@ -745,6 +809,9 @@ class BunResponse {
   isEnded() {
     return this.ended;
   }
+  _implicitHeader() {
+    this.writeHead(this.statusCode, {});
+  }
   buildStreamableResponse(body) {
     const streamHeaders = body.getHeaders();
     const headers = this.headersMap;
@@ -764,9 +831,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)
@@ -786,13 +851,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) {
@@ -820,24 +881,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;
@@ -846,44 +909,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) {
@@ -893,21 +956,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) {
@@ -924,12 +991,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;
@@ -938,17 +1008,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",
@@ -968,9 +1040,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);
@@ -988,35 +1060,27 @@ class BunAdapter extends AbstractHttpAdapter {
   wsOptions = {};
   useWs = false;
   useWsCors = false;
-  wsCorsHeaders;
-  constructor(bunServeOptions = {
-    development: false,
-    id: randomUUIDv7()
-  }) {
-    super();
+  staticAssetsOptions = null;
+  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(middleware) {
-    this.middlewareEngine.useGlobal(middleware);
+  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);
+    }
   }
   createHttpMethodHandler(httpMethod) {
     return (pathOrHandler, maybeHandler) => {
@@ -1077,95 +1141,88 @@ class BunAdapter extends AbstractHttpAdapter {
   search(pathOrHandler, maybeHandler) {
     this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
-  useStaticAssets(...args) {
-    throw new Error("Not supported.");
-  }
-  setViewEngine(engine) {
-    throw new Error("Not supported.");
-  }
-  render(response, view, options) {
-    throw new Error("Not supported.");
+  async 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;
+    await this.setupStaticAssetsIfNeeded();
+    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;
   }
-  async close() {
-    await this.httpServer.stop();
+  async stop(force) {
+    const server = this.httpServer;
+    if (!server) {
+      return;
+    }
+    await server.stop(force);
   }
-  initHttpServer(options) {
-    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,
-        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
+  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 preflightServer;
-  }
-  getRequestHostname(request) {
-    return request.hostname;
+    return {
+      address: server.hostname ?? "127.0.0.1",
+      port: server.port ?? 3000
+    };
   }
-  getRequestMethod(request) {
-    return request.method;
+  setWsOptions(options) {
+    this.wsOptions = options;
   }
-  getRequestUrl(request) {
-    return request.pathname;
+  registerWsOpenHandler(handler) {
+    this.wsHandlers.onOpen = handler;
   }
-  status(response, statusCode) {
-    response.setStatus(statusCode);
+  registerWsMessageHandler(handler) {
+    this.wsHandlers.onMessage = handler;
   }
-  reply(response, body, statusCode) {
-    if (statusCode) {
-      response.setStatus(statusCode);
-    }
-    response.end(body);
+  registerWsCloseHandler(handler) {
+    this.wsHandlers.onClose = handler;
   }
-  end(response, message) {
-    response.end(message);
+  getBunServer() {
+    return this.httpServer;
   }
-  redirect(response, statusCode, url) {
-    response.redirect(url, statusCode);
+  async close() {
+    await this.stop(true);
   }
-  setErrorHandler(handler, prefix) {
-    this.middlewareEngine.useErrorHandler(handler);
+  getMiddlewareEngine() {
+    return this.middlewareEngine;
   }
-  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);
@@ -1177,41 +1234,14 @@ class BunAdapter extends AbstractHttpAdapter {
       this.middlewareEngine.useRoute(methodName, normalizedPath, callback);
     };
   }
-  getType() {
-    return "bun";
-  }
-  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);
+  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));
   }
-  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, 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: routeHandler
-      });
-      return bunResponse.res();
-    };
-    const server = this.createServer(port, hostname, bunServeOptions, fetch);
-    callback?.();
-    this.setHttpServer(server);
+  useStaticAssets(path, options) {
+    this.logger.log(`Configuring static assets serving from path: ${path} with options: ${JSON.stringify(options)}`);
+    this.staticAssetsOptions = { path, options };
   }
   static isNumericPort(value) {
     return typeof value === "number" || !isNaN(Number(value));
@@ -1228,11 +1258,7 @@ class BunAdapter extends AbstractHttpAdapter {
     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);
+  async provideCorsHeaders(bunRequest) {
     const bunResponse = new BunResponse;
     await this.wsMiddlewareEngine.run({
       req: bunRequest,
@@ -1244,66 +1270,124 @@ class BunAdapter extends AbstractHttpAdapter {
       }
     });
     const response = await bunResponse.res();
-    this.wsCorsHeaders = response.headers;
-    return this.wsCorsHeaders;
+    return response.headers;
   }
-  async upgradeWebSocket(request, server) {
+  async upgradeWebSocket(request, bunRequest, 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);
+    const headers = this.useWsCors ? await this.provideCorsHeaders(bunRequest) : undefined;
     return server.upgrade(request, {
       headers,
-      data: this.wsOptions.clientDataFactory ? this.wsOptions.clientDataFactory(new BunRequest(request)) : {}
+      data: await this.wsOptions.clientDataFactory?.(bunRequest) ?? {}
     });
   }
+  async setupStaticAssetsIfNeeded() {
+    if (!this.staticAssetsOptions)
+      return;
+    const { path, options } = this.staticAssetsOptions;
+    const files = await readdir(path, { withFileTypes: true, recursive: true });
+    const flattenFiles = files.flat(Infinity);
+    if (flattenFiles.length === 0)
+      return;
+    const useStatic = options?.useStatic ?? false;
+    for (const file of flattenFiles) {
+      if (!file.isFile())
+        continue;
+      const relativePath = file.parentPath.replace(path, "");
+      const routePath = relativePath.startsWith("/") ? [relativePath, file.name].join("/") : `/${file.name}`;
+      if (useStatic) {
+        const bunFile = Bun.file(join(file.parentPath, file.name));
+        this.routes[routePath] = {
+          GET: new Response(await bunFile.bytes(), {
+            headers: {
+              "Content-Type": bunFile.type
+            }
+          })
+        };
+      } else {
+        this.delegateRouteHandler("GET", routePath, async (req, res) => {
+          const bunFile = Bun.file(join(file.parentPath, file.name));
+          if (!await bunFile.exists()) {
+            this.notFoundHandler(req, res);
+            return;
+          }
+          const ifModifiedSince = req.headers.get("if-modified-since");
+          if (ifModifiedSince) {
+            const lastModified = bunFile.lastModified;
+            if (new Date(ifModifiedSince).getTime() >= lastModified) {
+              res.setStatus(304);
+              res.end();
+              return;
+            }
+          }
+          const range = req.headers.get("range");
+          if (range) {
+            const fileSize = bunFile.size;
+            const match = /bytes=(\d*)-(\d*)/.exec(range);
+            if (match) {
+              const start = parseInt(match[1], 10) || 0;
+              const end = parseInt(match[2], 10) || fileSize - 1;
+              if (start >= 0 && end < fileSize && start <= end) {
+                res.setStatus(206);
+                res.setHeader("Content-Range", `bytes ${start.toString()}-${end.toString()}/${fileSize.toString()}`);
+                res.end(bunFile.slice(start, end + 1));
+                return;
+              } else {
+                res.setStatus(416);
+                res.setHeader("Content-Range", `bytes */${fileSize.toString()}`);
+                res.end();
+                return;
+              }
+            }
+          }
+          res.end(bunFile);
+        });
+      }
+    }
+  }
   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);
-        }
-      };
-    }
+    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);
+      }
+    };
     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));
-    }
+    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 BunAdapter.isNumericPort(port) ? Bun.serve({
+    return BunServerInstance.isNumericPort(port) ? Bun.serve({
       ...bunServeOptions,
       hostname,
       port,
       routes: this.routes,
       fetch
     }) : Bun.serve({
-      ...BunAdapter.omitKeys(bunServeOptions, "idleTimeout", "port", "hostname"),
+      ...BunServerInstance.omitKeys(bunServeOptions, "idleTimeout", "port", "hostname"),
       unix: port,
       routes: this.routes,
       fetch
@@ -1320,21 +1404,19 @@ class BunAdapter extends AbstractHttpAdapter {
     }
   }
   prepareRequestHandler(method, path, handler) {
-    if (!this.useVersioning) {
+    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)) {
+      const bunRequest = new BunRequest(request);
+      if (path === "/" && await this.upgradeWebSocket(request, bunRequest, server)) {
         return;
       }
-      const bunRequest = new BunRequest(request);
-      const bunResponse = new BunResponse;
-      await this.middlewareEngine.run({
+      const bunResponse = await this.middlewareEngine.run({
         req: bunRequest,
-        res: bunResponse,
+        res: new BunResponse,
         method,
         path,
         requestHandler
@@ -1390,9 +1472,119 @@ 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(path, options) {
+    this.instance.useStaticAssets(path, options);
+  }
+  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.instance.listen(port, hostnameOrCallback, maybeCallback).then((server) => {
+      this.setHttpServer(server);
+    });
+  }
+  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";
+import { basename, join as join2 } from "path";
 import { HttpAdapterHost } from "@nestjs/core";
 var {randomUUIDv7: randomUUIDv72 } = globalThis.Bun;
 import { tmpdir } from "os";
@@ -1402,7 +1594,7 @@ class BunFileInterceptor {
   constructor(adapter) {
     this.adapter = adapter;
     const httpAdapter = this.adapter.httpAdapter;
-    this.uploadDir ??= join(tmpdir(), "uploads", httpAdapter.getHttpServer().id, randomUUIDv72());
+    this.uploadDir ??= join2(tmpdir(), "uploads", httpAdapter.getHttpServer().id, randomUUIDv72());
   }
   async intercept(context, next) {
     const request = context.switchToHttp().getRequest();
@@ -1410,7 +1602,7 @@ class BunFileInterceptor {
       return next.handle();
     }
     const files = await Promise.all(request.files.map(async (file) => {
-      const destPath = join(this.uploadDir, basename(file.name));
+      const destPath = join2(this.uploadDir, basename(file.name));
       await Bun.write(destPath, file);
       return Bun.file(destPath);
     }));
@@ -1430,7 +1622,7 @@ import {
   AbstractWsAdapter
 } from "@nestjs/websockets";
 import { EMPTY, Subject, mergeMap } from "rxjs";
-import { Logger as Logger2 } from "@nestjs/common";
+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) => {
@@ -1447,7 +1639,7 @@ var defaultMessageParser = (data) => {
 };
 
 class BunWsAdapter extends AbstractWsAdapter {
-  logger = new Logger2(BunWsAdapter.name);
+  logger = new Logger3(BunWsAdapter.name);
   nestApp;
   messageParser = defaultMessageParser;
   onOpenHandler;
@@ -1572,6 +1764,7 @@ class BunWsAdapter extends AbstractWsAdapter {
 }
 export {
   BunWsAdapter,
+  BunServerInstance,
   BunResponse,
   BunRequest,
   BunPreflightHttpServer,
@@ -1579,5 +1772,5 @@ export {
   BunAdapter
 };
 
-//# debugId=1BD5D75380392B3E64756E2164756E21
+//# debugId=B2EFFD14F95E510364756E2164756E21
 //# sourceMappingURL=index.js.map