@krisanalfa/bunest-adapter 0.4.0 → 0.5.0

package/README.md

@@ -20,6 +20,7 @@ This project provides a native Bun adapter for NestJS, allowing developers to le
     - [CORS](#cors)
     - [Cookies](#cookies)
     - [Popular Express Middleware](#popular-express-middleware)
+    - [Static Assets](#static-assets)
   - [Bun File API Support](#bun-file-api-support)
     - [BunFileInterceptor](#bunfileinterceptor)
   - [WebSocket Support](#websocket-support)
@@ -51,7 +52,7 @@ This project provides a native Bun adapter for NestJS, allowing developers to le
 Easy to set up and use Bun as the underlying HTTP server for your NestJS applications.
 
 ```ts
-import { BunAdapter } from "@krisanalfa/bunest-adapter";
+import { BunAdapter, NestBunApplication } from "@krisanalfa/bunest-adapter";
 import { Logger } from "@nestjs/common";
 import { NestFactory } from "@nestjs/core";
 import { Server } from "bun";
@@ -59,10 +60,10 @@ import { Server } from "bun";
 import { AppModule } from "./app.module.js";
 
 async function main() {
-  const app = await NestFactory.create(AppModule, new BunAdapter());
+  const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter());
   await app.listen(3000);
-  const server = app.getHttpAdapter().getHttpServer() as Server<unknown>;
-  Logger.log(`Server started on ${server.url.toString()}`, "NestApplication");
+  const server = app.getHttpServer().getBunServer()
+  Logger.log(`Server started on ${server?.url.toString() ?? 'http://localhost:3000'}`, 'NestApplication')
 }
 
 await main();
@@ -495,7 +496,7 @@ app.enableCors((req: BunRequest, callback) => {
 You can also use NestJS's `CorsOptions` type for static configuration.
 
 ```ts
-const app = await NestFactory.create(AppModule, new BunAdapter(), {
+const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter(), {
   cors: {
     origin: "https://example.com",
     methods: ["GET", "POST", "PUT"],
@@ -535,7 +536,7 @@ Compatible with popular Express middleware:
 ```ts
 import helmet from "helmet";
 
-const app = await NestFactory.create(AppModule, new BunAdapter());
+const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter());
 app.use(helmet());
 ```
 
@@ -543,7 +544,65 @@ Tested and working with:
 
 - `helmet` - Security headers
 - `cors` - CORS handling
-- And most other Express-compatible middleware
+- `@thallesp/nestjs-better-auth` - `better-auth` middleware
+- `express-session` - Session management
+
+#### Static Assets
+
+Serve static files from your NestJS application using Bun's native file serving capabilities. The adapter supports two distinct modes:
+
+**File Routes (Default)** - Reads files from the filesystem on each request, supports range requests, respects middlewares, and provides full HTTP feature compatibility:
+
+```ts
+import { join } from 'path';
+
+const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter());
+
+// Serve static assets using file routes (default)
+app.useStaticAssets(join(__dirname, 'public'));
+
+// Or explicitly set useStatic to false
+app.useStaticAssets(join(__dirname, 'public'), { useStatic: false });
+
+await app.listen(3000);
+
+// Files in 'public' directory are now accessible:
+// public/index.html -> http://localhost:3000/index.html
+// public/css/style.css -> http://localhost:3000/css/style.css
+// public/images/logo.png -> http://localhost:3000/images/logo.png
+```
+
+> Note: Even if the file routes read the files from the filesystem on each request, you still need to make sure that Bun has access to the files right before you call `app.listen()`. The adapter reads the directory structure and prepares the routes at that time. If you need different behavior (e.g., dynamic files), consider using a custom controller to serve those files.
+
+**Static Routes** - Serves files directly from memory for maximum performance, but with some limitations (no range requests, doesn't respect middlewares):
+
+```ts
+import { join } from 'path';
+
+const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter());
+
+// Serve static assets using static routes (faster, but with limitations)
+app.useStaticAssets(join(__dirname, 'public'), { useStatic: true });
+
+await app.listen(3000);
+```
+
+**With CORS Support:**
+
+```ts
+const app = await NestFactory.create<NestBunApplication>(
+  AppModule,
+  new BunAdapter(),
+  { cors: true }
+);
+
+// Static assets will respect CORS settings when using file routes
+app.useStaticAssets(join(__dirname, 'public'), { useStatic: false });
+```
+
+**Choosing Between Modes:**
+
+For more details, see [Bun's documentation on file responses vs static responses](https://bun.sh/docs/runtime/http/routing#file-responses-vs-static-responses).
 
 ### WebSocket Support
 
@@ -585,7 +644,7 @@ class ChatGateway implements OnGatewayConnection, OnGatewayDisconnect {
 }
 
 // Enable WebSocket support in your application
-const app = await NestFactory.create(AppModule, new BunAdapter());
+const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter());
 app.useWebSocketAdapter(new BunWsAdapter(app));
 await app.listen(3000);
 ```
@@ -777,10 +836,10 @@ The Bun adapter supports secure WebSocket connections (WSS) using TLS/SSL certif
 **Using BunAdapter constructor options:**
 
 ```ts
-import { BunAdapter, BunWsAdapter } from "@krisanalfa/bunest-adapter";
+import { BunAdapter, BunWsAdapter, NestBunApplication } from "@krisanalfa/bunest-adapter";
 import { NestFactory } from "@nestjs/core";
 
-const app = await NestFactory.create(
+const app = await NestFactory.create<NestBunApplication>(
   AppModule,
   new BunAdapter({
     tls: {
@@ -800,10 +859,10 @@ await app.listen(3000);
 **Using NestFactory.create httpsOptions:**
 
 ```ts
-import { BunAdapter, BunWsAdapter } from "@krisanalfa/bunest-adapter";
+import { BunAdapter, BunWsAdapter, NestBunApplication } from "@krisanalfa/bunest-adapter";
 import { NestFactory } from "@nestjs/core";
 
-const app = await NestFactory.create(AppModule, new BunAdapter(), {
+const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter(), {
   httpsOptions: {
     cert: Bun.file("/path/to/cert.pem"),
     key: Bun.file("/path/to/key.pem"),
@@ -819,10 +878,10 @@ await app.listen(3000);
 You can also run secure WebSocket servers over Unix sockets:
 
 ```ts
-import { BunAdapter, BunWsAdapter } from "@krisanalfa/bunest-adapter";
+import { BunAdapter, BunWsAdapter, NestBunApplication } from "@krisanalfa/bunest-adapter";
 import { NestFactory } from "@nestjs/core";
 
-const app = await NestFactory.create(
+const app = await NestFactory.create<NestBunApplication>(
   AppModule,
   new BunAdapter({
     tls: {
@@ -877,7 +936,7 @@ class ChatGateway {
 }
 
 // WebSocket will be available on the same port as HTTP
-const app = await NestFactory.create(AppModule, new BunAdapter());
+const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter());
 app.useWebSocketAdapter(new BunWsAdapter(app));
 await app.listen(3000); // Both HTTP and WebSocket use port 3000
 ```
@@ -943,7 +1002,7 @@ You can run your NestJS application with HTTPS using two approaches:
 #### Using Bun's built-in HTTPS support (recommended)
 
 ```ts
-const app = await NestFactory.create(
+const app = await NestFactory.create<NestBunApplication>(
   AppModule,
   new BunAdapter({
     tls: {
@@ -957,7 +1016,7 @@ const app = await NestFactory.create(
 #### Using NestJS App Factory HTTPS options
 
 ```ts
-const app = await NestFactory.create(
+const app = await NestFactory.create<NestBunApplication>(
   AppModule,
   new BunAdapter(/* leave it empty */),
   {

package/dist/bun.adapter.d.ts

@@ -4,7 +4,7 @@ import { NestApplicationOptions, RequestMethod, VersioningOptions } from '@nestj
 import { Server } from 'bun';
 import { AbstractHttpAdapter } from '@nestjs/core';
 import { VersionValue } from '@nestjs/common/interfaces/version-options.interface.js';
-import { BunWsClientData, ServerOptions } from './bun.internal.types.js';
+import { BunStaticAssetsOptions, BunWsClientData, ServerOptions } from './bun.internal.types.js';
 import { BunPreflightHttpServer } from './bun.preflight-http-server.js';
 import { BunRequest } from './bun.request.js';
 import { BunResponse } from './bun.response.js';
@@ -14,7 +14,7 @@ export declare class BunAdapter extends AbstractHttpAdapter<Server<unknown>, Bun
     private readonly logger;
     protected instance: BunServerInstance;
     constructor(bunServeOptions?: ServerOptions<BunWsClientData>);
-    useStaticAssets(...args: unknown[]): void;
+    useStaticAssets(path: string, options?: BunStaticAssetsOptions): void;
     setViewEngine(engine: string): void;
     render(response: unknown, view: string, options: unknown): void;
     close(): Promise<void>;

package/dist/bun.internal.types.d.ts

@@ -1,8 +1,10 @@
-import { CorsOptionsDelegate, CorsOptions as NestCorsOptions } from '@nestjs/common/interfaces/external/cors-options.interface.js';
+import { CorsOptions, CorsOptionsDelegate } from '@nestjs/common/interfaces/external/cors-options.interface.js';
 import { Serve, Server, ServerWebSocket, WebSocketHandler } from 'bun';
+import { INestApplication } from '@nestjs/common';
+import { BunPreflightHttpServer } from './bun.preflight-http-server.js';
 import { BunRequest } from './bun.request.js';
 export interface WsOptions extends Pick<WebSocketHandler<unknown>, 'maxPayloadLength' | 'idleTimeout' | 'backpressureLimit' | 'closeOnBackpressureLimit' | 'sendPings' | 'publishToSelf' | 'perMessageDeflate'> {
-    cors?: true | NestCorsOptions | CorsOptionsDelegate<BunRequest>;
+    cors?: true | CorsOptions | CorsOptionsDelegate<BunRequest>;
     clientDataFactory?: (req: BunRequest) => unknown;
 }
 export type ServerOptions<TWebSocketData = unknown> = Pick<Serve.Options<TWebSocketData>, 'development' | 'maxRequestBodySize' | 'idleTimeout' | 'id' | 'tls' | 'websocket' | 'port' | 'hostname'>;
@@ -20,3 +22,32 @@ export interface BunWsClientData {
     /** Called by NestJS for disconnect handling */
     onDisconnect?: (ws: ServerWebSocket<unknown>) => void;
 }
+export interface BunStaticAssetsOptions {
+    /**
+     * Enable static assets serving.
+     *
+     * Bun has two distict modes for serving static assets:
+     * 1. Static routes
+     * 2. File routes
+     *
+     * If you set `useStatic: true`, Bun will use static routes for serving assets.
+     * This approach is generally faster for serving static files, as it serves
+     * files directly from memory. However, it comes with some limitations, such as
+     * lack of support for certain features like range requests and directory indexing.
+     * On top of that, static routes didn't respect middlewares due to Bun's internal design.
+     *
+     * On the other hand, if you set `useStatic: false` (the default behavior),
+     * Bun will use file routes, which read files from the filesystem on each request.
+     * This method supports a wider range of features, including range requests, and respects
+     * middlewares. However, it may be slightly slower than static routes due to
+     * filesystem access on each request.
+     *
+     * @see https://bun.com/docs/runtime/http/routing#file-responses-vs-static-responses
+     * @defaults false Use file routes by default.
+     */
+    useStatic?: boolean;
+}
+export interface NestBunApplication extends INestApplication<BunPreflightHttpServer> {
+    useStaticAssets(path: string, options?: BunStaticAssetsOptions): void;
+    enableCors(options?: CorsOptions | CorsOptionsDelegate<BunRequest>): void;
+}

package/dist/bun.request.d.ts

@@ -3,6 +3,15 @@ import { ParsedQs } from 'qs';
 type HeadersProxy = Record<string, string> & {
     get: (key: string) => string | null;
 };
+interface Connection {
+    encrypted: boolean;
+}
+interface TcpSocket {
+    encrypted: boolean;
+    setKeepAlive: (enable?: boolean, initialDelay?: number) => void;
+    setNoDelay: (noDelay?: boolean) => void;
+    setTimeout: (timeout: number, callback?: () => void) => void;
+}
 /**
  * A high-performance request wrapper for Bun's native request object.
  * Provides lazy parsing and caching for optimal performance in NestJS applications.
@@ -26,23 +35,23 @@ export declare class BunRequest {
     private _file;
     private _files;
     private _settings;
-    private readonly _url;
+    private _connection;
+    private _socket;
+    private _url;
     private readonly _parsedUrl;
     readonly method: string;
     readonly params: Record<string, string>;
     constructor(nativeRequest: NativeRequest);
+    /**
+     * Gets a mock connection object for compatibility with Node.js middleware.
+     * Some middleware (like express-session) check req.connection.encrypted to determine if the connection is HTTPS.
+     */
+    get connection(): Connection;
     /**
      * Gets a mock socket object for compatibility with Node.js middleware.
      * Some middleware (like Better Auth) check req.socket.encrypted to determine if the connection is HTTPS.
-     *
-     * @returns A mock socket object with encrypted property
      */
-    get socket(): {
-        encrypted: boolean;
-        setKeepAlive: () => void;
-        setNoDelay: () => void;
-        setTimeout: () => void;
-    };
+    get socket(): TcpSocket;
     /**
      * Gets the URL path and query string of the request.
      * Returns the pathname + search params for Node.js/Express compatibility.

package/dist/bun.response.d.ts

@@ -373,6 +373,13 @@ export declare class BunResponse {
      * ```
      */
     isEnded(): boolean;
+    /**
+     * Stub method for Node.js HTTP response compatibility.
+     *
+     * The primary purpose of _implicitHeader() is to automatically generate and send the HTTP headers if a write operation (like `response.write()` or `response.end()`)
+     * is called without explicitly calling `response.writeHead()` first.
+     */
+    _implicitHeader(): void;
     private buildStreamableResponse;
     private buildJsonResponse;
     private createResponse;

package/dist/bun.server-instance.d.ts

@@ -2,7 +2,7 @@ import { CorsOptions, CorsOptionsDelegate } from '@nestjs/common/interfaces/exte
 import { RequestMethod } from '@nestjs/common';
 import { Server, ServerWebSocket } from 'bun';
 import { RequestHandler } from '@nestjs/common/interfaces/index.js';
-import { BunWsClientData, ServerOptions, WsData, WsOptions } from './bun.internal.types.js';
+import { BunStaticAssetsOptions, BunWsClientData, ServerOptions, WsData, WsOptions } from './bun.internal.types.js';
 import { BunMiddlewareEngine } from './bun.middleware-engine.js';
 import { BunRequest } from './bun.request.js';
 import { BunResponse } from './bun.response.js';
@@ -25,6 +25,7 @@ export declare class BunServerInstance {
     private wsOptions;
     private useWs;
     private useWsCors;
+    private staticAssetsOptions;
     private httpServer;
     constructor(bunServeOptions: ServerOptions<BunWsClientData>);
     use(maybePath: string | RequestHandler<BunRequest, BunResponse>, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
@@ -52,7 +53,7 @@ export declare class BunServerInstance {
      * @param hostnameOrCallback The hostname to bind to or the callback function.
      * @param maybeCallback Optional callback to invoke once the server is listening.
      */
-    listen(port: string | number, hostnameOrCallback?: string | (() => void), maybeCallback?: () => void): Server<unknown>;
+    listen(port: string | number, hostnameOrCallback?: string | (() => void), maybeCallback?: () => void): Promise<Server<unknown>>;
     /**
      * NestJS compatibility methods - stop the server
      */
@@ -112,11 +113,16 @@ export declare class BunServerInstance {
      * Enable CORS middleware
      */
     enableCors(corsOptions?: CorsOptions | CorsOptionsDelegate<BunRequest>, prefix?: string): void;
+    /**
+     * Serve static assets
+     */
+    useStaticAssets(path: string, options?: BunStaticAssetsOptions): void;
     private static isNumericPort;
     private static omitKeys;
     private isWebSocketUpgradeRequest;
     private provideCorsHeaders;
     private upgradeWebSocket;
+    private setupStaticAssetsIfNeeded;
     private setupWebSocketIfNeeded;
     private createServer;
     private delegateRouteHandler;

package/dist/index.js

@@ -58,6 +58,8 @@ class BunPreflightHttpServer {
 
 // 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;
@@ -429,28 +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;
@@ -531,14 +539,18 @@ 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) {
@@ -797,6 +809,9 @@ class BunResponse {
   isEnded() {
     return this.ended;
   }
+  _implicitHeader() {
+    this.writeHead(this.statusCode, {});
+  }
   buildStreamableResponse(body) {
     const streamHeaders = body.getHeaders();
     const headers = this.headersMap;
@@ -1045,6 +1060,7 @@ class BunServerInstance {
   wsOptions = {};
   useWs = false;
   useWsCors = false;
+  staticAssetsOptions = null;
   httpServer = null;
   constructor(bunServeOptions) {
     this.bunServeOptions = bunServeOptions;
@@ -1125,13 +1141,14 @@ class BunServerInstance {
   search(pathOrHandler, maybeHandler) {
     this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
-  listen(port, hostnameOrCallback, maybeCallback) {
+  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);
@@ -1222,6 +1239,10 @@ class BunServerInstance {
     const corsMiddleware = new BunCorsMiddleware({ corsOptions, prefix });
     this.middlewareEngine.useGlobal(corsMiddleware.run.bind(corsMiddleware));
   }
+  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));
   }
@@ -1261,6 +1282,70 @@ class BunServerInstance {
       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;
     if (!useWs)
@@ -1399,8 +1484,8 @@ class BunAdapter extends AbstractHttpAdapter {
     super(new BunServerInstance(bunServeOptions));
     this.bunServeOptions = bunServeOptions;
   }
-  useStaticAssets(...args) {
-    throw new Error("Not supported.");
+  useStaticAssets(path, options) {
+    this.instance.useStaticAssets(path, options);
   }
   setViewEngine(engine) {
     throw new Error("Not supported.");
@@ -1478,7 +1563,9 @@ class BunAdapter extends AbstractHttpAdapter {
     return BunVersionFilterMiddleware.createFilter(handler, version, versioningOptions);
   }
   listen(port, hostnameOrCallback, maybeCallback) {
-    this.setHttpServer(this.instance.listen(port, hostnameOrCallback, maybeCallback));
+    this.instance.listen(port, hostnameOrCallback, maybeCallback).then((server) => {
+      this.setHttpServer(server);
+    });
   }
   configureTls(options) {
     if (options.httpsOptions) {
@@ -1497,7 +1584,7 @@ class BunAdapter extends AbstractHttpAdapter {
 }
 // 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";
@@ -1507,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();
@@ -1515,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);
     }));
@@ -1685,5 +1772,5 @@ export {
   BunAdapter
 };
 
-//# debugId=813882D1C572F1EC64756E2164756E21
+//# debugId=B2EFFD14F95E510364756E2164756E21
 //# sourceMappingURL=index.js.map