@krisanalfa/bunest-adapter 0.3.0 → 0.5.0

package/README.md

@@ -15,10 +15,12 @@ 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)
     - [Popular Express Middleware](#popular-express-middleware)
+    - [Static Assets](#static-assets)
   - [Bun File API Support](#bun-file-api-support)
     - [BunFileInterceptor](#bunfileinterceptor)
   - [WebSocket Support](#websocket-support)
@@ -50,7 +52,7 @@ This project provides a native Bun adapter for NestJS, allowing developers to le
 Easy to set up and use Bun as the underlying HTTP server for your NestJS applications.
 
 ```ts
-import { BunAdapter } from "@krisanalfa/bunest-adapter";
+import { BunAdapter, NestBunApplication } from "@krisanalfa/bunest-adapter";
 import { Logger } from "@nestjs/common";
 import { NestFactory } from "@nestjs/core";
 import { Server } from "bun";
@@ -58,10 +60,10 @@ import { Server } from "bun";
 import { AppModule } from "./app.module.js";
 
 async function main() {
-  const app = await NestFactory.create(AppModule, new BunAdapter());
+  const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter());
   await app.listen(3000);
-  const server = app.getHttpAdapter().getHttpServer() as Server<unknown>;
-  Logger.log(`Server started on ${server.url.toString()}`, "NestApplication");
+  const server = app.getHttpServer().getBunServer()
+  Logger.log(`Server started on ${server?.url.toString() ?? 'http://localhost:3000'}`, 'NestApplication')
 }
 
 await main();
@@ -375,6 +377,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):
@@ -433,7 +496,7 @@ app.enableCors((req: BunRequest, callback) => {
 You can also use NestJS's `CorsOptions` type for static configuration.
 
 ```ts
-const app = await NestFactory.create(AppModule, new BunAdapter(), {
+const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter(), {
   cors: {
     origin: "https://example.com",
     methods: ["GET", "POST", "PUT"],
@@ -473,7 +536,7 @@ Compatible with popular Express middleware:
 ```ts
 import helmet from "helmet";
 
-const app = await NestFactory.create(AppModule, new BunAdapter());
+const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter());
 app.use(helmet());
 ```
 
@@ -481,7 +544,65 @@ Tested and working with:
 
 - `helmet` - Security headers
 - `cors` - CORS handling
-- And most other Express-compatible middleware
+- `@thallesp/nestjs-better-auth` - `better-auth` middleware
+- `express-session` - Session management
+
+#### Static Assets
+
+Serve static files from your NestJS application using Bun's native file serving capabilities. The adapter supports two distinct modes:
+
+**File Routes (Default)** - Reads files from the filesystem on each request, supports range requests, respects middlewares, and provides full HTTP feature compatibility:
+
+```ts
+import { join } from 'path';
+
+const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter());
+
+// Serve static assets using file routes (default)
+app.useStaticAssets(join(__dirname, 'public'));
+
+// Or explicitly set useStatic to false
+app.useStaticAssets(join(__dirname, 'public'), { useStatic: false });
+
+await app.listen(3000);
+
+// Files in 'public' directory are now accessible:
+// public/index.html -> http://localhost:3000/index.html
+// public/css/style.css -> http://localhost:3000/css/style.css
+// public/images/logo.png -> http://localhost:3000/images/logo.png
+```
+
+> Note: Even if the file routes read the files from the filesystem on each request, you still need to make sure that Bun has access to the files right before you call `app.listen()`. The adapter reads the directory structure and prepares the routes at that time. If you need different behavior (e.g., dynamic files), consider using a custom controller to serve those files.
+
+**Static Routes** - Serves files directly from memory for maximum performance, but with some limitations (no range requests, doesn't respect middlewares):
+
+```ts
+import { join } from 'path';
+
+const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter());
+
+// Serve static assets using static routes (faster, but with limitations)
+app.useStaticAssets(join(__dirname, 'public'), { useStatic: true });
+
+await app.listen(3000);
+```
+
+**With CORS Support:**
+
+```ts
+const app = await NestFactory.create<NestBunApplication>(
+  AppModule,
+  new BunAdapter(),
+  { cors: true }
+);
+
+// Static assets will respect CORS settings when using file routes
+app.useStaticAssets(join(__dirname, 'public'), { useStatic: false });
+```
+
+**Choosing Between Modes:**
+
+For more details, see [Bun's documentation on file responses vs static responses](https://bun.sh/docs/runtime/http/routing#file-responses-vs-static-responses).
 
 ### WebSocket Support
 
@@ -523,7 +644,7 @@ class ChatGateway implements OnGatewayConnection, OnGatewayDisconnect {
 }
 
 // Enable WebSocket support in your application
-const app = await NestFactory.create(AppModule, new BunAdapter());
+const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter());
 app.useWebSocketAdapter(new BunWsAdapter(app));
 await app.listen(3000);
 ```
@@ -715,10 +836,10 @@ The Bun adapter supports secure WebSocket connections (WSS) using TLS/SSL certif
 **Using BunAdapter constructor options:**
 
 ```ts
-import { BunAdapter, BunWsAdapter } from "@krisanalfa/bunest-adapter";
+import { BunAdapter, BunWsAdapter, NestBunApplication } from "@krisanalfa/bunest-adapter";
 import { NestFactory } from "@nestjs/core";
 
-const app = await NestFactory.create(
+const app = await NestFactory.create<NestBunApplication>(
   AppModule,
   new BunAdapter({
     tls: {
@@ -738,10 +859,10 @@ await app.listen(3000);
 **Using NestFactory.create httpsOptions:**
 
 ```ts
-import { BunAdapter, BunWsAdapter } from "@krisanalfa/bunest-adapter";
+import { BunAdapter, BunWsAdapter, NestBunApplication } from "@krisanalfa/bunest-adapter";
 import { NestFactory } from "@nestjs/core";
 
-const app = await NestFactory.create(AppModule, new BunAdapter(), {
+const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter(), {
   httpsOptions: {
     cert: Bun.file("/path/to/cert.pem"),
     key: Bun.file("/path/to/key.pem"),
@@ -757,10 +878,10 @@ await app.listen(3000);
 You can also run secure WebSocket servers over Unix sockets:
 
 ```ts
-import { BunAdapter, BunWsAdapter } from "@krisanalfa/bunest-adapter";
+import { BunAdapter, BunWsAdapter, NestBunApplication } from "@krisanalfa/bunest-adapter";
 import { NestFactory } from "@nestjs/core";
 
-const app = await NestFactory.create(
+const app = await NestFactory.create<NestBunApplication>(
   AppModule,
   new BunAdapter({
     tls: {
@@ -815,7 +936,7 @@ class ChatGateway {
 }
 
 // WebSocket will be available on the same port as HTTP
-const app = await NestFactory.create(AppModule, new BunAdapter());
+const app = await NestFactory.create<NestBunApplication>(AppModule, new BunAdapter());
 app.useWebSocketAdapter(new BunWsAdapter(app));
 await app.listen(3000); // Both HTTP and WebSocket use port 3000
 ```
@@ -881,7 +1002,7 @@ You can run your NestJS application with HTTPS using two approaches:
 #### Using Bun's built-in HTTPS support (recommended)
 
 ```ts
-const app = await NestFactory.create(
+const app = await NestFactory.create<NestBunApplication>(
   AppModule,
   new BunAdapter({
     tls: {
@@ -895,7 +1016,7 @@ const app = await NestFactory.create(
 #### Using NestJS App Factory HTTPS options
 
 ```ts
-const app = await NestFactory.create(
+const app = await NestFactory.create<NestBunApplication>(
   AppModule,
   new BunAdapter(/* leave it empty */),
   {
@@ -1251,6 +1372,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 +1459,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,64 +1,20 @@
 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 { BunStaticAssetsOptions, BunWsClientData, ServerOptions } from './bun.internal.types.js';
 import { BunPreflightHttpServer } from './bun.preflight-http-server.js';
 import { BunRequest } from './bun.request.js';
 import { BunResponse } from './bun.response.js';
+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;
-    useStaticAssets(...args: unknown[]): void;
+    protected instance: BunServerInstance;
+    constructor(bunServeOptions?: ServerOptions<BunWsClientData>);
+    useStaticAssets(path: string, options?: BunStaticAssetsOptions): void;
     setViewEngine(engine: string): void;
     render(response: unknown, view: string, options: unknown): void;
     close(): Promise<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,53 @@
+import { CorsOptions, CorsOptionsDelegate } from '@nestjs/common/interfaces/external/cors-options.interface.js';
+import { Serve, Server, ServerWebSocket, WebSocketHandler } from 'bun';
+import { INestApplication } from '@nestjs/common';
+import { BunPreflightHttpServer } from './bun.preflight-http-server.js';
+import { BunRequest } from './bun.request.js';
+export interface WsOptions extends Pick<WebSocketHandler<unknown>, 'maxPayloadLength' | 'idleTimeout' | 'backpressureLimit' | 'closeOnBackpressureLimit' | 'sendPings' | 'publishToSelf' | 'perMessageDeflate'> {
+    cors?: true | CorsOptions | 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;
+}
+export interface BunStaticAssetsOptions {
+    /**
+     * Enable static assets serving.
+     *
+     * Bun has two distict modes for serving static assets:
+     * 1. Static routes
+     * 2. File routes
+     *
+     * If you set `useStatic: true`, Bun will use static routes for serving assets.
+     * This approach is generally faster for serving static files, as it serves
+     * files directly from memory. However, it comes with some limitations, such as
+     * lack of support for certain features like range requests and directory indexing.
+     * On top of that, static routes didn't respect middlewares due to Bun's internal design.
+     *
+     * On the other hand, if you set `useStatic: false` (the default behavior),
+     * Bun will use file routes, which read files from the filesystem on each request.
+     * This method supports a wider range of features, including range requests, and respects
+     * middlewares. However, it may be slightly slower than static routes due to
+     * filesystem access on each request.
+     *
+     * @see https://bun.com/docs/runtime/http/routing#file-responses-vs-static-responses
+     * @defaults false Use file routes by default.
+     */
+    useStatic?: boolean;
+}
+export interface NestBunApplication extends INestApplication<BunPreflightHttpServer> {
+    useStaticAssets(path: string, options?: BunStaticAssetsOptions): void;
+    enableCors(options?: CorsOptions | CorsOptionsDelegate<BunRequest>): void;
+}

package/dist/bun.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

@@ -3,6 +3,15 @@ import { ParsedQs } from 'qs';
 type HeadersProxy = Record<string, string> & {
     get: (key: string) => string | null;
 };
+interface Connection {
+    encrypted: boolean;
+}
+interface TcpSocket {
+    encrypted: boolean;
+    setKeepAlive: (enable?: boolean, initialDelay?: number) => void;
+    setNoDelay: (noDelay?: boolean) => void;
+    setTimeout: (timeout: number, callback?: () => void) => void;
+}
 /**
  * A high-performance request wrapper for Bun's native request object.
  * Provides lazy parsing and caching for optimal performance in NestJS applications.
@@ -26,20 +35,23 @@ export declare class BunRequest {
     private _file;
     private _files;
     private _settings;
-    private readonly _url;
+    private _connection;
+    private _socket;
+    private _url;
     private readonly _parsedUrl;
     readonly method: string;
     readonly params: Record<string, string>;
     constructor(nativeRequest: NativeRequest);
+    /**
+     * Gets a mock connection object for compatibility with Node.js middleware.
+     * Some middleware (like express-session) check req.connection.encrypted to determine if the connection is HTTPS.
+     */
+    get connection(): Connection;
     /**
      * Gets a mock socket object for compatibility with Node.js middleware.
      * Some middleware (like Better Auth) check req.socket.encrypted to determine if the connection is HTTPS.
-     *
-     * @returns A mock socket object with encrypted property
      */
-    get socket(): {
-        encrypted: boolean;
-    };
+    get socket(): TcpSocket;
     /**
      * Gets the URL path and query string of the request.
      * Returns the pathname + search params for Node.js/Express compatibility.
@@ -235,7 +247,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 +370,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.
@@ -345,6 +373,13 @@ export declare class BunResponse {
      * ```
      */
     isEnded(): boolean;
+    /**
+     * Stub method for Node.js HTTP response compatibility.
+     *
+     * The primary purpose of _implicitHeader() is to automatically generate and send the HTTP headers if a write operation (like `response.write()` or `response.end()`)
+     * is called without explicitly calling `response.writeHead()` first.
+     */
+    _implicitHeader(): void;
     private buildStreamableResponse;
     private buildJsonResponse;
     private createResponse;