@krisanalfa/bunest-adapter 0.1.0 → 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
 
@@ -853,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.
@@ -895,7 +1320,6 @@ 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

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;

package/dist/bun.preflight-http-server.d.ts

@@ -0,0 +1,62 @@
+import { Server, ServerWebSocket } from 'bun';
+import { BaseWsInstance } from '@nestjs/websockets';
+import { ServerOptions, WsOptions } from './internal.types.js';
+interface BunHttpAdapter {
+    setWsOptions(options: WsOptions): void;
+    getBunHttpServerInstance(): Server<unknown>;
+    getWsHandlers(): {
+        onOpen: ((ws: ServerWebSocket<unknown>) => void) | undefined;
+        onMessage: ((ws: ServerWebSocket<unknown>, message: string | ArrayBuffer | Buffer | Buffer[], server: Server<unknown>) => void) | undefined;
+        onClose: ((ws: ServerWebSocket<unknown>, code: number, reason: string) => void) | undefined;
+    };
+    getBunServerOptions(): Pick<ServerOptions, 'port' | 'hostname'>;
+}
+/**
+ * Bun HTTP server placeholder used before the actual server instance is created.
+ * This class provides compatibility methods expected by NestJS framework.
+ *
+ * There's limitation in Bun where we can't create the server instance without
+ * listening on a port right away. This placeholder allows us to defer
+ * the server creation until NestJS calls the listen method.
+ */
+export declare class BunPreflightHttpServer implements BaseWsInstance {
+    private readonly adapter;
+    constructor(adapter: BunHttpAdapter);
+    on(event: string, callback: Function): void;
+    /**
+     * NestJS compatibility methods
+     * Nest use this to listen for "error" events during HTTP server initialization
+     */
+    once(): void;
+    /**
+     * NestJS compatibility methods
+     * Nest use this to remove "error" event listeners during HTTP server cleanup
+     */
+    removeListener(): void;
+    /**
+     * NestJS compatibility methods
+     */
+    stop(force?: boolean): Promise<void>;
+    address(): {
+        address: "0.0.0.0" | "127.0.0.1" | "localhost" | (string & {});
+        port: string | number;
+    } | {
+        address: string | undefined;
+        port: number | undefined;
+    };
+    setWsOptions(options: WsOptions): void;
+    registerWsOpenHandler(handler: (ws: ServerWebSocket<unknown>) => void): void;
+    registerWsMessageHandler(handler: (ws: ServerWebSocket<unknown>, message: string | ArrayBuffer | Buffer | Buffer[], server: Server<unknown>) => void): void;
+    registerWsCloseHandler(handler: (ws: ServerWebSocket<unknown>, code: number, reason: string) => void): void;
+    getWsHandlers(): {
+        onOpen: ((ws: ServerWebSocket<unknown>) => void) | undefined;
+        onMessage: ((ws: ServerWebSocket<unknown>, message: string | ArrayBuffer | Buffer | Buffer[], server: Server<unknown>) => void) | undefined;
+        onClose: ((ws: ServerWebSocket<unknown>, code: number, reason: string) => void) | undefined;
+    };
+    getBunServer(): Server<unknown>;
+    /**
+     * Proxy method for WebSocket server close
+     */
+    close(): Promise<void>;
+}
+export {};

package/dist/bun.ws-adapter.d.ts

@@ -0,0 +1,48 @@
+import { AbstractWsAdapter, BaseWsInstance, MessageMappingProperties } from '@nestjs/websockets';
+import { Observable } from 'rxjs';
+import { INestApplicationContext } from '@nestjs/common';
+import { ServerWebSocket } from 'bun';
+import { BunPreflightHttpServer } from './bun.preflight-http-server.js';
+import { WsOptions } from './internal.types.js';
+export type WsData = string | Buffer | ArrayBuffer | Buffer[];
+export type WsMessageParser<TData = unknown> = (data: WsData) => WsParsedData<TData>;
+export interface WsParsedData<TData = unknown> {
+    event: string;
+    data: TData;
+}
+export interface BunWsAdapterOptions extends WsOptions {
+    messageParser?: WsMessageParser;
+}
+/** Internal data stored on each WebSocket connection - must match bun.adapter.ts */
+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;
+}
+type BunWsClient = ServerWebSocket<BunWsClientData> & BaseWsInstance;
+/**
+ * High-performance WebSocket adapter for Bun runtime with NestJS.
+ */
+export declare class BunWsAdapter extends AbstractWsAdapter<BunPreflightHttpServer, BunWsClient> {
+    private readonly logger;
+    private readonly nestApp;
+    private messageParser;
+    private onOpenHandler?;
+    private globalHandlersInitialized;
+    constructor(appOrHttpServer?: INestApplicationContext | object);
+    create(_port: number, options?: BunWsAdapterOptions): BunPreflightHttpServer;
+    private extractWsOptions;
+    close(server: BunPreflightHttpServer): Promise<void>;
+    bindClientConnect(server: BunPreflightHttpServer, callback: (client: BunWsClient) => void): void;
+    bindClientDisconnect(client: BunWsClient, callback: (client: BunWsClient) => void): void;
+    bindMessageHandlers(client: BunWsClient, handlers: MessageMappingProperties[], transform: (data: unknown) => Observable<unknown>): void;
+    private initializeGlobalHandlers;
+    private buildHandlerMap;
+    private processMessage;
+    private sendResponse;
+    private cleanupClient;
+}
+export {};

package/dist/index.d.ts

@@ -1,4 +1,7 @@
-export { BunAdapter } from './bun.adapter.js';
-export { BunRequest } from './bun.request.js';
-export { BunResponse } from './bun.response.js';
-export { BunFileInterceptor } from './bun.file.interceptor.js';
+export * from './bun.adapter.js';
+export * from './bun.request.js';
+export * from './bun.response.js';
+export * from './bun.file.interceptor.js';
+export * from './internal.types.js';
+export * from './bun.preflight-http-server.js';
+export * from './bun.ws-adapter.js';