qhttpx 1.8.1 → 1.8.3

package/dist/src/core/types.d.ts

@@ -0,0 +1,134 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { URL } from 'url';
+import type { BufferPool, BufferPoolConfig } from './buffer-pool';
+import type { DatabaseManager } from '../database/manager';
+import type { RouteSchema, Validator } from '../validation/types';
+import type { ViewEngine } from '../views/types';
+import type { RequestFusionOptions } from './fusion';
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+export declare enum RoutePriority {
+    CRITICAL = "critical",
+    STANDARD = "standard",
+    BEST_EFFORT = "best-effort"
+}
+export type RouteOptions = {
+    priority?: RoutePriority;
+};
+export declare class HttpError extends Error {
+    status: number;
+    code?: string;
+    details?: unknown;
+    constructor(status: number, message?: string, options?: {
+        code?: string;
+        details?: unknown;
+    });
+}
+export type CookieOptions = {
+    domain?: string;
+    path?: string;
+    expires?: Date;
+    maxAge?: number;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'lax' | 'strict' | 'none';
+};
+export type QHTTPXFile = {
+    filename: string;
+    encoding: string;
+    mimeType: string;
+    data: Buffer;
+    size: number;
+};
+export type QHTTPXContext = {
+    readonly req: IncomingMessage;
+    readonly res: ServerResponse;
+    readonly url: URL;
+    readonly params: Record<string, string>;
+    readonly query: Record<string, string | string[]>;
+    body: unknown;
+    files?: Record<string, QHTTPXFile | QHTTPXFile[]>;
+    readonly cookies: Record<string, string>;
+    state: Record<string, any>;
+    readonly bufferPool: BufferPool;
+    requestId: string | undefined;
+    requestStart: number | undefined;
+    serializer?: (value: unknown) => string;
+    readonly json: (body: unknown, status?: number) => void;
+    readonly send: (body: string | Buffer, status?: number) => void;
+    readonly html: (html: string, status?: number) => void;
+    readonly redirect: (url: string, status?: number) => void;
+    readonly setCookie: (name: string, value: string, options?: CookieOptions) => void;
+    readonly db?: DatabaseManager;
+    readonly call?: (op: string, params: any) => Promise<any>;
+    readonly render: (view: string, locals?: Record<string, any>) => Promise<void>;
+    readonly validate: <T = unknown>(schema: unknown, data?: unknown) => Promise<T>;
+    disableAutoEnd?: boolean;
+    readonly path: string;
+    readonly next?: () => Promise<void>;
+};
+export type QHTTPXOpHandler = (params: any, ctx: QHTTPXContext) => any | Promise<any>;
+export type QHTTPXHandler = (ctx: QHTTPXContext) => void | Promise<void>;
+export type QHTTPXRouteOptions = {
+    schema?: RouteSchema | Record<string, any>;
+    handler: QHTTPXHandler;
+    priority?: RoutePriority;
+};
+export type QHTTPXMiddleware = (ctx: QHTTPXContext, next: () => Promise<void>) => void | Promise<void>;
+export type QHTTPXErrorContext = QHTTPXContext & {
+    error: unknown;
+};
+export type QHTTPXErrorHandler = (ctx: QHTTPXErrorContext) => void | Promise<void>;
+export type QHTTPXNotFoundHandler = (ctx: QHTTPXContext) => void | Promise<void>;
+export type QHTTPXMethodNotAllowedHandler = (ctx: QHTTPXContext, allowedMethods: HTTPMethod[]) => void | Promise<void>;
+export type QHTTPXTraceEvent = {
+    type: 'request_start';
+    method: string;
+    path: string;
+    requestId?: string;
+} | {
+    type: 'request_end';
+    method: string;
+    path: string;
+    statusCode: number;
+    durationMs: number;
+    requestId?: string;
+};
+export type QHTTPXTracer = (event: QHTTPXTraceEvent) => void | Promise<void>;
+export type QHTTPXTaskHandler = (payload: unknown) => void | Promise<void>;
+export type QHTTPXTaskOptions = {
+    maxRetries?: number;
+    backoffMs?: number;
+};
+export type PerformanceMode = 'balanced' | 'ultra';
+export type QHTTPXOptions = {
+    name?: string;
+    workers?: 'auto' | number;
+    maxConcurrency?: number;
+    requestTimeoutMs?: number;
+    maxMemoryBytes?: number;
+    maxBodyBytes?: number;
+    keepAliveTimeoutMs?: number;
+    headersTimeoutMs?: number;
+    metricsEnabled?: boolean;
+    jsonSerializer?: (value: unknown) => string | Buffer;
+    bufferPoolConfig?: BufferPoolConfig;
+    errorHandler?: QHTTPXErrorHandler;
+    notFoundHandler?: QHTTPXNotFoundHandler;
+    methodNotAllowedHandler?: QHTTPXMethodNotAllowedHandler;
+    tracer?: QHTTPXTracer;
+    performanceMode?: PerformanceMode;
+    database?: DatabaseManager;
+    enableBatching?: boolean | {
+        endpoint: string;
+    };
+    validator?: Validator;
+    enableRequestFusion?: boolean | RequestFusionOptions;
+    viewEngine?: ViewEngine;
+    viewsPath?: string;
+};
+export type QHTTPXPlugin<Options = any> = (app: any, // We use 'any' here to avoid circular dependency with QHTTPX class, or we could use an interface
+options: Options) => void | Promise<void>;
+export type QHTTPXPluginOptions = {
+    prefix?: string;
+    [key: string]: any;
+};

