@krisanalfa/bunest-adapter 0.0.1 → 0.3.0

package/README.md

@@ -2,6 +2,47 @@
 
 This project provides a native Bun adapter for NestJS, allowing developers to leverage the performance benefits of the Bun runtime while using the powerful features of the NestJS framework.
 
+## Table of Contents
+
+- [Features](#features)
+  - [Native Bun adapter for NestJS](#native-bun-adapter-for-nestjs)
+  - [Full NestJS Feature Support](#full-nestjs-feature-support)
+    - [Controllers & HTTP Methods](#controllers--http-methods)
+    - [Middleware](#middleware)
+    - [Guards](#guards)
+    - [Interceptors](#interceptors)
+    - [Exception Filters](#exception-filters)
+    - [Validation](#validation)
+    - [File Uploads](#file-uploads)
+    - [Streaming Responses](#streaming-responses)
+    - [Versioning](#versioning)
+    - [CORS](#cors)
+    - [Cookies](#cookies)
+    - [Popular Express Middleware](#popular-express-middleware)
+  - [Bun File API Support](#bun-file-api-support)
+    - [BunFileInterceptor](#bunfileinterceptor)
+  - [WebSocket Support](#websocket-support)
+    - [Basic WebSocket Gateway](#basic-websocket-gateway)
+    - [WebSocket with Guards](#websocket-with-guards)
+    - [WebSocket with Pipes](#websocket-with-pipes)
+    - [WebSocket with Exception Filters](#websocket-with-exception-filters)
+    - [Broadcasting Messages](#broadcasting-messages)
+    - [Secure WebSocket (WSS)](#secure-websocket-wss)
+    - [Limitations](#limitations)
+  - [HTTPS](#https)
+  - [Code Quality](#code-quality)
+- [Request / Response Objects](#request--response-objects)
+  - [BunRequest](#bunrequest)
+  - [BunResponse](#bunresponse)
+- [Benchmark Results](#benchmark-results)
+  - [HTTP Benchmark](#http-benchmark)
+  - [WebSocket Benchmark](#websocket-benchmark)
+  - [Running HTTP Benchmark](#running-http-benchmark)
+  - [Running WebSocket Benchmark](#running-websocket-benchmark)
+- [Contributing](#contributing)
+- [Future Plans](#future-plans)
+- [License](#license)
+
 ## Features
 
 ### Native Bun adapter for NestJS
@@ -442,6 +483,343 @@ Tested and working with:
 - `cors` - CORS handling
 - And most other Express-compatible middleware
 
+### WebSocket Support
+
+The Bun adapter provides full WebSocket support using Bun's native WebSocket implementation. The `BunWsAdapter` enables real-time, bidirectional communication between clients and servers with excellent performance.
+
+#### Basic WebSocket Gateway
+
+Create WebSocket gateways using NestJS decorators:
+
+```ts
+import { BunWsAdapter, BunAdapter } from "@krisanalfa/bunest-adapter";
+import {
+  WebSocketGateway,
+  SubscribeMessage,
+  MessageBody,
+  OnGatewayConnection,
+  OnGatewayDisconnect,
+  ConnectedSocket,
+} from "@nestjs/websockets";
+import { ServerWebSocket } from "bun";
+
+@WebSocketGateway({ cors: true })
+class ChatGateway implements OnGatewayConnection, OnGatewayDisconnect {
+  handleConnection(client: ServerWebSocket) {
+    client.send(JSON.stringify({ event: "welcome", data: "Welcome!" }));
+  }
+
+  handleDisconnect(client: ServerWebSocket) {
+    console.log("Client disconnected");
+  }
+
+  @SubscribeMessage("message")
+  handleMessage(@MessageBody() data: string) {
+    return {
+      event: "message",
+      data: `Received: ${data}`,
+    };
+  }
+}
+
+// Enable WebSocket support in your application
+const app = await NestFactory.create(AppModule, new BunAdapter());
+app.useWebSocketAdapter(new BunWsAdapter(app));
+await app.listen(3000);
+```
+
+Connect from the client:
+
+```ts
+const socket = new WebSocket("ws://localhost:3000");
+
+socket.onopen = () => {
+  socket.send(JSON.stringify({ event: "message", data: "Hello!" }));
+};
+
+socket.onmessage = (event) => {
+  const data = JSON.parse(event.data);
+  console.log(data); // { event: 'message', data: 'Received: Hello!' }
+};
+```
+
+#### WebSocket with Guards
+
+Protect WebSocket endpoints with guards:
+
+```ts
+import { CanActivate, ExecutionContext, Injectable } from "@nestjs/common";
+import { WsException } from "@nestjs/websockets";
+
+@Injectable()
+class WsAuthGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const data = context.switchToWs().getData<{ token?: string }>();
+
+    if (data.token !== "valid-token") {
+      throw new WsException("Unauthorized");
+    }
+
+    return true;
+  }
+}
+
+@WebSocketGateway()
+@UseGuards(WsAuthGuard)
+class ProtectedGateway {
+  @SubscribeMessage("protected")
+  handleProtected(@MessageBody() data: { message: string }) {
+    return {
+      event: "protected",
+      data: `Protected message: ${data.message}`,
+    };
+  }
+}
+```
+
+#### WebSocket with Pipes
+
+Validate WebSocket messages using pipes:
+
+```ts
+import { UsePipes, ValidationPipe } from "@nestjs/common";
+import { IsString, IsNotEmpty, MinLength } from "class-validator";
+
+class CreateMessageDto {
+  @IsString()
+  @IsNotEmpty()
+  @MinLength(3)
+  text!: string;
+}
+
+@WebSocketGateway()
+@UsePipes(
+  new ValidationPipe({
+    exceptionFactory: (errors) => new WsException(errors),
+  }),
+)
+class ValidationGateway {
+  @SubscribeMessage("createMessage")
+  handleCreateMessage(@MessageBody() dto: CreateMessageDto) {
+    return {
+      event: "messageCreated",
+      data: dto.text,
+    };
+  }
+}
+```
+
+#### WebSocket with Exception Filters
+
+Handle WebSocket exceptions with custom filters:
+
+```ts
+import { Catch, ArgumentsHost, WsExceptionFilter } from "@nestjs/common";
+import { WsException } from "@nestjs/websockets";
+import { ServerWebSocket } from "bun";
+
+@Catch(WsException)
+class WsExceptionsFilter implements WsExceptionFilter {
+  catch(exception: WsException, host: ArgumentsHost) {
+    const client = host.switchToWs().getClient<ServerWebSocket>();
+    const error = exception.getError();
+    const details = typeof error === "object" ? error : { message: error };
+
+    client.send(
+      JSON.stringify({
+        event: "error",
+        data: {
+          message: "An error occurred",
+          details,
+        },
+      }),
+    );
+  }
+}
+
+@WebSocketGateway()
+@UseFilters(WsExceptionsFilter)
+class ErrorHandlingGateway {
+  @SubscribeMessage("risky")
+  handleRisky(@MessageBody() data: { shouldFail: boolean }) {
+    if (data.shouldFail) {
+      throw new WsException("Something went wrong");
+    }
+    return { event: "success", data: "OK" };
+  }
+}
+```
+
+#### Broadcasting Messages
+
+Broadcast messages to all connected clients using Bun's publish/subscribe system:
+
+```ts
+import {
+  WebSocketGateway,
+  WebSocketServer,
+  SubscribeMessage,
+  MessageBody,
+  ConnectedSocket,
+  OnGatewayConnection,
+} from "@nestjs/websockets";
+import { ServerWebSocket } from "bun";
+import { BunPreflightHttpServer } from "@krisanalfa/bunest-adapter";
+
+@Injectable() // Mandatory to be able to inject `BunPreflightHttpServer`
+@WebSocketGateway()
+class BroadcastGateway implements OnGatewayConnection {
+  @WebSocketServer()
+  server!: BunPreflightHttpServer; // Inject BunPreflightHttpServer
+
+  private readonly roomName = "global-room";
+
+  handleConnection(client: ServerWebSocket) {
+    // Subscribe client to room
+    client.subscribe(this.roomName);
+  }
+
+  @SubscribeMessage("broadcast")
+  handleBroadcast(
+    @MessageBody() message: string,
+    @ConnectedSocket() socket: ServerWebSocket,
+  ) {
+    // Get subscriber count
+    const count = this.server.getBunServer().subscriberCount(this.roomName);
+
+    // Publish to all subscribers in the room
+    socket.publishText(
+      this.roomName,
+      JSON.stringify({
+        event: "broadcast",
+        data: message,
+        subscribers: count,
+      }),
+    );
+  }
+}
+```
+
+**Key Features:**
+
+- **Native Performance** - Uses Bun's native WebSocket implementation for maximum speed
+- **NestJS Integration** - Full support for decorators, guards, pipes, and exception filters
+- **Pub/Sub Support** - Built-in support for broadcasting messages to multiple clients
+- **CORS Configuration** - Easy CORS setup for WebSocket connections
+- **HTTP + WebSocket** - Run both HTTP and WebSocket servers on the same port
+
+#### Secure WebSocket (WSS)
+
+The Bun adapter supports secure WebSocket connections (WSS) using TLS/SSL certificates. You can configure WSS in two ways:
+
+**Using BunAdapter constructor options:**
+
+```ts
+import { BunAdapter, BunWsAdapter } from "@krisanalfa/bunest-adapter";
+import { NestFactory } from "@nestjs/core";
+
+const app = await NestFactory.create(
+  AppModule,
+  new BunAdapter({
+    tls: {
+      cert: Bun.file("/path/to/cert.pem"),
+      key: Bun.file("/path/to/key.pem"),
+    },
+  }),
+);
+
+app.useWebSocketAdapter(new BunWsAdapter(app));
+await app.listen(3000);
+
+// Clients connect using wss:// protocol
+// const ws = new WebSocket('wss://localhost:3000');
+```
+
+**Using NestFactory.create httpsOptions:**
+
+```ts
+import { BunAdapter, BunWsAdapter } from "@krisanalfa/bunest-adapter";
+import { NestFactory } from "@nestjs/core";
+
+const app = await NestFactory.create(AppModule, new BunAdapter(), {
+  httpsOptions: {
+    cert: Bun.file("/path/to/cert.pem"),
+    key: Bun.file("/path/to/key.pem"),
+  },
+});
+
+app.useWebSocketAdapter(new BunWsAdapter(app));
+await app.listen(3000);
+```
+
+**Unix Socket Support with WSS:**
+
+You can also run secure WebSocket servers over Unix sockets:
+
+```ts
+import { BunAdapter, BunWsAdapter } from "@krisanalfa/bunest-adapter";
+import { NestFactory } from "@nestjs/core";
+
+const app = await NestFactory.create(
+  AppModule,
+  new BunAdapter({
+    tls: {
+      cert: Bun.file("/path/to/cert.pem"),
+      key: Bun.file("/path/to/key.pem"),
+    },
+  }),
+);
+
+app.useWebSocketAdapter(new BunWsAdapter(app));
+await app.listen("/tmp/secure-nestjs.sock");
+
+// Or use abstract namespace socket on Linux
+await app.listen("\0secure-nestjs-socket");
+```
+
+**Client Connection Example:**
+
+```ts
+// For development with self-signed certificates
+const ws = new WebSocket("wss://localhost:3000", {
+  tls: { rejectUnauthorized: false },
+});
+
+ws.onopen = () => {
+  console.log("Connected to secure WebSocket");
+  ws.send(JSON.stringify({ event: "message", data: "Hello WSS!" }));
+};
+
+ws.onmessage = (event) => {
+  const data = JSON.parse(event.data);
+  console.log("Received:", data);
+};
+```
+
+**Important Notes:**
+
+- WSS automatically uses the same port as your HTTPS server
+- The `wss://` protocol is used instead of `ws://` for secure connections
+- For production, use properly signed certificates from a trusted Certificate Authority
+- For development, you can use self-signed certificates with `rejectUnauthorized: false` on the client
+
+#### Limitations
+
+**Port Configuration:** The WebSocket server port will always be the same as the Bun HTTP server port. In standard NestJS, you can configure different ports via the `@WebSocketGateway` decorator's `port` option (see [NestJS WebSocket documentation](https://docs.nestjs.com/websockets/gateways#overview)), but with the Bun adapter, WebSocket connections must use the same port as your HTTP server. This is due to Bun's unified server architecture where HTTP and WebSocket upgrades are handled by the same server instance.
+
+```ts
+// This port option is ignored with BunWsAdapter
+@WebSocketGateway({ port: 8080 }) // ⚠️ Port option has no effect
+class ChatGateway {
+  // Gateway will use the same port as app.listen()
+}
+
+// WebSocket will be available on the same port as HTTP
+const app = await NestFactory.create(AppModule, new BunAdapter());
+app.useWebSocketAdapter(new BunWsAdapter(app));
+await app.listen(3000); // Both HTTP and WebSocket use port 3000
+```
+
 ### Bun File API Support
 
 This package provides first-class support for Bun's native [`BunFile`](https://bun.com/docs/runtime/file-io) API, enabling seamless file uploads and downloads using Bun's efficient file handling capabilities.
@@ -550,7 +928,7 @@ The Bun adapter is developed with high code quality standards, including:
 - Strict TypeScript typings
 - Strict linting rules (ESLint)
 - Comprehensive unit and integration tests
-- Coverage reports (>98% line coverage, >85% function coverage)
+- Coverage reports (>97% line coverage, >85% function coverage)
 
 ## Request / Response Objects
 
@@ -562,10 +940,10 @@ A high-performance request wrapper that provides lazy parsing and caching for op
 
 #### Properties
 
-- **`url`** - The complete request URL
+- **`url`** - The URL path and query string (e.g., "/api/users?page=1"). For the full URL including protocol and host, use `original().url`
 - **`method`** - HTTP method (GET, POST, etc.)
 - **`pathname`** - URL path (lazily parsed)
-- **`hostname`** - Host name without port (lazily parsed)
+- **`hostname`** - Host name without port (lazily parsed, respects X-Forwarded-Host header)
 - **`query`** - Parsed query parameters (lazily parsed)
 - **`headers`** - Request headers object with `.get()` method (lazily materialized)
 - **`params`** - Route parameters from URL patterns
@@ -575,9 +953,11 @@ A high-performance request wrapper that provides lazy parsing and caching for op
 - **`files`** - Multiple uploaded files (for multi-file uploads)
 - **`signal`** - AbortSignal for request cancellation
 - **`cookies`** - Cookie map for accessing request cookies
+- **`socket`** - Mock socket object for Node.js compatibility (contains `encrypted` property)
 
 #### Methods
 
+- **`original()`** - Get the underlying native Bun request object
 - **`get(key)`** - Get custom property stored in request
 - **`set(key, value)`** - Set custom property in request (useful for middleware)
 - **`json()`** - Parse body as JSON
@@ -603,7 +983,10 @@ class UsersController {
     const auth = req.headers.get("authorization");
     const contentType = req.headers["content-type"];
 
-    return { page, limit, auth };
+    // Check if connection is secure
+    const isSecure = req.socket.encrypted;
+
+    return { page, limit, auth, isSecure };
   }
 
   @Post()
@@ -612,10 +995,14 @@ class UsersController {
     console.log(req.body); // Same as dto
 
     // Access request info
+    console.log(req.url); // "/users" (pathname + search)
     console.log(req.pathname); // "/users"
     console.log(req.hostname); // "localhost"
     console.log(req.method); // "POST"
 
+    // Access native request for full URL
+    console.log(req.original().url); // "http://localhost:3000/users"
+
     return { created: dto };
   }
 
@@ -658,7 +1045,7 @@ class ApiController {
 
 ### BunResponse
 
-A high-performance response builder that provides methods to construct responses with headers, cookies, and various body types. Uses lazy initialization and optimized response building for maximum performance.
+A high-performance response builder that provides methods to construct responses with headers, cookies, and various body types. Uses lazy initialization and optimized response building for maximum performance. Includes Node.js compatibility methods for seamless integration with existing middleware.
 
 #### Methods
 
@@ -673,10 +1060,22 @@ A high-performance response builder that provides methods to construct responses
 - **`deleteCookie(name)`** - Delete a cookie by name
 - **`deleteCookie(options)`** - Delete a cookie with path/domain options
 - **`redirect(url, statusCode?)`** - Send redirect response (default 302)
-- **`end(body?)`** - End response and send body (auto-handles JSON, streams, binary, or even [`BunFile`](https://bun.com/docs/runtime/file-io))
+- **`write(chunk)`** - Write data to response stream (Node.js compatibility). Chunks are accumulated until `end()` is called
+- **`writeHead(statusCode, headers?)`** - Write status and headers (Node.js compatibility)
+- **`end(body?)`** - End response and send body. Auto-handles JSON, streams, binary, [`BunFile`](https://bun.com/docs/runtime/file-io), and accumulated chunks from `write()` calls
 - **`res()`** - Get the native Response promise
 - **`isEnded()`** - Check if response has been ended
 
+#### Node.js Compatibility Properties
+
+For compatibility with Node.js HTTP response objects and EventEmitter-based middleware:
+
+- **`destroyed`** - Always returns `false` (read-only property)
+- **`on(event, listener)`** - No-op stub for EventEmitter compatibility
+- **`off(event, listener)`** - No-op stub for EventEmitter compatibility
+- **`once(event, listener)`** - No-op stub for EventEmitter compatibility
+- **`destroy(error?)`** - No-op stub for Node.js compatibility
+
 #### Usage Examples
 
 **Setting status and headers:**
@@ -773,6 +1172,23 @@ class FilesController {
   sendBinary(@Res() res: BunResponse) {
     const buffer = new Uint8Array([1, 2, 3, 4, 5]);
     res.setHeader("Content-Type", "application/octet-stream");
+
+  @Get("chunked")
+  sendChunked(@Res() res: BunResponse) {
+    // Node.js-style chunked response
+    res.writeHead(200, { "Content-Type": "text/plain" });
+    res.write("Hello ");
+    res.write("World");
+    res.end("!"); // Sends "Hello World!"
+  }
+
+  @Get("mixed-chunks")
+  sendMixedChunks(@Res() res: BunResponse) {
+    // Mix of strings and binary data
+    res.write("Status: ");
+    res.write(new Uint8Array([50, 48, 48])); // "200" in bytes
+    res.end(); // Chunks are combined and sent
+  }
     res.end(buffer);
   }
 
@@ -815,38 +1231,85 @@ class HybridController {
 
 ## Benchmark Results
 
-Tested on MacOS Sequoia (15.6.1), Apple M1 Max (64GB RAM), Bun 1.3.5, Node.js 20.10.0
+Tested on MacOS Sequoia (15.6.1), Apple M1 Max (64GB RAM), Bun 1.3.5, Node.js 20.10.0.
+
+### HTTP Benchmark
+
+HTTP benchmarks run using [`oha`](https://github.com/hatoo/oha) tool with the following command:
+
+```
+oha -c 125 -n 1000000 --no-tui "http://127.0.0.1:3000/"
+```
 
 | Configuration                                                                     | Requests/sec | Compared to Pure Bun |
 | --------------------------------------------------------------------------------- | -----------: | -------------------: |
 | Pure Bun                                                                          |    80,742.72 |              100.00% |
-| Nest + Bun + Native Bun Adapter                                                   |    69,665.59 |               86.32% |
+| Nest + Bun + Native Bun Adapter                                                   |    70,234.76 |               86.98% |
 | Nest + Bun + Express Adapter                                                      |    43,375.97 |               53.72% |
 | Nest + Bun + [Hono Adapter](https://www.npmjs.com/package/@kiyasov/platform-hono) |    19,194.78 |               23.77% |
 | Nest + Node + Express                                                             |    14,019.88 |               17.36% |
 
 > **Pure Bun** is the fastest at **80,743 req/s**. **Nest + Bun + Native Bun Adapter** achieves **~86%** of Pure Bun's performance while providing full NestJS features, and is **~5x faster** than Nest + Node + Express. Compared to Bun with Express adapter, the native Bun adapter is **~1.6x faster**.
 
-### Running Benchmarks
+### WebSocket Benchmark
+
+WebSocket benchmarks run using the custom benchmark script in `benchmarks/ws.benchmark.ts`.
+
+| Configuration                      | Messages/sec | Compared to Pure Bun |
+| ---------------------------------- | -----------: | -------------------: |
+| Pure Bun WebSocket                 |   817,594.60 |              100.00% |
+| Nest + Bun + BunWsAdapter          |   764,962.70 |               93.56% |
+| Nest + Bun + WebSocketAdapter (ws) |   299,161.50 |               36.59% |
+
+> **Pure Bun WebSocket** achieves **817,595 msg/s**. **Nest + Bun + BunWsAdapter** achieves **~94%** of Pure Bun's performance, and is **~2.6x faster** than using the standard WebSocketAdapter with `ws` library.
+
+### Running HTTP Benchmark
 
 This project includes benchmark configurations in the `benchmarks` directory.
-To run the specific server benchmark, you can use predefined scripts in `package.json`. For example:
+To run the specific HTTP server benchmark, you can use predefined scripts in `package.json`:
 
 ```bash
 # Running native bun server benchmark
-bun run native
+bun run http:native
 
 # Running NestJS with Bun adapter benchmark
-bun run bun
+bun run http:bun
 
 # Running NestJS with Hono adapter benchmark
-bun run hono
+bun run http:hono
 
 # Running NestJS with Express adapter benchmark
-bun run express
+bun run http:express
 
 # Running NestJS with Node and Express benchmark
-bun run node
+bun run http:node
+```
+
+Then run the benchmark using [`oha`](https://github.com/hatoo/oha):
+
+```bash
+oha -c 125 -n 1000000 --no-tui "http://127.0.0.1:3000/"
+```
+
+### Running WebSocket Benchmark
+
+To run WebSocket benchmarks, first start the WebSocket server:
+
+```bash
+# Running native bun websocket benchmark
+bun run ws:native
+
+# Running NestJS with BunWsAdapter websocket benchmark
+bun run ws:bun
+
+# Running NestJS with WebSocketAdapter (ws) websocket benchmark
+bun run ws:ws
+```
+
+Then run the benchmark script:
+
+```bash
+bun benchmarks/ws.benchmark.ts
 ```
 
 All benchmarks use port `3000` by default. You can adjust the port in the respective benchmark files if needed.
@@ -857,9 +1320,9 @@ Contributions are welcome! Please open issues or submit pull requests for bug fi
 
 ## Future Plans
 
-- Support for WebSocket integration with Bun
 - Enhanced trusted proxy configuration for host header handling
 - Additional performance optimizations and benchmarks
+- Release automation via CI/CD pipelines
 
 ## License
 

package/dist/bun.adapter.d.ts

@@ -1,21 +1,30 @@
 import { CorsOptions, CorsOptionsDelegate } from '@nestjs/common/interfaces/external/cors-options.interface.js';
 import { ErrorHandler, RequestHandler } from '@nestjs/common/interfaces/index.js';
+import { Server } from 'bun';
 import { NestApplicationOptions, RequestMethod, VersioningOptions } from '@nestjs/common';
-import { Serve, Server } from 'bun';
 import { AbstractHttpAdapter } from '@nestjs/core';
 import { VersionValue } from '@nestjs/common/interfaces/version-options.interface.js';
+import { ServerOptions } from './internal.types.js';
+import { BunPreflightHttpServer } from './bun.preflight-http-server.js';
 import { BunRequest } from './bun.request.js';
 import { BunResponse } from './bun.response.js';
 export declare class BunAdapter extends AbstractHttpAdapter<Server<unknown>, BunRequest, BunResponse> {
-    private bunServeOptions;
+    protected bunServeOptions: ServerOptions;
     private readonly logger;
     private readonly middlewareEngine;
     private useVersioning;
     private readonly routes;
     private readonly routeHandlers;
     private notFoundHandler;
-    constructor(bunServeOptions?: Pick<Serve.Options<unknown>, 'development' | 'maxRequestBodySize' | 'idleTimeout' | 'id' | 'tls'>);
+    private readonly wsHandlers;
+    private readonly wsMiddlewareEngine;
+    private wsOptions;
+    private useWs;
+    private useWsCors;
+    private wsCorsHeaders?;
+    constructor(bunServeOptions?: ServerOptions);
     use(middleware: RequestHandler<BunRequest, BunResponse>): void;
+    private createHttpMethodHandler;
     get(handler: RequestHandler<BunRequest, BunResponse>): void;
     get(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
     post(handler: RequestHandler<BunRequest, BunResponse>): void;
@@ -30,6 +39,7 @@ export declare class BunAdapter extends AbstractHttpAdapter<Server<unknown>, Bun
     head(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
     options(handler: RequestHandler<BunRequest, BunResponse>): void;
     options(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
+    private createUnsupportedMethod;
     all(handler: RequestHandler<BunRequest, BunResponse>): void;
     all(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
     propfind(handler: RequestHandler<BunRequest, BunResponse>): void;
@@ -52,7 +62,7 @@ export declare class BunAdapter extends AbstractHttpAdapter<Server<unknown>, Bun
     setViewEngine(engine: string): void;
     render(response: unknown, view: string, options: unknown): void;
     close(): Promise<void>;
-    initHttpServer(options: NestApplicationOptions): void;
+    initHttpServer(options: NestApplicationOptions): BunPreflightHttpServer;
     getRequestHostname(request: BunRequest): string;
     getRequestMethod(request: BunRequest): string;
     getRequestUrl(request: BunRequest): string;
@@ -84,7 +94,17 @@ export declare class BunAdapter extends AbstractHttpAdapter<Server<unknown>, Bun
      * @param callback Optional callback to invoke once the server is listening.
      */
     listen(port: string | number, hostname: string, callback?: () => void): void;
+    private static isNumericPort;
+    private static omitKeys;
+    private isWebSocketUpgradeRequest;
+    private handleWebSocketCors;
+    private upgradeWebSocket;
+    private setupWebSocketIfNeeded;
+    private createServer;
     private delegateRouteHandler;
+    private ensureRouteExists;
+    private prepareRequestHandler;
+    private createRouteFetchHandler;
     private createVersioningHandlers;
     private executeHandlerChain;
     private createChainedHandlerForVersioningResolution;