@krisanalfa/bunest-adapter 0.0.1

package/dist/bun.adapter.d.ts

@@ -0,0 +1,93 @@
+import { CorsOptions, CorsOptionsDelegate } from '@nestjs/common/interfaces/external/cors-options.interface.js';
+import { ErrorHandler, RequestHandler } from '@nestjs/common/interfaces/index.js';
+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 { BunRequest } from './bun.request.js';
+import { BunResponse } from './bun.response.js';
+export declare class BunAdapter extends AbstractHttpAdapter<Server<unknown>, BunRequest, BunResponse> {
+    private bunServeOptions;
+    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'>);
+    use(middleware: RequestHandler<BunRequest, BunResponse>): void;
+    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;
+    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;
+    setViewEngine(engine: string): void;
+    render(response: unknown, view: string, options: unknown): void;
+    close(): Promise<void>;
+    initHttpServer(options: NestApplicationOptions): void;
+    getRequestHostname(request: BunRequest): string;
+    getRequestMethod(request: BunRequest): string;
+    getRequestUrl(request: BunRequest): string;
+    status(response: BunResponse, statusCode: number): void;
+    reply(response: BunResponse, body: unknown, statusCode?: number): void;
+    end(response: BunResponse, message?: string): void;
+    redirect(response: BunResponse, statusCode: number, url: string): void;
+    setErrorHandler(handler: ErrorHandler<BunRequest, BunResponse>, prefix?: string): void;
+    setNotFoundHandler(handler: RequestHandler<BunRequest, BunResponse>, prefix?: string): void;
+    isHeadersSent(response: BunResponse): boolean;
+    getHeader(response: BunResponse, name: string): string | null;
+    setHeader(response: BunResponse, name: string, value: string): void;
+    appendHeader(response: BunResponse, name: string, value: string): void;
+    registerParserMiddleware(prefix?: string, rawBody?: boolean): void;
+    enableCors(options?: CorsOptions | CorsOptionsDelegate<BunRequest>, prefix?: string): void;
+    createMiddlewareFactory(requestMethod: RequestMethod): (path: string, callback: Function) => void;
+    getType(): string;
+    applyVersionFilter(handler: Function, version: VersionValue, versioningOptions: VersioningOptions): (req: BunRequest, res: BunResponse, next: () => void) => Function;
+    /**
+     * Start listening on the specified port and hostname.
+     * @param port The port number or Unix socket path to listen on.
+     * @param callback Optional callback to invoke once the server is listening.
+     */
+    listen(port: string | number, callback?: () => void): void;
+    /**
+     * Start listening on the specified port and hostname.
+     * @param port The port number or Unix socket path to listen on.
+     * @param hostname The hostname to bind to.
+     * @param callback Optional callback to invoke once the server is listening.
+     */
+    listen(port: string | number, hostname: string, callback?: () => void): void;
+    private delegateRouteHandler;
+    private createVersioningHandlers;
+    private executeHandlerChain;
+    private createChainedHandlerForVersioningResolution;
+    private mapRequestMethodToString;
+    private parseRouteHandler;
+}

package/dist/bun.file.interceptor.d.ts

@@ -0,0 +1,9 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { HttpAdapterHost } from '@nestjs/core';
+import { Observable } from 'rxjs';
+export declare class BunFileInterceptor implements NestInterceptor {
+    private readonly adapter;
+    private readonly uploadDir;
+    constructor(adapter: HttpAdapterHost);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<unknown>>;
+}

package/dist/bun.request.d.ts

