@krisanalfa/bunest-adapter 0.1.0 → 0.4.0

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

@@ -0,0 +1,44 @@
+import { Server, ServerWebSocket } from 'bun';
+import { BaseWsInstance } from '@nestjs/websockets';
+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.
+ *
+ * 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 serverInstance;
+    constructor(serverInstance: BunServerInstance);
+    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: string;
+        port: number;
+    };
+    setWsOptions(options: WsOptions): void;
+    registerWsOpenHandler(handler: (ws: ServerWebSocket<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;
+    getBunServer(): Server<unknown> | null;
+    /**
+     * Proxy method for WebSocket server close
+     */
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,38 @@
+import { AbstractWsAdapter, BaseWsInstance, MessageMappingProperties } from '@nestjs/websockets';
+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';
+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;
+}
+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,8 @@
-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 './bun.internal.types.js';
+export * from './bun.preflight-http-server.js';
+export * from './bun.server-instance.js';
+export * from './bun.ws-adapter.js';