package/dist/src/core/websocket.d.ts

@@ -0,0 +1,25 @@
+import { IncomingMessage } from 'http';
+import { Duplex } from 'stream';
+import { WebSocket } from 'ws';
+export interface QHTTPXWebSocket extends WebSocket {
+    join(room: string): void;
+    leave(room: string): void;
+    id: string;
+}
+export type WSHandler = (ws: QHTTPXWebSocket, req: IncomingMessage) => void;
+export declare class WebSocketManager {
+    private readonly requestIdGenerator;
+    private readonly wss;
+    private readonly handlers;
+    private readonly rooms;
+    constructor(requestIdGenerator: () => string);
+    register(path: string, handler: WSHandler): void;
+    handleUpgrade(req: IncomingMessage, socket: Duplex, head: Buffer): Promise<void>;
+    private join;
+    private leave;
+    private leaveAll;
+    to(room: string): {
+        emit: (data: unknown) => void;
+    };
+    broadcast(data: unknown): void;
+}

package/dist/src/core/worker-queue.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Lock-free (or lock-minimal) work queue for per-worker task distribution.
+ * Uses a simple ring buffer for high throughput.
+ */
+export type WorkItem<T> = {
+    id: number;
+    task: T;
+    priority: number;
+};
+export declare class WorkerQueue<T> {
+    private readonly capacity;
+    private readonly buffer;
+    private writeIndex;
+    private readIndex;
+    private size;
+    constructor(capacity?: number);
+    /**
+     * Enqueue a work item. Returns true if successful, false if queue is full.
+     */
+    enqueue(item: WorkItem<T>): boolean;
+    /**
+     * Dequeue a work item. Returns undefined if queue is empty.
+     */
+    dequeue(): WorkItem<T> | undefined;
+    /**
+     * Peek at the next item without removing it.
+     */
+    peek(): WorkItem<T> | undefined;
+    /**
+     * Check if the queue is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Get the current size of the queue.
+     */
+    getSize(): number;
+    /**
+     * Get the capacity of the queue.
+     */
+    getCapacity(): number;
+}

package/dist/src/database/adapters/memory.d.ts

