@krisanalfa/bunest-adapter 0.0.1

package/dist/index.js

@@ -0,0 +1,1089 @@
+// @bun
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// lib/bun.adapter.ts
+import {
+  Logger
+} from "@nestjs/common";
+var {randomUUIDv7 } = globalThis.Bun;
+import { AbstractHttpAdapter } from "@nestjs/core";
+
+// lib/bun.body-parser.middleware.ts
+var GET_CODE = 71;
+var HEAD_CODE = 72;
+var DELETE_CODE = 68;
+var OPTIONS_CODE = 79;
+
+class BunBodyParserMiddleware {
+  prefix;
+  rawBody;
+  prefixLen;
+  constructor(options) {
+    this.prefix = options?.prefix ?? null;
+    this.prefixLen = this.prefix?.length ?? 0;
+    this.rawBody = options?.rawBody ?? false;
+  }
+  async run(req, res, next) {
+    const methodFirstChar = req.method.charCodeAt(0);
+    if (methodFirstChar === GET_CODE || methodFirstChar === HEAD_CODE || methodFirstChar === DELETE_CODE || methodFirstChar === OPTIONS_CODE) {
+      next?.();
+      return;
+    }
+    if (this.prefix !== null) {
+      const pathname = req.pathname;
+      if (pathname.length < this.prefixLen || !pathname.startsWith(this.prefix)) {
+        next?.();
+        return;
+      }
+    }
+    if (this.rawBody) {
+      req.setRawBody(await req.arrayBuffer());
+    }
+    await this.parseRequestBody(req);
+    next?.();
+  }
+  async parseRequestBody(req) {
+    const contentType = req.headers.get("content-type");
+    if (!contentType) {
+      return;
+    }
+    if (contentType.includes("application/json")) {
+      req.setBody(await req.json());
+      return;
+    }
+    if (contentType.includes("text/") || contentType.includes("application/text")) {
+      req.setBody(await req.text());
+      return;
+    }
+    if (contentType.includes("form")) {
+      await this.parseFormData(req);
+    }
+  }
+  async parseFormData(req) {
+    const formData = await req.formData();
+    const body = Object.create(null);
+    let files = null;
+    let firstFile = null;
+    for (const [key, value] of formData.entries()) {
+      body[key] = value;
+      if (this.isFile(value)) {
+        if (firstFile === null) {
+          firstFile = value;
+          files = [value];
+        } else {
+          files?.push(value);
+        }
+      }
+    }
+    req.setBody(body);
+    if (firstFile !== null) {
+      req.setFile(firstFile);
+    }
+    if (files !== null) {
+      req.setFiles(files);
+    }
+  }
+  isFile(value) {
+    return typeof value === "object" && value !== null && "size" in value && "name" in value && "type" in value;
+  }
+}
+
+// lib/bun.cors.middleware.ts
+import cors from "cors";
+
+class BunCorsMiddleware {
+  options;
+  prefix;
+  constructor(options) {
+    this.options = options?.corsOptions;
+    this.prefix = options?.prefix;
+  }
+  async run(req, res, next) {
+    const nextFn = next;
+    if (this.prefix && !req.pathname.startsWith(this.prefix)) {
+      return nextFn?.();
+    }
+    const corsOptions = await this.resolveCorsOptions(req);
+    const { nodeReq, nodeRes, isEnded } = this.createNodeAdapters(req, res);
+    cors(corsOptions)(nodeReq, nodeRes, (err) => {
+      if (err)
+        return nextFn?.(err);
+      if (!isEnded())
+        nextFn?.();
+    });
+  }
+  async resolveCorsOptions(req) {
+    const options = this.options;
+    if (typeof options === "function") {
+      return new Promise((resolve, reject) => {
+        options(req, (err, opts) => {
+          if (err)
+            reject(err);
+          else
+            resolve(opts);
+        });
+      });
+    }
+    if (!options)
+      return;
+    return {
+      origin: options.origin,
+      methods: options.methods,
+      allowedHeaders: options.allowedHeaders,
+      exposedHeaders: options.exposedHeaders,
+      credentials: options.credentials,
+      maxAge: options.maxAge,
+      preflightContinue: options.preflightContinue,
+      optionsSuccessStatus: options.optionsSuccessStatus
+    };
+  }
+  createNodeAdapters(req, res) {
+    const nodeReq = {
+      method: req.method,
+      headers: req.headers,
+      url: req.pathname
+    };
+    const nodeRes = {
+      get statusCode() {
+        return res.getStatus();
+      },
+      set statusCode(code) {
+        res.setStatus(code);
+      },
+      setHeader: (key, value) => {
+        res.setHeader(key, value);
+      },
+      end: (data) => {
+        res.end(data);
+      },
+      getHeader: (name) => res.getHeader(name),
+      removeHeader: (name) => {
+        res.removeHeader(name);
+      }
+    };
+    return { nodeReq, nodeRes, isEnded: () => res.isEnded() };
+  }
+}
+
+// lib/bun.middleware-engine.ts
+var EMPTY_HANDLERS = new Array(0);
+var noop = () => {};
+
+class BunMiddlewareEngine {
+  globalMiddlewares = [];
+  routeMiddleware = new Map;
+  routeMiddlewareByMethod = new Map;
+  wildcardMiddleware = new Map;
+  middlewareCache = new Map;
+  errorHandler = null;
+  notFoundHandler = null;
+  useGlobal(middleware) {
+    this.globalMiddlewares.push(middleware);
+  }
+  useRoute(method, path, middleware) {
+    const key = `${method}:${path}`;
+    (this.routeMiddleware.get(key) ?? this.routeMiddleware.set(key, []).get(key)).push(middleware);
+    (this.routeMiddlewareByMethod.get(method) ?? this.routeMiddlewareByMethod.set(method, new Map).get(method)).set(path, this.routeMiddlewareByMethod.get(method)?.get(path) ?? []).get(path).push(middleware);
+  }
+  useWildcard(method, middleware) {
+    (this.wildcardMiddleware.get(method) ?? this.wildcardMiddleware.set(method, []).get(method)).push(middleware);
+  }
+  useErrorHandler(handler) {
+    this.errorHandler = handler;
+  }
+  useNotFoundHandler(handler) {
+    this.notFoundHandler = handler;
+  }
+  async run(options) {
+    try {
+      const middlewares = this.getMiddlewareChain(options.method, options.path);
+      await this.executeChain(middlewares, options.requestHandler, options.req, options.res);
+      return options.res;
+    } catch (error) {
+      return this.handleError(error, options.req, options.res);
+    }
+  }
+  getMiddlewareChain(method, path) {
+    const cacheKey = `${method}:${path}`;
+    let cached = this.middlewareCache.get(cacheKey);
+    if (cached !== undefined)
+      return cached;
+    cached = this.buildMiddlewareChain(method, path, cacheKey);
+    this.middlewareCache.set(cacheKey, cached);
+    return cached;
+  }
+  buildMiddlewareChain(method, path, cacheKey) {
+    const global = this.globalMiddlewares;
+    const globalLen = global.length;
+    const wildcardAll = this.wildcardMiddleware.get("ALL");
+    const wildcardMethod = this.wildcardMiddleware.get(method);
+    const routeMiddleware = this.findRouteMiddleware(method, path, cacheKey);
+    const wildcardAllLen = wildcardAll?.length ?? 0;
+    const wildcardMethodLen = wildcardMethod?.length ?? 0;
+    const routeLen = routeMiddleware.length;
+    const totalLen = globalLen + wildcardAllLen + wildcardMethodLen + routeLen;
+    if (totalLen === 0)
+      return EMPTY_HANDLERS;
+    const chain = new Array(totalLen);
+    let idx = 0;
+    for (let i = 0;i < globalLen; i++)
+      chain[idx++] = global[i];
+    if (wildcardAll)
+      for (let i = 0;i < wildcardAllLen; i++)
+        chain[idx++] = wildcardAll[i];
+    if (wildcardMethod)
+      for (let i = 0;i < wildcardMethodLen; i++)
+        chain[idx++] = wildcardMethod[i];
+    for (let i = 0;i < routeLen; i++)
+      chain[idx++] = routeMiddleware[i];
+    return chain;
+  }
+  findRouteMiddleware(method, path, cacheKey) {
+    const exactMiddleware = this.routeMiddleware.get(cacheKey);
+    if (exactMiddleware !== undefined)
+      return exactMiddleware;
+    return this.findBestPrefixMatch(method, path);
+  }
+  findBestPrefixMatch(method, path) {
+    const methodMap = this.routeMiddlewareByMethod.get(method);
+    if (!methodMap)
+      return EMPTY_HANDLERS;
+    let bestMatch = null;
+    let bestMatchLength = 0;
+    const pathLen = path.length;
+    for (const [keyPath, middleware] of methodMap) {
+      const keyPathLen = keyPath.length;
+      if (keyPathLen <= bestMatchLength || middleware.length === 0)
+        continue;
+      if (path === keyPath || pathLen > keyPathLen && path.charCodeAt(keyPathLen) === 47 && path.startsWith(keyPath)) {
+        bestMatch = middleware;
+        bestMatchLength = keyPathLen;
+      }
+    }
+    return bestMatch ?? EMPTY_HANDLERS;
+  }
+  async executeChain(chain, requestHandler, req, res) {
+    const chainLength = chain.length;
+    let index = 0;
+    const next = async (err) => {
+      if (err)
+        throw err;
+      if (index < chainLength) {
+        const handler = chain[index++];
+        const result = handler(req, res, next);
+        if (result instanceof Promise)
+          await result;
+        return;
+      }
+      if (index === chainLength) {
+        index++;
+        const result = requestHandler(req, res, next);
+        if (result instanceof Promise)
+          await result;
+        if (index > chainLength) {
+          const result2 = this.notFoundHandler?.(req, res, noop);
+          if (result2 instanceof Promise)
+            await result2;
+        }
+      }
+    };
+    await next();
+  }
+  async handleError(error, req, res) {
+    if (this.errorHandler !== null) {
+      const result = this.errorHandler(error, req, res, noop);
+      if (result instanceof Promise)
+        await result;
+      return res;
+    }
+    throw error;
+  }
+}
+
+// lib/bun.request.ts
+import { parse } from "qs";
+var NULL_PROTO = Object.getPrototypeOf(Object.create(null));
+
+class BunRequest {
+  nativeRequest;
+  _nativeHeaders;
+  _headers = null;
+  _hostname = null;
+  _pathname = null;
+  _query = null;
+  _body = null;
+  _rawBody = null;
+  _file = null;
+  _files = null;
+  _settings = null;
+  _url;
+  _parsedUrl;
+  method;
+  params;
+  constructor(nativeRequest) {
+    this.nativeRequest = nativeRequest;
+    this._url = nativeRequest.url;
+    this._parsedUrl = new URL(this._url);
+    this._nativeHeaders = nativeRequest.headers;
+    this.method = nativeRequest.method;
+    this.params = nativeRequest.params;
+  }
+  get url() {
+    return this._url;
+  }
+  get pathname() {
+    return this._pathname ??= this._parsedUrl.pathname;
+  }
+  get hostname() {
+    return this._hostname ??= this.headers.get("x-forwarded-host") ?? this._parsedUrl.hostname;
+  }
+  get headers() {
+    if (this._headers !== null)
+      return this._headers;
+    const native = this._nativeHeaders;
+    const proxy = Object.create(NULL_PROTO);
+    native.forEach((value, key) => {
+      proxy[key.toLowerCase()] = value;
+    });
+    proxy.get = (key) => native.get(key);
+    return this._headers = proxy;
+  }
+  get query() {
+    return this._query ??= parse(this._parsedUrl.searchParams.toString());
+  }
+  get body() {
+    return this._body;
+  }
+  setBody(body) {
+    this._body = body;
+  }
+  get rawBody() {
+    return this._rawBody;
+  }
+  setRawBody(rawBody) {
+    this._rawBody = rawBody;
+  }
+  get file() {
+    return this._file;
+  }
+  setFile(file) {
+    this._file = file;
+  }
+  get files() {
+    return this._files;
+  }
+  setFiles(files) {
+    this._files = files;
+  }
+  get(key) {
+    return this._settings?.get(key);
+  }
+  set(key, value) {
+    (this._settings ??= new Map).set(key, value);
+  }
+  get signal() {
+    return this.nativeRequest.signal;
+  }
+  get cookies() {
+    return this.nativeRequest.cookies;
+  }
+  json() {
+    return this.nativeRequest.json();
+  }
+  text() {
+    return this.nativeRequest.text();
+  }
+  formData() {
+    return this.nativeRequest.formData();
+  }
+  arrayBuffer() {
+    return this.nativeRequest.arrayBuffer();
+  }
+  blob() {
+    return this.nativeRequest.blob();
+  }
+  bytes() {
+    return this.nativeRequest.bytes();
+  }
+  clone() {
+    const cloned = new BunRequest(this.nativeRequest.clone());
+    cloned._pathname = this._pathname;
+    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;
+    return cloned;
+  }
+}
+
+// lib/bun.response.ts
+var {CookieMap } = globalThis.Bun;
+import { StreamableFile } from "@nestjs/common";
+var JSON_CONTENT_TYPE = "application/json";
+
+class BunResponse {
+  resolve;
+  response;
+  cookieMap = new CookieMap;
+  _headers = null;
+  statusCode = 200;
+  ended = false;
+  _cookieHeaderCache = null;
+  constructor() {
+    this.response = new Promise((r) => {
+      this.resolve = r;
+    });
+  }
+  get headersMap() {
+    return this._headers ??= new Map;
+  }
+  cookie(...args) {
+    this._cookieHeaderCache = null;
+    if (args.length === 1) {
+      this.cookieMap.set(args[0]);
+    } else {
+      this.cookieMap.set(args[0], args[1]);
+    }
+  }
+  deleteCookie(optionsOrName, options) {
+    if (typeof optionsOrName === "string") {
+      this.cookieMap.delete(optionsOrName, options);
+    } else {
+      this.cookieMap.delete(optionsOrName);
+    }
+  }
+  redirect(url, statusCode = 302) {
+    if (this.ended)
+      return;
+    this.ended = true;
+    this.resolve(Response.redirect(url, statusCode));
+  }
+  end(body) {
+    if (this.ended)
+      return;
+    this.ended = true;
+    this._cookieHeaderCache ??= this.cookieMap.toSetCookieHeaders().join("; ");
+    if (this._cookieHeaderCache.length > 0) {
+      this.setHeader("set-cookie", this._cookieHeaderCache);
+    }
+    if (body !== null && typeof body === "object") {
+      if (body instanceof Uint8Array || body instanceof Blob) {
+        this.resolve(this.createResponse(body));
+        return;
+      }
+      if (body instanceof StreamableFile) {
+        this.resolve(this.buildStreamableResponse(body));
+        return;
+      }
+      this.resolve(this.buildJsonResponse(body));
+      return;
+    }
+    if (!body) {
+      this.resolve(this.createResponse(null));
+      return;
+    }
+    this.resolve(this.buildJsonResponse(body));
+  }
+  setHeader(name, value) {
+    this.headersMap.set(name.toLowerCase(), value);
+  }
+  getHeader(name) {
+    return this._headers?.get(name.toLowerCase()) ?? null;
+  }
+  appendHeader(name, value) {
+    const key = name.toLowerCase();
+    const headers = this.headersMap;
+    const existing = headers.get(key);
+    headers.set(key, existing ? `${existing}, ${value}` : value);
+  }
+  removeHeader(name) {
+    this._headers?.delete(name.toLowerCase());
+  }
+  setStatus(code) {
+    this.statusCode = code;
+  }
+  getStatus() {
+    return this.statusCode;
+  }
+  res() {
+    return this.response;
+  }
+  isEnded() {
+    return this.ended;
+  }
+  buildStreamableResponse(body) {
+    const streamHeaders = body.getHeaders();
+    const headers = this.headersMap;
+    if (streamHeaders.type && !headers.has("content-type")) {
+      headers.set("content-type", streamHeaders.type);
+    }
+    if (streamHeaders.disposition && !headers.has("content-disposition")) {
+      headers.set("content-disposition", streamHeaders.disposition);
+    }
+    if (streamHeaders.length !== undefined && !headers.has("content-length")) {
+      headers.set("content-length", String(streamHeaders.length));
+    }
+    return this.createResponse(body.getStream());
+  }
+  buildJsonResponse(body) {
+    const headers = this._headers;
+    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);
+    }
+    return Response.json(body, {
+      status: this.statusCode,
+      headers: Object.fromEntries(headers)
+    });
+  }
+  createResponse(body) {
+    const headers = this._headers;
+    if (headers === null || headers.size === 0) {
+      return new Response(body, { status: this.statusCode });
+    }
+    return new Response(body, {
+      status: this.statusCode,
+      headers: Object.fromEntries(headers)
+    });
+  }
+}
+
+// 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();
+}
+
+class BunVersionFilterMiddleware {
+  static createFilter(handler, version, versioningOptions) {
+    if (version === VERSION_NEUTRAL || versioningOptions.type === VersioningType.URI) {
+      return handler;
+    }
+    switch (versioningOptions.type) {
+      case VersioningType.CUSTOM:
+        return this.createCustomVersionFilter(handler, version, versioningOptions);
+      case VersioningType.MEDIA_TYPE:
+        return this.createMediaTypeVersionFilter(handler, version, versioningOptions);
+      case VersioningType.HEADER:
+        return this.createHeaderVersionFilter(handler, version, versioningOptions);
+      default:
+        throw new Error("Unsupported versioning options");
+    }
+  }
+  static createVersionMatcher(handlerVersion) {
+    if (Array.isArray(handlerVersion)) {
+      const versionSet = new Set(handlerVersion);
+      return (requestedVersion) => requestedVersion !== undefined && versionSet.has(requestedVersion);
+    }
+    return (requestedVersion) => requestedVersion == handlerVersion;
+  }
+  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) => {
+      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 match;
+      let matchIndex = -1;
+      for (let i = 0;i < extractedVersions.length; i++) {
+        const extractedVersion = extractedVersions[i];
+        if (versionSet ? versionSet.has(extractedVersion) : extractedVersion === singleVersion) {
+          match = extractedVersion;
+          matchIndex = i;
+          break;
+        }
+      }
+      if (match) {
+        if (isDiscovery) {
+          reqMeta._customVersioningCandidates.set(match, {
+            priority: matchIndex,
+            execute: () => handler(req, res, next)
+          });
+          return callNext(next);
+        }
+        if (reqMeta._customVersioningBestCandidate === match) {
+          return executeHandler(handler, req, res, next);
+        }
+      }
+      return callNext(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");
+      if (acceptHeader) {
+        const semiIndex = acceptHeader.indexOf(";");
+        if (semiIndex !== -1) {
+          const versionPart = acceptHeader.substring(semiIndex + 1).trim();
+          const keyIndex = versionPart.indexOf(options.key);
+          if (keyIndex !== -1) {
+            const headerVersion = versionPart.substring(keyIndex + keyLength);
+            if (versionMatches(headerVersion)) {
+              return executeHandler(handler, req, res, next);
+            }
+            return callNext(next);
+          }
+        }
+      }
+      if (acceptsNeutral) {
+        return executeHandler(handler, req, res, next);
+      }
+      return callNext(next);
+    };
+  }
+  static createHeaderVersionFilter(handler, version, options) {
+    const acceptsNeutral = this.computeAcceptsNeutral(version);
+    const versionMatches = this.createVersionMatcher(version);
+    const defaultVersion = options.defaultVersion;
+    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;
+      headerVersion ??= resolvedDefault;
+      if (!headerVersion) {
+        if ((hasNeutralDefault || !defaultVersion) && acceptsNeutral) {
+          return executeHandler(handler, req, res, next);
+        }
+        return callNext(next);
+      }
+      if (versionMatches(headerVersion)) {
+        return executeHandler(handler, req, res, next);
+      }
+      return callNext(next);
+    };
+  }
+  static resolveDefaultVersion(handlerVersion, defaultVersion) {
+    if (defaultVersion === undefined || defaultVersion === VERSION_NEUTRAL) {
+      return;
+    }
+    const handlerVersions = Array.isArray(handlerVersion) ? handlerVersion : [handlerVersion];
+    if (typeof defaultVersion === "string") {
+      return handlerVersions.includes(defaultVersion) ? defaultVersion : undefined;
+    }
+    if (Array.isArray(defaultVersion)) {
+      return defaultVersion.find((dv) => typeof dv === "string" && handlerVersions.includes(dv));
+    }
+    return;
+  }
+  static selectBestCustomVersionCandidate(req) {
+    const { _customVersioningPhase: phase, _customVersioningCandidates: candidates } = req;
+    if (phase !== "discovery" || !candidates?.size)
+      return null;
+    let bestVersion = null;
+    let bestPriority = Infinity;
+    for (const [version, { priority }] of candidates) {
+      if (priority < bestPriority) {
+        bestPriority = priority;
+        bestVersion = version;
+      }
+    }
+    return bestVersion;
+  }
+  static setCustomVersioningExecutionPhase(req, bestVersion) {
+    const reqMeta = req;
+    reqMeta._customVersioningPhase = "execution";
+    reqMeta._customVersioningBestCandidate = bestVersion;
+  }
+  static hasCustomVersioningCandidates(req) {
+    const { _customVersioningPhase: phase, _customVersioningCandidates: candidates } = req;
+    return phase === "discovery" && !!candidates?.size;
+  }
+}
+
+// lib/bun.adapter.ts
+var REQUEST_METHOD_STRINGS = [
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "ALL",
+  "OPTIONS",
+  "HEAD",
+  "SEARCH",
+  "PROPFIND",
+  "PROPPATCH",
+  "MKCOL",
+  "COPY",
+  "MOVE",
+  "LOCK",
+  "UNLOCK"
+];
+
+class BunAdapter extends AbstractHttpAdapter {
+  bunServeOptions;
+  logger = new Logger("BunAdapter", { timestamp: true });
+  middlewareEngine = new BunMiddlewareEngine;
+  useVersioning = false;
+  routes = Object.create(null);
+  routeHandlers = new Map;
+  notFoundHandler = (req, res) => {
+    res.setStatus(404);
+    res.end({ message: "Not Found" });
+  };
+  constructor(bunServeOptions = {
+    development: false,
+    id: randomUUIDv7()
+  }) {
+    super();
+    this.bunServeOptions = bunServeOptions;
+  }
+  use(middleware) {
+    this.middlewareEngine.useGlobal(middleware);
+  }
+  get(pathOrHandler, maybeHandler) {
+    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
+    this.delegateRouteHandler("GET", path, handler);
+  }
+  post(pathOrHandler, maybeHandler) {
+    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
+    this.delegateRouteHandler("POST", path, handler);
+  }
+  put(pathOrHandler, maybeHandler) {
+    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
+    this.delegateRouteHandler("PUT", path, handler);
+  }
+  patch(pathOrHandler, maybeHandler) {
+    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
+    this.delegateRouteHandler("PATCH", path, handler);
+  }
+  delete(pathOrHandler, maybeHandler) {
+    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
+    this.delegateRouteHandler("DELETE", path, handler);
+  }
+  head(pathOrHandler, maybeHandler) {
+    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
+    this.delegateRouteHandler("HEAD", path, handler);
+  }
+  options(pathOrHandler, maybeHandler) {
+    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
+    this.delegateRouteHandler("OPTIONS", path, handler);
+  }
+  all(pathOrHandler, maybeHandler) {
+    throw new Error("Not supported.");
+  }
+  propfind(pathOrHandler, maybeHandler) {
+    throw new Error("Not supported.");
+  }
+  proppatch(pathOrHandler, maybeHandler) {
+    throw new Error("Not supported.");
+  }
+  mkcol(pathOrHandler, maybeHandler) {
+    throw new Error("Not supported.");
+  }
+  copy(pathOrHandler, maybeHandler) {
+    throw new Error("Not supported.");
+  }
+  move(pathOrHandler, maybeHandler) {
+    throw new Error("Not supported.");
+  }
+  lock(pathOrHandler, maybeHandler) {
+    throw new Error("Not supported.");
+  }
+  unlock(pathOrHandler, maybeHandler) {
+    throw new Error("Not supported.");
+  }
+  search(pathOrHandler, maybeHandler) {
+    throw new Error("Not supported.");
+  }
+  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.httpServer.stop();
+  }
+  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
+      };
+    }
+  }
+  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.middlewareEngine.useErrorHandler(handler);
+  }
+  setNotFoundHandler(handler, prefix) {
+    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);
+  }
+  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);
+      if (path === "*" || path === "/*") {
+        this.middlewareEngine.useWildcard(methodName, callback);
+        return;
+      }
+      const normalizedPath = path === "/" ? path : path.replace(/\/$/, "");
+      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);
+  }
+  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;
+      await middlewareEngine.run({
+        req: bunRequest,
+        res: bunResponse,
+        method: bunRequest.method,
+        path: bunRequest.pathname,
+        requestHandler: notFoundHandler
+      });
+      return bunResponse.res();
+    };
+    const omit = (obj, ...keys) => {
+      const result = { ...obj };
+      for (const key of keys) {
+        Reflect.deleteProperty(result, key);
+      }
+      return result;
+    };
+    const server = typeof port === "number" || !isNaN(Number(port)) ? Bun.serve({
+      ...this.bunServeOptions,
+      hostname,
+      port,
+      routes: this.routes,
+      fetch
+    }) : Bun.serve({
+      ...omit(this.bunServeOptions, "idleTimeout"),
+      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) {
+    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) => {
+      const bunRequest = new BunRequest(request);
+      const bunResponse = new BunResponse;
+      await this.middlewareEngine.run({
+        req: bunRequest,
+        res: bunResponse,
+        method,
+        path,
+        requestHandler
+      });
+      return bunResponse.res();
+    };
+  }
+  createVersioningHandlers(method, path, handler) {
+    const routeKey = `${method}:${path}`;
+    let versioningHandlers = this.routeHandlers.get(routeKey);
+    if (!versioningHandlers) {
+      versioningHandlers = [];
+      this.routeHandlers.set(routeKey, versioningHandlers);
+    }
+    versioningHandlers.push(handler);
+    return versioningHandlers;
+  }
+  async executeHandlerChain(handlers, req, res) {
+    const handlersLength = handlers.length;
+    let index = 0;
+    let shouldContinue = true;
+    while (shouldContinue && index < handlersLength && !res.isEnded()) {
+      shouldContinue = false;
+      const currentIndex = index++;
+      const result = handlers[currentIndex](req, res, () => {
+        shouldContinue = true;
+      });
+      if (result instanceof Promise)
+        await result;
+    }
+  }
+  createChainedHandlerForVersioningResolution(handlers, notFoundHandler) {
+    return async (req, res, next) => {
+      await this.executeHandlerChain(handlers, req, res);
+      if (!res.isEnded() && BunVersionFilterMiddleware.hasCustomVersioningCandidates(req)) {
+        const bestVersion = BunVersionFilterMiddleware.selectBestCustomVersionCandidate(req);
+        if (bestVersion) {
+          BunVersionFilterMiddleware.setCustomVersioningExecutionPhase(req, bestVersion);
+          await this.executeHandlerChain(handlers, req, res);
+        }
+      }
+      if (!res.isEnded()) {
+        notFoundHandler(req, res, next);
+      }
+    };
+  }
+  mapRequestMethodToString(requestMethod) {
+    return REQUEST_METHOD_STRINGS[requestMethod] ?? "ALL";
+  }
+  parseRouteHandler(pathOrHandler, maybeHandler) {
+    const path = typeof pathOrHandler === "string" ? pathOrHandler : "/";
+    const handler = typeof pathOrHandler === "function" ? pathOrHandler : maybeHandler;
+    return { path, handler };
+  }
+}
+// lib/bun.file.interceptor.ts
+import { Injectable } from "@nestjs/common";
+import { basename, join } from "path";
+import { HttpAdapterHost } from "@nestjs/core";
+var {randomUUIDv7: randomUUIDv72 } = globalThis.Bun;
+import { tmpdir } from "os";
+class BunFileInterceptor {
+  adapter;
+  uploadDir = Bun.env.BUN_UPLOAD_DIR;
+  constructor(adapter) {
+    this.adapter = adapter;
+    const httpAdapter = this.adapter.httpAdapter;
+    this.uploadDir ??= join(tmpdir(), "uploads", httpAdapter.getHttpServer().id, randomUUIDv72());
+  }
+  async intercept(context, next) {
+    const request = context.switchToHttp().getRequest();
+    if (!request.files?.length) {
+      return next.handle();
+    }
+    const files = await Promise.all(request.files.map(async (file) => {
+      const destPath = join(this.uploadDir, basename(file.name));
+      await Bun.write(destPath, file);
+      return Bun.file(destPath);
+    }));
+    request.setFile(files[0]);
+    request.setFiles(files);
+    return next.handle();
+  }
+}
+BunFileInterceptor = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof HttpAdapterHost === "undefined" ? Object : HttpAdapterHost
+  ])
+], BunFileInterceptor);
+export {
+  BunResponse,
+  BunRequest,
+  BunFileInterceptor,
+  BunAdapter
+};
+
+//# debugId=E15070B5DB09928264756E2164756E21
+//# sourceMappingURL=index.js.map