@krisanalfa/bunest-adapter 0.3.0 → 0.4.0

package/README.md

@@ -15,6 +15,7 @@ This project provides a native Bun adapter for NestJS, allowing developers to le
     - [Validation](#validation)
     - [File Uploads](#file-uploads)
     - [Streaming Responses](#streaming-responses)
+    - [Server-Sent Events (SSE)](#server-sent-events-sse)
     - [Versioning](#versioning)
     - [CORS](#cors)
     - [Cookies](#cookies)
@@ -375,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):
@@ -1251,6 +1313,23 @@ oha -c 125 -n 1000000 --no-tui "http://127.0.0.1:3000/"
 
 > **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**.
 
+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`.
@@ -1321,7 +1400,7 @@ Contributions are welcome! Please open issues or submit pull requests for bug fi
 ## Future Plans
 
 - 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,63 +1,19 @@
 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 { 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 { 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> {
-    protected bunServeOptions: ServerOptions;
+    protected bunServeOptions: ServerOptions<BunWsClientData>;
     private readonly logger;
-    private readonly middlewareEngine;
-    private useVersioning;
-    private readonly routes;
-    private readonly routeHandlers;
-    private notFoundHandler;
-    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;
-    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;
-    private createUnsupportedMethod;
-    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;
@@ -94,20 +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 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;
-    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;
+}

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

@@ -1,16 +1,7 @@
 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'>;
-}
+import { WsData, WsOptions } from './bun.internal.types.js';
+import { BunServerInstance } from './bun.server-instance.js';
 /**
  * Bun HTTP server placeholder used before the actual server instance is created.
  * This class provides compatibility methods expected by NestJS framework.
@@ -20,8 +11,8 @@ interface BunHttpAdapter {
  * the server creation until NestJS calls the listen method.
  */
 export declare class BunPreflightHttpServer implements BaseWsInstance {
-    private readonly adapter;
-    constructor(adapter: BunHttpAdapter);
+    private readonly serverInstance;
+    constructor(serverInstance: BunServerInstance);
     on(event: string, callback: Function): void;
     /**
      * NestJS compatibility methods
@@ -38,25 +29,16 @@ export declare class BunPreflightHttpServer implements BaseWsInstance {
      */
     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;
+        address: string;
+        port: number;
     };
     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;
+    registerWsMessageHandler(handler: (ws: ServerWebSocket<unknown>, message: WsData, 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>;
+    getBunServer(): Server<unknown> | null;
     /**
      * Proxy method for WebSocket server close
      */
     close(): Promise<void>;
 }
-export {};

package/dist/bun.request.d.ts

@@ -39,6 +39,9 @@ export declare class BunRequest {
      */
     get socket(): {
         encrypted: boolean;
+        setKeepAlive: () => void;
+        setNoDelay: () => void;
+        setTimeout: () => void;
     };
     /**
      * Gets the URL path and query string of the request.
@@ -235,7 +238,7 @@ export declare class BunRequest {
      * console.log(user); // { id: 1, name: 'John' }
      * ```
      */
-    get(key: string): unknown;
+    get<T>(key: string): T | undefined;
     /**
      * Sets a custom setting/property in the request.
      * Useful for passing data between middleware and handlers.
@@ -358,5 +361,42 @@ export declare class BunRequest {
      * ```
      */
     clone(): BunRequest;
+    /**
+     * Stub method for Node.js EventEmitter compatibility.
+     * This is a no-op method provided for compatibility with Node.js HTTP request objects.
+     * Required for SSE and other streaming scenarios where NestJS listens for request events.
+     *
+     * @param event - The event name
+     * @param listener - The event listener function
+     * @returns This request object for chaining
+     */
+    on(event: string, listener: (...args: unknown[]) => void): this;
+    /**
+     * Stub method for Node.js EventEmitter compatibility.
+     * This is a no-op method provided for compatibility with Node.js HTTP request objects.
+     *
+     * @param event - The event name
+     * @param listener - The event listener function
+     * @returns This request object for chaining
+     */
+    once(event: string, listener: (...args: unknown[]) => void): this;
+    /**
+     * Stub method for Node.js EventEmitter compatibility.
+     * This is a no-op method provided for compatibility with Node.js HTTP request objects.
+     *
+     * @param event - The event name
+     * @param listener - The event listener function
+     * @returns This request object for chaining
+     */
+    off(event: string, listener: (...args: unknown[]) => void): this;
+    /**
+     * Stub method for Node.js EventEmitter compatibility.
+     * This is a no-op method provided for compatibility with Node.js HTTP request objects.
+     *
+     * @param event - The event name
+     * @param args - Event arguments
+     * @returns True to indicate the event was handled
+     */
+    emit(event: string, ...args: unknown[]): boolean;
 }
 export {};

package/dist/bun.response.d.ts

@@ -18,11 +18,18 @@ export declare class BunResponse {
     private readonly response;
     private readonly cookieMap;
     private static readonly textDecoder;
+    /**
+     * Property for Node.js Writable stream compatibility.
+     * Indicates this object can be written to.
+     */
+    readonly writable = true;
     private headers;
     private statusCode;
     private ended;
     private cookieHeaders;
     private chunks;
+    private streamWriter;
+    private textEncoder;
     constructor();
     private get headersMap();
     /**
@@ -205,6 +212,21 @@ export declare class BunResponse {
      * @returns This response object for chaining
      */
     once(event: string, listener: (...args: unknown[]) => void): this;
+    /**
+     * Stub method for Node.js EventEmitter compatibility.
+     * This is a no-op method provided for compatibility with Node.js streams and HTTP response objects.
+     * Required when streams are piped to the response object (e.g., for SSE).
+     *
+     * @param event - The event name
+     * @param args - Event arguments
+     * @returns True to indicate the event was handled
+     */
+    emit(event: string, ...args: unknown[]): boolean;
+    /**
+     * Property for Node.js Writable stream compatibility.
+     * Indicates whether the stream has ended.
+     */
+    get writableEnded(): boolean;
     /**
      * Stub method for Node.js HTTP response compatibility.
      * This method writes data to the response stream.
@@ -234,6 +256,12 @@ export declare class BunResponse {
      * ```
      */
     write(chunk: unknown): boolean;
+    /**
+     * Initializes streaming mode by creating a TransformStream and resolving the response.
+     * This is used for SSE and other streaming scenarios where data needs to be sent
+     * before end() is called.
+     */
+    private initializeStreamingMode;
     /**
      * Gets the value of a response header.
      * Header lookup is case-insensitive.

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

@@ -0,0 +1,131 @@
+import { CorsOptions, CorsOptionsDelegate } from '@nestjs/common/interfaces/external/cors-options.interface.js';
+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 { BunMiddlewareEngine } from './bun.middleware-engine.js';
+import { BunRequest } from './bun.request.js';
+import { BunResponse } from './bun.response.js';
+/**
+ * BunServerInstance is the actual server instance that handles route registrations,
+ * WebSocket functionalities, and the listen method. This class is passed to
+ * AbstractHttpAdapter.setInstance() and implements the methods that NestJS expects
+ * from an HTTP server instance (similar to Express app or Fastify instance).
+ */
+export declare class BunServerInstance {
+    private readonly bunServeOptions;
+    private readonly logger;
+    private readonly middlewareEngine;
+    private useVersioning;
+    private readonly routes;
+    private readonly routeHandlers;
+    private notFoundHandler;
+    private readonly wsHandlers;
+    private readonly wsMiddlewareEngine;
+    private wsOptions;
+    private useWs;
+    private useWsCors;
+    private httpServer;
+    constructor(bunServeOptions: ServerOptions<BunWsClientData>);
+    use(maybePath: string | RequestHandler<BunRequest, BunResponse>, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    private createHttpMethodHandler;
+    get(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    post(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    put(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    patch(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    delete(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    head(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    options(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    private createUnsupportedMethod;
+    all(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    propfind(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    proppatch(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    mkcol(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    copy(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    move(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    lock(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    unlock(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    search(pathOrHandler: unknown, maybeHandler?: RequestHandler<BunRequest, BunResponse>): void;
+    /**
+     * Start listening on the specified port and hostname.
+     * @param port The port number or Unix socket path to listen on.
+     * @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>;
+    /**
+     * NestJS compatibility methods - stop the server
+     */
+    stop(force?: boolean): Promise<void>;
+    /**
+     * Get the address of the server
+     */
+    address(): {
+        address: string;
+        port: number;
+    };
+    /**
+     * Set WebSocket options
+     */
+    setWsOptions(options: WsOptions): void;
+    /**
+     * Register WebSocket open handler
+     */
+    registerWsOpenHandler(handler: (ws: ServerWebSocket<unknown>) => void): void;
+    /**
+     * Register WebSocket message handler
+     */
+    registerWsMessageHandler(handler: (ws: ServerWebSocket<unknown>, message: WsData, server: Server<unknown>) => void): void;
+    /**
+     * Register WebSocket close handler
+     */
+    registerWsCloseHandler(handler: (ws: ServerWebSocket<unknown>, code: number, reason: string) => void): void;
+    /**
+     * Get the underlying Bun server
+     */
+    getBunServer(): Server<unknown> | null;
+    /**
+     * Proxy method for WebSocket server close (BaseWsInstance)
+     */
+    close(): Promise<void>;
+    /**
+     * Get the middleware engine
+     */
+    getMiddlewareEngine(): BunMiddlewareEngine;
+    /**
+     * Set the not found handler
+     */
+    setNotFoundHandler(handler: RequestHandler<BunRequest, BunResponse>): void;
+    /**
+     * Enable versioning support
+     */
+    setUseVersioning(value: boolean): void;
+    /**
+     * Register body parser middleware
+     */
+    registerParserMiddleware(prefix?: string, rawBody?: boolean): void;
+    /**
+     * Create middleware factory for NestJS
+     */
+    createMiddlewareFactory(requestMethod: RequestMethod): (path: string, callback: Function) => void;
+    /**
+     * Enable CORS middleware
+     */
+    enableCors(corsOptions?: CorsOptions | CorsOptionsDelegate<BunRequest>, prefix?: string): void;
+    private static isNumericPort;
+    private static omitKeys;
+    private isWebSocketUpgradeRequest;
+    private provideCorsHeaders;
+    private upgradeWebSocket;
+    private setupWebSocketIfNeeded;
+    private createServer;
+    private delegateRouteHandler;
+    private ensureRouteExists;
+    private prepareRequestHandler;
+    private createRouteFetchHandler;
+    private createVersioningHandlers;
+    private executeHandlerChain;
+    private createChainedHandlerForVersioningResolution;
+    private mapRequestMethodToString;
+    private parseRouteHandler;
+}

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

@@ -2,9 +2,8 @@ import { AbstractWsAdapter, BaseWsInstance, MessageMappingProperties } from '@ne
 import { Observable } from 'rxjs';
 import { INestApplicationContext } from '@nestjs/common';
 import { ServerWebSocket } from 'bun';
+import { BunWsClientData, WsData, WsOptions } from './bun.internal.types.js';
 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;
@@ -13,15 +12,6 @@ export interface WsParsedData<TData = unknown> {
 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.

package/dist/index.d.ts

@@ -2,6 +2,7 @@ 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.internal.types.js';
 export * from './bun.preflight-http-server.js';
+export * from './bun.server-instance.js';
 export * from './bun.ws-adapter.js';