@krisanalfa/bunest-adapter 0.0.1 → 0.3.0

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.request.d.ts

@@ -32,15 +32,38 @@ export declare class BunRequest {
     readonly params: Record<string, string>;
     constructor(nativeRequest: NativeRequest);
     /**
-     * Gets the full URL of the request.
+     * 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 The complete URL string
+     * @returns A mock socket object with encrypted property
+     */
+    get socket(): {
+        encrypted: boolean;
+    };
+    /**
+     * Gets the URL path and query string of the request.
+     * Returns the pathname + search params for Node.js/Express compatibility.
+     * For the full URL including protocol and host, use the original() method to access the native request.
+     *
+     * @returns The URL path and query string (e.g., "/api/users?page=1")
      * @example
      * ```typescript
-     * const url = request.url; // "http://localhost:3000/api/users?page=1"
+     * const url = request.url; // "/api/users?page=1"
+     * // For full URL: request.original().url // "http://localhost:3000/api/users?page=1"
      * ```
      */
     get url(): string;
+    /**
+     * Gets the original native Bun request object.
+     *
+     * @returns The underlying Bun request
+     * @example
+     * ```typescript
+     * const nativeReq = request.original();
+     * console.log(nativeReq.url); // Full URL with protocol and host
+     * ```
+     */
+    original(): NativeRequest;
     /**
      * Gets the pathname portion of the URL.
      * Uses lazy parsing for optimal performance - the pathname is only extracted when first accessed.

package/dist/bun.response.d.ts

@@ -17,10 +17,12 @@ export declare class BunResponse {
     private resolve;
     private readonly response;
     private readonly cookieMap;
-    private _headers;
+    private static readonly textDecoder;
+    private headers;
     private statusCode;
     private ended;
-    private _cookieHeaderCache;
+    private cookieHeaders;
+    private chunks;
     constructor();
     private get headersMap();
     /**
@@ -99,6 +101,7 @@ export declare class BunResponse {
      * Ends the response and sends the body to the client.
      * Automatically handles JSON serialization, streams, and binary data.
      * Can only be called once per response.
+     * If write() was called before end(), accumulated chunks will be sent.
      *
      * @param body - The response body (JSON, string, Uint8Array, StreamableFile, or undefined)
      * @example
@@ -117,9 +120,24 @@ export declare class BunResponse {
      * // Send file stream
      * const file = new StreamableFile(stream);
      * response.end(file);
+     *
+     * // Send accumulated chunks from write() calls
+     * response.write('Hello ');
+     * response.write('World');
+     * response.end('!'); // Sends "Hello World!"
      * ```
      */
     end(body?: unknown): void;
+    /**
+     * Applies cookie headers to the response.
+     * According to RFC 6265, each cookie must be sent as a separate Set-Cookie header.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie
+     */
+    private applyCookieHeaders;
+    private sendResponse;
+    private combineChunks;
+    private combineAsString;
+    private combineAsBinary;
     /**
      * Sets a response header.
      * Header names are automatically normalized to lowercase.
@@ -134,6 +152,88 @@ export declare class BunResponse {
      * ```
      */
     setHeader(name: string, value: string): void;
+    /**
+     * Writes the response status and headers (Node.js compatibility method).
+     * This method is provided for compatibility with Node.js HTTP response objects.
+     *
+     * @param statusCode - The HTTP status code
+     * @param headers - Optional headers to set
+     * @example
+     * ```typescript
+     * response.writeHead(200, { 'Content-Type': 'application/json' });
+     * response.writeHead(404);
+     * ```
+     */
+    writeHead(statusCode: number, headers?: Record<string, string>): void;
+    /**
+     * Stub method for Node.js EventEmitter compatibility.
+     * This is a no-op method provided for compatibility with Node.js HTTP response objects.
+     * Some middleware may try to listen for events like 'close' on the response object.
+     *
+     * @param event - The event name
+     * @param listener - The event listener function
+     * @returns This response 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 response objects.
+     *
+     * @param event - The event name
+     * @param listener - The event listener function
+     * @returns This response object for chaining
+     */
+    off(event: string, listener: (...args: unknown[]) => void): this;
+    /**
+     * Property for Node.js HTTP response compatibility.
+     * Always returns false since Bun responses don't have a destroyed state.
+     */
+    readonly destroyed = false;
+    /**
+     * Stub method for Node.js HTTP response compatibility.
+     * This is a no-op method provided for compatibility with Node.js HTTP response objects.
+     *
+     * @param error - Optional error
+     */
+    destroy(error?: Error): void;
+    /**
+     * Stub method for Node.js EventEmitter compatibility.
+     * This is a no-op method provided for compatibility with Node.js HTTP response objects.
+     *
+     * @param event - The event name
+     * @param listener - The event listener function
+     * @returns This response object for chaining
+     */
+    once(event: string, listener: (...args: unknown[]) => void): this;
+    /**
+     * Stub method for Node.js HTTP response compatibility.
+     * This method writes data to the response stream.
+     * Data is accumulated in a buffer until end() is called.
+     * Mimics Node.js behavior where write() can be called multiple times.
+     *
+     * @param chunk - The data to write (string, Uint8Array, or other types that can be stringified)
+     * @returns true if the chunk was successfully buffered, false if the response has already ended
+     * @example
+     * ```typescript
+     * // Write string chunks
+     * response.write('Hello ');
+     * response.write('World');
+     * response.end('!'); // Sends "Hello World!"
+     *
+     * // Write binary chunks
+     * const chunk1 = new Uint8Array([1, 2, 3]);
+     * const chunk2 = new Uint8Array([4, 5, 6]);
+     * response.write(chunk1);
+     * response.write(chunk2);
+     * response.end(); // Sends combined binary data
+     *
+     * // Mixed usage (converts to string)
+     * response.write('Status: ');
+     * response.write(200);
+     * response.end(); // Sends "Status: 200"
+     * ```
+     */
+    write(chunk: unknown): boolean;
     /**
      * Gets the value of a response header.
      * Header lookup is case-insensitive.

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';