@@ -0,0 +1,339 @@
+import { CookieMap, BunRequest as NativeRequest } from 'bun';
+import { ParsedQs } from 'qs';
+type HeadersProxy = Record<string, string> & {
+    get: (key: string) => string | null;
+};
+/**
+ * A high-performance request wrapper for Bun's native request object.
+ * Provides lazy parsing and caching for optimal performance in NestJS applications.
+ *
+ * @example
+ * ```typescript
+ * const bunRequest = new BunRequest(nativeRequest);
+ * const pathname = bunRequest.pathname; // Lazily parsed
+ * const query = bunRequest.query; // Parsed only when accessed
+ * ```
+ */
+export declare class BunRequest {
+    private readonly nativeRequest;
+    private _nativeHeaders;
+    private _headers;
+    private _hostname;
+    private _pathname;
+    private _query;
+    private _body;
+    private _rawBody;
+    private _file;
+    private _files;
+    private _settings;
+    private readonly _url;
+    private readonly _parsedUrl;
+    readonly method: string;
+    readonly params: Record<string, string>;
+    constructor(nativeRequest: NativeRequest);
+    /**
+     * Gets the full URL of the request.
+     *
+     * @returns The complete URL string
+     * @example
+     * ```typescript
+     * const url = request.url; // "http://localhost:3000/api/users?page=1"
+     * ```
+     */
+    get url(): string;
+    /**
+     * Gets the pathname portion of the URL.
+     * Uses lazy parsing for optimal performance - the pathname is only extracted when first accessed.
+     *
+     * @returns The pathname component of the URL
+     * @example
+     * ```typescript
+     * // For URL "http://localhost:3000/api/users?page=1"
+     * const pathname = request.pathname; // "/api/users"
+     * ```
+     */
+    get pathname(): string;
+    /**
+     * Gets the hostname portion of the URL.
+     * Uses lazy parsing - the hostname is only extracted when first accessed.
+     *
+     * @returns The hostname component of the URL (without port)
+     * @example
+     * ```typescript
+     * // For URL "http://localhost:3000/api/users"
+     * const hostname = request.hostname; // "localhost"
+     * ```
+     */
+    get hostname(): string;
+    /**
+     * Gets all request headers as a key-value object.
+     * Uses lazy parsing - headers are materialized only when first accessed.
+     * All header keys are normalized to lowercase.
+     *
+     * @returns An object containing all headers with a .get() method for efficient lookups
+     * @example
+     * ```typescript
+     * const headers = request.headers;
+     * const contentType = headers['content-type']; // Direct access
+     * const auth = headers.get('Authorization'); // Using .get() method
+     * ```
+     */
+    get headers(): HeadersProxy;
+    /**
+     * Gets the parsed query parameters from the URL.
+     * Uses lazy parsing - query string is only parsed when first accessed.
+     *
+     * @returns Parsed query parameters as an object
+     * @example
+     * ```typescript
+     * // For URL "http://localhost:3000/api/users?page=1&limit=10"
+     * const query = request.query;
+     * console.log(query.page); // "1"
+     * console.log(query.limit); // "10"
+     * ```
+     */
+    get query(): ParsedQs;
+    /**
+     * Gets the parsed request body.
+     *
+     * @returns The parsed body content (could be JSON, form data, etc.)
+     * @example
+     * ```typescript
+     * const body = request.body;
+     * console.log(body); // { name: "John", email: "john@example.com" }
+     * ```
+     */
+    get body(): unknown;
+    /**
+     * Sets the parsed request body.
+     * Typically used by body parser middleware.
+     *
+     * @param body - The parsed body content to set
+     * @example
+     * ```typescript
+     * request.setBody({ name: "John", email: "john@example.com" });
+     * ```
+     */
+    setBody(body: unknown): void;
+    /**
+     * Gets the raw request body as an ArrayBuffer.
+     *
+     * @returns The raw body data or null if not set
+     * @example
+     * ```typescript
+     * const rawBody = request.rawBody;
+     * if (rawBody) {
+     *   const text = new TextDecoder().decode(rawBody);
+     * }
+     * ```
+     */
+    get rawBody(): ArrayBuffer | null;
+    /**
+     * Sets the raw request body as an ArrayBuffer.
+     *
+     * @param rawBody - The raw body data to set
+     * @example
+     * ```typescript
+     * const buffer = await request.arrayBuffer();
+     * request.setRawBody(buffer);
+     * ```
+     */
+    setRawBody(rawBody: ArrayBuffer): void;
+    /**
+     * Gets the uploaded file from the request.
+     * Used for single file uploads.
+     *
+     * @returns The uploaded file or null if no file was uploaded
+     * @example
+     * ```typescript
+     * const file = request.file;
+     * if (file) {
+     *   console.log(file.name); // "avatar.png"
+     *   console.log(file.size); // 2048
+     * }
+     * ```
+     */
+    get file(): File | null;
+    /**
+     * Sets the uploaded file in the request.
+     * Typically used by file upload middleware.
+     *
+     * @param file - The file to set
+     * @example
+     * ```typescript
+     * const formData = await request.formData();
+     * const file = formData.get('avatar') as File;
+     * request.setFile(file);
+     * ```
+     */
+    setFile(file: File): void;
+    /**
+     * Gets all uploaded files from the request.
+     * Used for multiple file uploads.
+     *
+     * @returns Array of uploaded files or null if no files were uploaded
+     * @example
+     * ```typescript
+     * const files = request.files;
+     * if (files) {
+     *   files.forEach(file => {
+     *     console.log(file.name, file.size);
+     *   });
+     * }
+     * ```
+     */
+    get files(): File[] | null;
+    /**
+     * Sets multiple uploaded files in the request.
+     * Typically used by file upload middleware.
+     *
+     * @param files - Array of files to set
+     * @example
+     * ```typescript
+     * const formData = await request.formData();
+     * const files = formData.getAll('attachments') as File[];
+     * request.setFiles(files);
+     * ```
+     */
+    setFiles(files: File[]): void;
+    /**
+     * Gets a custom setting/property stored in the request.
+     * Useful for passing data between middleware and handlers.
+     *
+     * @param key - The setting key to retrieve
+     * @returns The stored value or undefined if not found
+     * @example
+     * ```typescript
+     * // In middleware
+     * request.set('user', { id: 1, name: 'John' });
+     *
+     * // In handler
+     * const user = request.get('user');
+     * console.log(user); // { id: 1, name: 'John' }
+     * ```
+     */
+    get(key: string): unknown;
+    /**
+     * Sets a custom setting/property in the request.
+     * Useful for passing data between middleware and handlers.
+     *
+     * @param key - The setting key to store
+     * @param value - The value to store
+     * @example
+     * ```typescript
+     * request.set('user', { id: 1, name: 'John' });
+     * request.set('startTime', Date.now());
+     * ```
+     */
+    set(key: string, value: unknown): void;
+    /**
+     * Gets the AbortSignal for the request.
+     * Can be used to detect if the request has been cancelled.
+     *
+     * @returns The request's AbortSignal
+     * @example
+     * ```typescript
+     * const signal = request.signal;
+     * signal.addEventListener('abort', () => {
+     *   console.log('Request was cancelled');
+     * });
+     * ```
+     */
+    get signal(): AbortSignal;
+    /**
+     * Gets the cookies from the request.
+     *
+     * @returns A Map-like object containing all cookies
+     * @example
+     * ```typescript
+     * const cookies = request.cookies;
+     * const sessionId = cookies.get('sessionId');
+     * console.log(sessionId?.value);
+     * ```
+     */
+    get cookies(): CookieMap;
+    /**
+     * Parses the request body as JSON.
+     *
+     * @returns Promise that resolves to the parsed JSON data
+     * @example
+     * ```typescript
+     * const data = await request.json();
+     * console.log(data); // { name: "John", email: "john@example.com" }
+     * ```
+     */
+    json(): Promise<unknown>;
+    /**
+     * Reads the request body as text.
+     *
+     * @returns Promise that resolves to the body text
+     * @example
+     * ```typescript
+     * const text = await request.text();
+     * console.log(text); // "Hello, World!"
+     * ```
+     */
+    text(): Promise<string>;
+    /**
+     * Parses the request body as FormData.
+     *
+     * @returns Promise that resolves to the parsed FormData
+     * @example
+     * ```typescript
+     * const formData = await request.formData();
+     * const name = formData.get('name');
+     * console.log(name); // "John"
+     * ```
+     */
+    formData(): Promise<FormData>;
+    /**
+     * Reads the request body as an ArrayBuffer.
+     *
+     * @returns Promise that resolves to the body as ArrayBuffer
+     * @example
+     * ```typescript
+     * const buffer = await request.arrayBuffer();
+     * console.log(buffer.byteLength); // 1024
+     * ```
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * Reads the request body as a Blob.
+     *
+     * @returns Promise that resolves to the body as Blob
+     * @example
+     * ```typescript
+     * const blob = await request.blob();
+     * console.log(blob.type); // "image/png"
+     * ```
+     */
+    blob(): Promise<Blob>;
+    /**
+     * Reads the request body as a Uint8Array.
+     *
+     * @returns Promise that resolves to the body as Uint8Array
+     * @example
+     * ```typescript
+     * const bytes = await request.bytes();
+     * console.log(bytes.length); // 1024
+     * ```
+     */
+    bytes(): Promise<Uint8Array>;
+    /**
+     * Creates a deep clone of the request.
+     * Clones both the native request and all cached properties.
+     *
+     * @returns A new BunRequest instance with cloned data
+     * @example
+     * ```typescript
+     * const originalRequest = new BunRequest(nativeRequest);
+     * const clonedRequest = originalRequest.clone();
+     *
+     * // Modifications to clone don't affect original
+     * clonedRequest.set('user', { id: 1 });
+     * console.log(originalRequest.get('user')); // undefined
+     * ```
+     */
+    clone(): BunRequest;
+}
+export {};