@@ -0,0 +1,21 @@
+import { DatabaseAdapter, DatabaseConfig } from '../types';
+export declare class MemoryAdapter implements DatabaseAdapter {
+    private config;
+    private connected;
+    private collections;
+    constructor(config: DatabaseConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /**
+      * Execute a query against the in-memory database
+      * @param query Object specifying collection, action, and parameters
+      * @example
+      * // Find
+      * query({ collection: 'users', action: 'find', filter: { id: 1 } })
+      * // Insert
+      * query({ collection: 'users', action: 'insert', data: { name: 'Alice' } })
+      */
+    query<T = any>(query: any): Promise<T>;
+    private matches;
+}

package/dist/src/database/adapters/mongo.d.ts

@@ -0,0 +1,11 @@
+import { DatabaseAdapter, DatabaseConfig } from '../types';
+export declare class MongoAdapter implements DatabaseAdapter {
+    private client;
+    private db;
+    private config;
+    constructor(config: DatabaseConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = any>(query: string | object, params?: any[]): Promise<T>;
+    isConnected(): boolean;
+}

package/dist/src/database/adapters/postgres.d.ts

@@ -0,0 +1,10 @@
+import { DatabaseAdapter, DatabaseConfig } from '../types';
+export declare class PostgresAdapter implements DatabaseAdapter {
+    private pool;
+    private config;
+    constructor(config: DatabaseConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = any>(sql: string, params?: any[]): Promise<T>;
+    isConnected(): boolean;
+}

package/dist/src/database/adapters/sqlite.d.ts

@@ -0,0 +1,10 @@
+import { DatabaseAdapter, DatabaseConfig } from '../types';
+export declare class SQLiteAdapter implements DatabaseAdapter {
+    private db;
+    private config;
+    constructor(config: DatabaseConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = any>(sql: string, params?: any[]): Promise<T>;
+    isConnected(): boolean;
+}

package/dist/src/database/coalescer.d.ts

@@ -0,0 +1,14 @@
+import { DatabaseAdapter } from './types';
+export declare class QueryCoalescer<T = unknown> {
+    private pending;
+    private timeout;
+    private readonly adapter;
+    constructor(adapter: DatabaseAdapter);
+    /**
+      * Intercepts a query and attempts to coalesce it with others.
+      * Only supports simple queries of the form "SELECT ... WHERE col = ?" for now.
+      */
+    query(query: string, params?: unknown[]): Promise<T>;
+    private scheduleFlush;
+    private flush;
+}

package/dist/src/database/manager.d.ts

@@ -0,0 +1,35 @@
+import { DatabaseAdapter, DatabaseConfig, DatabaseEngineOptions } from './types';
+export type AdapterConstructor = new (config: DatabaseConfig) => DatabaseAdapter;
+export declare class DatabaseManager {
+    private config;
+    private static adapterRegistry;
+    private connections;
+    constructor(config: DatabaseEngineOptions);
+    /**
+     * Manually register an already initialized adapter instance
+     * @param name The connection name
+     * @param adapter The initialized adapter instance
+     */
+    registerConnection(name: string, adapter: DatabaseAdapter): void;
+    /**
+     * Register a new database adapter type
+     * @param type The type identifier (e.g., 'postgres', 'mysql', 'mongo')
+     * @param adapter The adapter class
+     */
+    static registerAdapter(type: string, adapter: AdapterConstructor): void;
+    /**
+     * Connect to a specific database or the default one
+     * @param name Connection name from config
+     */
+    connect(name?: string): Promise<DatabaseAdapter>;
+    /**
+     * Disconnect a specific connection or all connections
+     * @param name Connection name (optional). If not provided, disconnects all.
+     */
+    disconnect(name?: string): Promise<void>;
+    /**
+     * Get an active connection
+     * @param name Connection name
+     */
+    get(name?: string): DatabaseAdapter;
+}

package/dist/src/database/types.d.ts

@@ -0,0 +1,20 @@
+export interface DatabaseConfig {
+    type: string;
+    url?: string;
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    database?: string;
+    options?: Record<string, any>;
+}
+export interface DatabaseAdapter {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = any>(query: string | object, params?: any[]): Promise<T>;
+    isConnected(): boolean;
+}
+export interface DatabaseEngineOptions {
+    default?: string;
+    connections: Record<string, DatabaseConfig>;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,45 @@
+import { QHTTPX } from './core/server';
+import type { QHTTPXOptions } from './core/types';
+export { QHTTPX } from './core/server';
+export * from './core/types';
+export * from './middleware/cors';
+export * from './middleware/security';
+export * from './middleware/static';
+export * from './middleware/compression';
+export * from './core/stream';
+export * from './utils/logger';
+export { BufferPool, BufferPoolConfig } from './core/buffer-pool';
+export * from './testing';
+export * from './utils/signals';
+export * from './middleware/presets';
+export * from './utils/cookies';
+export * from './utils/sse';
+export { fastJsonStringify, getStringifier } from './core/serializer';
+export * from './database/types';
+export * from './database/manager';
+export * from './database/adapters/memory';
+export * from './views';
+export * from './validation';
+export * from './database/adapters/sqlite';
+export * from './database/adapters/postgres';
+export * from './database/adapters/mongo';
+export * from './core/fusion';
+export * from './validation/types';
+export * from './validation/simple';
+export * from './openapi/generator';
+export * from './client';
+export declare function createHttpApp(options?: QHTTPXOptions): QHTTPX;
+/**
+ * Singleton instance for quick start
+ * @example
+ * import { app } from 'qhttpx';
+ * app.get('/', ({ json }) => json({ hello: 'world' }));
+ */
+export declare const app: QHTTPX;
+/**
+ * Default export for simplified usage
+ * @example
+ * import QHTTPX from 'qhttpx';
+ * const app = QHTTPX();
+ */
+export default createHttpApp;

package/dist/src/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStringifier = exports.fastJsonStringify = exports.BufferPool = exports.QHTTPX = void 0;
+exports.app = exports.getStringifier = exports.fastJsonStringify = exports.BufferPool = exports.QHTTPX = void 0;
 exports.createHttpApp = createHttpApp;
 const server_1 = require("./core/server");
 const presets_1 = require("./middleware/presets");
@@ -59,3 +59,17 @@ function createHttpApp(options = {}) {
     }
     return app;
 }
+/**
+ * Singleton instance for quick start
+ * @example
+ * import { app } from 'qhttpx';
+ * app.get('/', ({ json }) => json({ hello: 'world' }));
+ */
+exports.app = createHttpApp();
+/**
+ * Default export for simplified usage
+ * @example
+ * import QHTTPX from 'qhttpx';
+ * const app = QHTTPX();
+ */
+exports.default = createHttpApp;

package/dist/src/middleware/compression.d.ts

@@ -0,0 +1,6 @@
+import { QHTTPXMiddleware } from '../core/types';
+export type CompressionOptions = {
+    threshold?: number;
+    level?: number;
+};
+export declare function createCompressionMiddleware(options?: CompressionOptions): QHTTPXMiddleware;

package/dist/src/middleware/cors.d.ts

@@ -0,0 +1,11 @@
+import { QHTTPXMiddleware } from '../core/types';
+export type CorsOrigin = string | string[] | ((origin: string | undefined) => string | null | undefined);
+export type CorsOptions = {
+    origin?: CorsOrigin;
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAgeSeconds?: number;
+};
+export declare function createCorsMiddleware(options?: CorsOptions): QHTTPXMiddleware;

package/dist/src/middleware/presets.d.ts

@@ -0,0 +1,13 @@
+import { QHTTPXMiddleware } from '../core/types';
+import { SecureDefaultsOptions } from './security';
+import { LoggerOptions } from '../utils/logger';
+import { StaticOptions } from './static';
+export type ApiPresetOptions = {
+    security?: SecureDefaultsOptions;
+    logging?: LoggerOptions | boolean;
+};
+export declare function createApiPreset(options?: ApiPresetOptions): QHTTPXMiddleware[];
+export type StaticAppPresetOptions = ApiPresetOptions & {
+    static: StaticOptions;
+};
+export declare function createStaticAppPreset(options: StaticAppPresetOptions): QHTTPXMiddleware[];

package/dist/src/middleware/rate-limit.d.ts

@@ -0,0 +1,32 @@
+import type { QHTTPXContext, QHTTPXMiddleware } from '../core/types';
+export interface RateLimitStore {
+    increment(key: string, windowMs: number): Promise<{
+        total: number;
+        resetTime: number;
+    }>;
+    decrement(key: string): Promise<void>;
+    reset(key: string): Promise<void>;
+}
+export declare class MemoryStore implements RateLimitStore {
+    private hits;
+    private interval?;
+    constructor(clearPeriodMs?: number);
+    increment(key: string, windowMs: number): Promise<{
+        total: number;
+        resetTime: number;
+    }>;
+    decrement(key: string): Promise<void>;
+    reset(key: string): Promise<void>;
+    private cleanup;
+}
+export interface RateLimitOptions {
+    windowMs?: number;
+    max?: number;
+    message?: string | object;
+    statusCode?: number;
+    headers?: boolean;
+    keyGenerator?: (ctx: QHTTPXContext) => string;
+    skip?: (ctx: QHTTPXContext) => boolean;
+    store?: RateLimitStore;
+}
+export declare const rateLimit: (options?: RateLimitOptions) => QHTTPXMiddleware;

package/dist/src/middleware/security.d.ts

@@ -0,0 +1,22 @@
+import { QHTTPXContext, QHTTPXMiddleware } from '../core/types';
+import { CorsOptions } from './cors';
+export type SecurityHeadersOptions = {
+    contentSecurityPolicy?: string | null;
+    referrerPolicy?: string | null;
+    xFrameOptions?: 'DENY' | 'SAMEORIGIN' | null;
+    xContentTypeOptions?: 'nosniff' | null;
+    xXssProtection?: '0' | '1; mode=block' | null;
+    strictTransportSecurity?: string | null;
+};
+export declare function createSecurityHeadersMiddleware(options?: SecurityHeadersOptions): QHTTPXMiddleware;
+export type SecureDefaultsOptions = {
+    cors?: CorsOptions;
+    securityHeaders?: SecurityHeadersOptions;
+};
+export declare function createSecureDefaults(options?: SecureDefaultsOptions): QHTTPXMiddleware[];
+export type RateLimitOptions = {
+    maxRequests: number;
+    windowMs: number;
+    keyGenerator?: (ctx: QHTTPXContext) => string;
+};
+export declare function createRateLimitMiddleware(options: RateLimitOptions): QHTTPXMiddleware;

package/dist/src/middleware/static.d.ts

@@ -0,0 +1,11 @@
+import { QHTTPXMiddleware } from '../core/types';
+export type StaticOptions = {
+    root: string;
+    index?: string;
+    fallthrough?: boolean;
+    etag?: boolean;
+    lastModified?: boolean;
+    maxAge?: number;
+    immutable?: boolean;
+};
+export declare function createStaticMiddleware(options: StaticOptions): QHTTPXMiddleware;

package/dist/src/openapi/generator.d.ts

@@ -0,0 +1,19 @@
+import { Router } from '../router/router';
+export type OpenAPIOptions = {
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+    };
+    servers?: {
+        url: string;
+        description?: string;
+    }[];
+};
+export declare class OpenAPIGenerator {
+    private router;
+    private options;
+    constructor(router: Router, options: OpenAPIOptions);
+    generate(): object;
+    private convertSchema;
+}

package/dist/src/router/radix-router.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Radix tree router compiled into a flat array structure for zero-allocation matching.
+ * Built once at server startup (frozen).
+ */
+import { HTTPMethod, QHTTPXHandler } from '../core/types';
+export type CompiledRadixMatch = {
+    handler: QHTTPXHandler;
+    params: Record<string, string>;
+};
+export declare class RadixRouter {
+    private roots;
+    private isFrozen;
+    register(method: HTTPMethod, path: string, handler: QHTTPXHandler): void;
+    match(method: HTTPMethod, path: string): CompiledRadixMatch | undefined;
+    freeze(): void;
+    isFrozenRouter(): boolean;
+    private normalize;
+}

package/dist/src/router/radix-tree.d.ts

@@ -0,0 +1,16 @@
+import { QHTTPXHandler, RoutePriority } from '../core/types';
+export type RouteData = {
+    handler: QHTTPXHandler;
+    priority: RoutePriority;
+};
+export type MatchResult = {
+    handler: QHTTPXHandler;
+    priority: RoutePriority;
+    params: Record<string, string>;
+};
+export declare class RadixTree {
+    private root;
+    insert(segments: string[], handler: QHTTPXHandler, priority: RoutePriority): void;
+    lookup(segments: string[]): MatchResult | null;
+    private find;
+}

package/dist/src/router/router.d.ts

@@ -0,0 +1,33 @@
+import { HTTPMethod, QHTTPXHandler, RouteOptions, RoutePriority } from '../core/types';
+import { RouteSchema } from '../validation/types';
+type RouteDefinition = {
+    path: string;
+    segments: string[];
+    handler: QHTTPXHandler;
+    priority: RoutePriority;
+    schema?: RouteSchema | Record<string, unknown>;
+};
+export type RouteMatch = {
+    handler: QHTTPXHandler;
+    params: Record<string, string>;
+    priority: RoutePriority;
+};
+export declare class Router {
+    private readonly methodBuckets;
+    private readonly radixTrees;
+    private isFrozen;
+    register(method: HTTPMethod, path: string, handler: QHTTPXHandler, options?: RouteOptions & {
+        schema?: RouteSchema | Record<string, unknown>;
+    }): void;
+    getRoutes(): Map<HTTPMethod, RouteDefinition[]>;
+    match(method: HTTPMethod, path: string): RouteMatch | undefined;
+    getAllowedMethods(path: string): HTTPMethod[];
+    /**
+     * Freeze the router after server starts.
+     * Prevents further route registration and builds derived structures for optimized matching.
+     */
+    freeze(): void;
+    isFrozenRouter(): boolean;
+    private normalize;
+}
+export {};

package/dist/src/testing/index.d.ts

@@ -0,0 +1,25 @@
+import { QHTTPX } from '../core/server';
+import { HTTPMethod } from '../core/types';
+export declare class TestClient {
+    private app;
+    private server;
+    private baseURL;
+    constructor(app: QHTTPX);
+    /**
+     * Starts the server on a random port.
+     * Automatically called by request methods if not started.
+     */
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    request(method: HTTPMethod, path: string, options?: {
+        headers?: Record<string, string>;
+        body?: any;
+        query?: Record<string, string | number | boolean>;
+    }): Promise<Response>;
+    get(path: string, options?: Omit<Parameters<TestClient['request']>[2], 'body'>): Promise<Response>;
+    post(path: string, body?: any, options?: Omit<Parameters<TestClient['request']>[2], 'body'>): Promise<Response>;
+    put(path: string, body?: any, options?: Omit<Parameters<TestClient['request']>[2], 'body'>): Promise<Response>;
+    delete(path: string, options?: Omit<Parameters<TestClient['request']>[2], 'body'>): Promise<Response>;
+    patch(path: string, body?: any, options?: Omit<Parameters<TestClient['request']>[2], 'body'>): Promise<Response>;
+}
+export declare function createTestClient(app: QHTTPX): TestClient;

package/dist/src/utils/cookies.d.ts

@@ -0,0 +1,3 @@
+import { CookieOptions } from '../core/types';
+export declare function parseCookies(header: string | undefined): Record<string, string>;
+export declare function serializeCookie(name: string, value: string, options?: CookieOptions): string;

package/dist/src/utils/logger.d.ts

@@ -0,0 +1,12 @@
+import { QHTTPXContext, QHTTPXMiddleware } from '../core/types';
+export type LogEntry = {
+    method: string;
+    path: string;
+    status: number;
+    durationMs: number;
+    requestId?: string;
+};
+export type LoggerOptions = {
+    sink?: (entry: LogEntry, ctx: QHTTPXContext) => void;
+};
+export declare function createLoggerMiddleware(options?: LoggerOptions): QHTTPXMiddleware;

package/dist/src/utils/signals.d.ts

@@ -0,0 +1,6 @@
+import { QHTTPX } from '../core/server';
+export type SignalHandlerOptions = {
+    signals?: NodeJS.Signals[];
+    timeoutMs?: number;
+};
+export declare function attachSignalHandlers(app: QHTTPX, options?: SignalHandlerOptions): void;

package/dist/src/utils/sse.d.ts

@@ -0,0 +1,6 @@
+import { QHTTPXContext } from '../core/types';
+export interface SSEStream {
+    send(data: unknown, event?: string, id?: string): void;
+    close(): void;
+}
+export declare function createSSE(ctx: QHTTPXContext): SSEStream;

package/dist/src/validation/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './simple';
+export * from './zod';