@krisanalfa/bunest-adapter 0.1.0 → 0.4.0

package/README.md

@@ -2,6 +2,48 @@
 
 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)
+    - [Server-Sent Events (SSE)](#server-sent-events-sse)
+    - [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
@@ -334,6 +376,67 @@ class FilesController {
 }
 ```
 
+#### Server-Sent Events (SSE)
+
+Full support for [Server-Sent Events](https://docs.nestjs.com/techniques/server-sent-events) using the `@Sse()` decorator. SSE allows servers to push real-time updates to clients over HTTP:
+
+```ts
+import { Controller, Sse, MessageEvent } from '@nestjs/common';
+import { Observable, interval, map } from 'rxjs';
+
+@Controller()
+class EventsController {
+  @Sse('/sse')
+  sendEvents(): Observable<MessageEvent> {
+    return interval(1000).pipe(
+      map(num => ({
+        data: `SSE message ${num.toString()}`,
+      })),
+    );
+  }
+}
+```
+
+**Client Connection Example:**
+
+```ts
+const eventSource = new EventSource('http://localhost:3000/sse');
+
+eventSource.onopen = () => {
+  console.log('SSE connection opened');
+};
+
+eventSource.onmessage = (event) => {
+  console.log('Received:', event.data); // "SSE message 0", "SSE message 1", etc.
+};
+
+eventSource.onerror = (error) => {
+  console.error('SSE error:', error);
+  eventSource.close();
+};
+
+// Close the connection when done
+// eventSource.close();
+```
+
+**For HTTPS/Secure Connections:**
+
+```ts
+import { EventSource } from 'eventsource'; // npm package for Node.js
+
+const eventSource = new EventSource('https://localhost:3000/sse', {
+  fetch: (url, init) => fetch(url, {
+    ...init,
+    tls: { rejectUnauthorized: false }, // For self-signed certificates
+  }),
+});
+
+eventSource.onmessage = (event) => {
+  console.log('Received:', event.data);
+};
+```
+
+
 #### Versioning
 
 Full API [versioning](https://docs.nestjs.com/techniques/versioning) support (URI, Header, Media Type, Custom):
@@ -442,6 +545,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 +990,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
 
@@ -853,38 +1293,102 @@ 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
+Bonus if you use Unix sockets:
+```
+Summary:
+  Success rate:	100.00%
+  Total:	8298.2243 ms
+  Slowest:	5.2326 ms
+  Fastest:	0.2857 ms
+  Average:	1.0361 ms
+  Requests/sec:	120507.7092
+
+  Total data:	21.93 MiB
+  Size/request:	23 B
+  Size/sec:	2.64 MiB
+```
+
+As you can see, using Unix sockets boosts the performance further to **120,508 req/s**, which is **~1.5x faster** than TCP. Since Bun `fetch` supports Unix sockets, you can leverage this for inter-process communication on the same machine.
+
+### 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.
@@ -895,9 +1399,8 @@ 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
+- Improved documentation and examples
 - Release automation via CI/CD pipelines
 
 ## License

package/dist/bun.adapter.d.ts

@@ -1,58 +1,24 @@
 import { CorsOptions, CorsOptionsDelegate } from '@nestjs/common/interfaces/external/cors-options.interface.js';
 import { ErrorHandler, RequestHandler } from '@nestjs/common/interfaces/index.js';
 import { NestApplicationOptions, RequestMethod, VersioningOptions } from '@nestjs/common';
-import { Serve, Server } from 'bun';
+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 { BunPreflightHttpServer } from './bun.preflight-http-server.js';
 import { BunRequest } from './bun.request.js';
 import { BunResponse } from './bun.response.js';
+import { BunServerInstance } from './bun.server-instance.js';
 export declare class BunAdapter extends AbstractHttpAdapter<Server<unknown>, BunRequest, BunResponse> {
-    private bunServeOptions;
+    protected bunServeOptions: ServerOptions<BunWsClientData>;
     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'>);
-    use(middleware: RequestHandler<BunRequest, BunResponse>): void;
-    get(handler: RequestHandler<BunRequest, BunResponse>): void;
-    get(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
-    post(handler: RequestHandler<BunRequest, BunResponse>): void;
-    post(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
-    put(handler: RequestHandler<BunRequest, BunResponse>): void;
-    put(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
-    patch(handler: RequestHandler<BunRequest, BunResponse>): void;
-    patch(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
-    delete(handler: RequestHandler<BunRequest, BunResponse>): void;
-    delete(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
-    head(handler: RequestHandler<BunRequest, BunResponse>): void;
-    head(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
-    options(handler: RequestHandler<BunRequest, BunResponse>): void;
-    options(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
-    all(handler: RequestHandler<BunRequest, BunResponse>): void;
-    all(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
-    propfind(handler: RequestHandler<BunRequest, BunResponse>): void;
-    propfind(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
-    proppatch(handler: RequestHandler<BunRequest, BunResponse>): void;
-    proppatch(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
-    mkcol(handler: RequestHandler<BunRequest, BunResponse>): void;
-    mkcol(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
-    copy(handler: RequestHandler<BunRequest, BunResponse>): void;
-    copy(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
-    move(handler: RequestHandler<BunRequest, BunResponse>): void;
-    move(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
-    lock(handler: RequestHandler<BunRequest, BunResponse>): void;
-    lock(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
-    unlock(handler: RequestHandler<BunRequest, BunResponse>): void;
-    unlock(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
-    search(handler: RequestHandler<BunRequest, BunResponse>): void;
-    search(path: unknown, handler: RequestHandler<BunRequest, BunResponse>): void;
+    protected instance: BunServerInstance;
+    constructor(bunServeOptions?: ServerOptions<BunWsClientData>);
     useStaticAssets(...args: unknown[]): void;
     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,10 +50,5 @@ 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 delegateRouteHandler;
-    private createVersioningHandlers;
-    private executeHandlerChain;
-    private createChainedHandlerForVersioningResolution;
-    private mapRequestMethodToString;
-    private parseRouteHandler;
+    private configureTls;
 }

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

@@ -0,0 +1,22 @@
+import { CorsOptionsDelegate, CorsOptions as NestCorsOptions } from '@nestjs/common/interfaces/external/cors-options.interface.js';
+import { Serve, Server, ServerWebSocket, WebSocketHandler } from 'bun';
+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>;
+    clientDataFactory?: (req: BunRequest) => unknown;
+}
+export type ServerOptions<TWebSocketData = unknown> = Pick<Serve.Options<TWebSocketData>, 'development' | 'maxRequestBodySize' | 'idleTimeout' | 'id' | 'tls' | 'websocket' | 'port' | 'hostname'>;
+export type WsData = string | Buffer | ArrayBuffer | Buffer[];
+export interface WsHandlers {
+    onOpen: ((ws: ServerWebSocket<unknown>) => void) | undefined;
+    onMessage: ((ws: ServerWebSocket<unknown>, message: WsData, server: Server<unknown>) => void) | undefined;
+    onClose: ((ws: ServerWebSocket<unknown>, code: number, reason: string) => void) | undefined;
+}
+export interface BunWsClientData {
+    /** Called when a message is received - matches bun.adapter.ts onMessageInternal */
+    onMessageInternal?: (message: WsData) => void;
+    /** Called when the connection closes - matches bun.adapter.ts onCloseInternal */
+    onCloseInternal?: () => void;
+    /** Called by NestJS for disconnect handling */
+    onDisconnect?: (ws: ServerWebSocket<unknown>) => void;
+}