package/dist/bun.response.d.ts

@@ -0,0 +1,251 @@
+import { Cookie, CookieInit, CookieStoreDeleteOptions } from 'bun';
+/**
+ * A high-performance response builder for Bun's native Response object.
+ * Provides methods to build responses with headers, cookies, and various body types.
+ * Uses lazy initialization and optimized response building for maximum performance.
+ *
+ * @example
+ * ```typescript
+ * const response = new BunResponse();
+ * response.setStatus(200);
+ * response.setHeader('Content-Type', 'application/json');
+ * response.cookie('sessionId', 'abc123');
+ * response.end({ message: 'Success' });
+ * ```
+ */
+export declare class BunResponse {
+    private resolve;
+    private readonly response;
+    private readonly cookieMap;
+    private _headers;
+    private statusCode;
+    private ended;
+    private _cookieHeaderCache;
+    constructor();
+    private get headersMap();
+    /**
+     * Sets a cookie in the response.
+     * Can be called with either a cookie options object or name-value pair.
+     *
+     * @param options - Cookie configuration object
+     * @example
+     * ```typescript
+     * // Using name-value pair
+     * response.cookie('sessionId', 'abc123');
+     *
+     * // Using options object
+     * response.cookie({
+     *   name: 'sessionId',
+     *   value: 'abc123',
+     *   httpOnly: true,
+     *   secure: true,
+     *   maxAge: 3600
+     * });
+     * ```
+     */
+    cookie(options: CookieInit | Cookie): void;
+    /**
+     * Sets a cookie in the response using name and value.
+     *
+     * @param name - The cookie name
+     * @param value - The cookie value
+     */
+    cookie(name: string, value: string): void;
+    /**
+     * Deletes a cookie from the response.
+     *
+     * @param optionsOrName - Cookie name or delete options
+     * @example
+     * ```typescript
+     * // Delete by name
+     * response.deleteCookie('sessionId');
+     *
+     * // Delete with options
+     * response.deleteCookie({
+     *   name: 'sessionId',
+     *   path: '/',
+     *   domain: 'example.com'
+     * });
+     * ```
+     */
+    deleteCookie(optionsOrName: CookieStoreDeleteOptions | string): void;
+    /**
+     * Deletes a cookie from the response with additional options.
+     *
+     * @param optionsOrName - Cookie name
+     * @param options - Additional delete options (path, domain, etc.)
+     */
+    deleteCookie(optionsOrName: string, options: Omit<CookieStoreDeleteOptions, 'name'>): void;
+    /**
+     * Sends a redirect response to the specified URL.
+     * Ends the response after calling this method.
+     *
+     * @param url - The URL to redirect to
+     * @param statusCode - HTTP status code for the redirect (default: 302)
+     * @example
+     * ```typescript
+     * // Temporary redirect (302)
+     * response.redirect('/login');
+     *
+     * // Permanent redirect (301)
+     * response.redirect('/new-page', 301);
+     *
+     * // See Other (303)
+     * response.redirect('/success', 303);
+     * ```
+     */
+    redirect(url: string, statusCode?: number): void;
+    /**
+     * 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.
+     *
+     * @param body - The response body (JSON, string, Uint8Array, StreamableFile, or undefined)
+     * @example
+     * ```typescript
+     * // Send JSON response
+     * response.end({ message: 'Success', data: { id: 1 } });
+     *
+     * // Send empty response
+     * response.setStatus(204);
+     * response.end();
+     *
+     * // Send binary data
+     * const buffer = new Uint8Array([1, 2, 3]);
+     * response.end(buffer);
+     *
+     * // Send file stream
+     * const file = new StreamableFile(stream);
+     * response.end(file);
+     * ```
+     */
+    end(body?: unknown): void;
+    /**
+     * Sets a response header.
+     * Header names are automatically normalized to lowercase.
+     *
+     * @param name - The header name
+     * @param value - The header value
+     * @example
+     * ```typescript
+     * response.setHeader('Content-Type', 'application/json');
+     * response.setHeader('Cache-Control', 'no-cache');
+     * response.setHeader('X-Custom-Header', 'custom-value');
+     * ```
+     */
+    setHeader(name: string, value: string): void;
+    /**
+     * Gets the value of a response header.
+     * Header lookup is case-insensitive.
+     *
+     * @param name - The header name to retrieve
+     * @returns The header value or null if not set
+     * @example
+     * ```typescript
+     * response.setHeader('Content-Type', 'application/json');
+     * const contentType = response.getHeader('content-type');
+     * console.log(contentType); // "application/json"
+     *
+     * const missing = response.getHeader('X-Missing');
+     * console.log(missing); // null
+     * ```
+     */
+    getHeader(name: string): string | null;
+    /**
+     * Appends a value to an existing response header.
+     * If the header doesn't exist, it will be created.
+     * Multiple values are joined with a comma as per RFC 9110.
+     *
+     * @param name - The header name
+     * @param value - The value to append
+     * @example
+     * ```typescript
+     * response.setHeader('Cache-Control', 'no-cache');
+     * response.appendHeader('Cache-Control', 'no-store');
+     * // Results in: "Cache-Control: no-cache, no-store"
+     *
+     * response.appendHeader('X-Custom', 'value1');
+     * response.appendHeader('X-Custom', 'value2');
+     * // Results in: "X-Custom: value1, value2"
+     * ```
+     */
+    appendHeader(name: string, value: string): void;
+    /**
+     * Removes a response header.
+     * Header lookup is case-insensitive.
+     *
+     * @param name - The header name to remove
+     * @example
+     * ```typescript
+     * response.setHeader('X-Custom-Header', 'value');
+     * response.removeHeader('X-Custom-Header');
+     *
+     * const header = response.getHeader('X-Custom-Header');
+     * console.log(header); // null
+     * ```
+     */
+    removeHeader(name: string): void;
+    /**
+     * Sets the HTTP status code for the response.
+     *
+     * @param code - The HTTP status code (e.g., 200, 404, 500)
+     * @example
+     * ```typescript
+     * response.setStatus(200); // OK
+     * response.setStatus(201); // Created
+     * response.setStatus(400); // Bad Request
+     * response.setStatus(404); // Not Found
+     * response.setStatus(500); // Internal Server Error
+     * ```
+     */
+    setStatus(code: number): void;
+    /**
+     * Gets the current HTTP status code of the response.
+     *
+     * @returns The HTTP status code
+     * @example
+     * ```typescript
+     * response.setStatus(404);
+     * const status = response.getStatus();
+     * console.log(status); // 404
+     * ```
+     */
+    getStatus(): number;
+    /**
+     * Returns a Promise that resolves to the native Response object.
+     * The Promise resolves when end() or redirect() is called.
+     *
+     * @returns Promise that resolves to the Bun Response object
+     * @example
+     * ```typescript
+     * const response = new BunResponse();
+     * response.setStatus(200);
+     * response.end({ message: 'Success' });
+     *
+     * const nativeResponse = await response.res();
+     * console.log(nativeResponse.status); // 200
+     * ```
+     */
+    res(): Promise<Response>;
+    /**
+     * Checks if the response has been ended.
+     * Once ended, no further modifications can be made to the response.
+     *
+     * @returns true if the response has been ended, false otherwise
+     * @example
+     * ```typescript
+     * const response = new BunResponse();
+     * console.log(response.isEnded()); // false
+     *
+     * response.end({ message: 'Done' });
+     * console.log(response.isEnded()); // true
+     *
+     * // This will be ignored since response is already ended
+     * response.setHeader('X-Custom', 'value');
+     * ```
+     */
+    isEnded(): boolean;
+    private buildStreamableResponse;
+    private buildJsonResponse;
+    private createResponse;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+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';