qhttpx 1.8.12 → 1.9.1

package/dist/src/router/radix-tree.js

@@ -1,131 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RadixTree = void 0;
-class Node {
-    constructor() {
-        // Map segment -> Node
-        this.children = new Map();
-        // Parameter child node (only one allowed per level for simplicity)
-        this.paramChild = null;
-        this.paramName = null;
-        // Data if this node is a route end
-        this.data = null;
-        // Optimization: Pre-allocated match result for static matches
-        this.staticMatch = null;
-    }
-}
-class RadixTree {
-    constructor() {
-        this.root = new Node();
-    }
-    insert(segments, handler, priority) {
-        let node = this.root;
-        for (const segment of segments) {
-            if (segment.startsWith(':')) {
-                const paramName = segment.slice(1);
-                if (!node.paramChild) {
-                    node.paramChild = new Node();
-                    node.paramChild.paramName = paramName;
-                }
-                else if (node.paramChild.paramName !== paramName) {
-                    throw new Error(`Cannot have two different parameter names at the same level: "${node.paramChild.paramName}" and "${paramName}"`);
-                }
-                node = node.paramChild;
-            }
-            else {
-                if (!node.children.has(segment)) {
-                    node.children.set(segment, new Node());
-                }
-                node = node.children.get(segment);
-            }
-        }
-        node.data = { handler, priority };
-        node.staticMatch = { handler, priority, params: {} };
-    }
-    lookup(segments) {
-        return this.find(this.root, segments, 0);
-    }
-    lookupPath(path) {
-        if (path === '/' || path === '') {
-            if (this.root.staticMatch) {
-                return this.root.staticMatch;
-            }
-            return null;
-        }
-        const start = path.charCodeAt(0) === 47 ? 1 : 0;
-        return this.findPath(this.root, path, start);
-    }
-    findPath(node, path, start) {
-        // Handle trailing slash or end of path
-        if (start >= path.length) {
-            if (node.staticMatch) {
-                return node.staticMatch;
-            }
-            return null;
-        }
-        let end = path.indexOf('/', start);
-        if (end === -1) {
-            end = path.length;
-        }
-        const segment = path.substring(start, end);
-        const nextStart = end + 1;
-        // Skip empty segments (e.g. //) to match normalize behavior
-        if (segment.length === 0) {
-            return this.findPath(node, path, nextStart);
-        }
-        // 1. Try exact match
-        const child = node.children.get(segment);
-        if (child) {
-            const result = this.findPath(child, path, nextStart);
-            if (result)
-                return result;
-        }
-        // 2. Try param match
-        if (node.paramChild) {
-            const result = this.findPath(node.paramChild, path, nextStart);
-            if (result) {
-                // Clone params to avoid modifying shared staticMatch
-                const newParams = { ...result.params };
-                newParams[node.paramChild.paramName] = segment;
-                return {
-                    handler: result.handler,
-                    priority: result.priority,
-                    params: newParams
-                };
-            }
-        }
-        return null;
-    }
-    find(node, segments, index) {
-        if (index === segments.length) {
-            if (node.data) {
-                return {
-                    handler: node.data.handler,
-                    priority: node.data.priority,
-                    params: {},
-                };
-            }
-            return null;
-        }
-        const segment = segments[index];
-        // 1. Try exact match
-        const child = node.children.get(segment);
-        if (child) {
-            const result = this.find(child, segments, index + 1);
-            if (result) {
-                return result;
-            }
-        }
-        // 2. Try param match
-        if (node.paramChild) {
-            const result = this.find(node.paramChild, segments, index + 1);
-            if (result) {
-                // If match found down this path, add current param to it
-                result.params[node.paramChild.paramName] = segment;
-                return result;
-            }
-        }
-        return null;
-    }
-}
-exports.RadixTree = RadixTree;

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

@@ -1,34 +0,0 @@
-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 readonly staticRoutes;
-    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/router/router.js

@@ -1,186 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Router = void 0;
-const radix_tree_1 = require("./radix-tree");
-const types_1 = require("../core/types");
-class Router {
-    constructor() {
-        // Per-method route buckets
-        this.methodBuckets = new Map([
-            ['GET', []],
-            ['POST', []],
-            ['PUT', []],
-            ['DELETE', []],
-            ['PATCH', []],
-            ['HEAD', []],
-            ['OPTIONS', []],
-        ]);
-        // Derived structures (built at freeze time)
-        this.radixTrees = new Map();
-        // Fast lookup for static routes (no params)
-        this.staticRoutes = new Map([
-            ['GET', new Map()],
-            ['POST', new Map()],
-            ['PUT', new Map()],
-            ['DELETE', new Map()],
-            ['PATCH', new Map()],
-            ['HEAD', new Map()],
-            ['OPTIONS', new Map()],
-        ]);
-        // Freeze state
-        this.isFrozen = false;
-    }
-    register(method, path, handler, options) {
-        if (this.isFrozen) {
-            console.warn(`Router is frozen. Late route registration (${method} ${path}) may not be optimized.`);
-        }
-        const segments = this.normalize(path);
-        const bucket = this.methodBuckets.get(method);
-        if (bucket) {
-            bucket.push({
-                path,
-                segments,
-                handler,
-                priority: options?.priority ?? types_1.RoutePriority.STANDARD,
-                schema: options?.schema,
-            });
-        }
-    }
-    getRoutes() {
-        return this.methodBuckets;
-    }
-    match(method, path) {
-        // Fast path for frozen router
-        if (this.isFrozen) {
-            // 1. Try static match (O(1))
-            const staticMap = this.staticRoutes.get(method);
-            if (staticMap) {
-                const match = staticMap.get(path);
-                if (match) {
-                    return match;
-                }
-            }
-            // 2. Try radix tree match
-            const tree = this.radixTrees.get(method);
-            if (tree) {
-                const match = tree.lookupPath(path);
-                if (match) {
-                    return match;
-                }
-            }
-            return undefined;
-        }
-        // Slow path for unfrozen router (legacy behavior)
-        const segments = this.normalize(path);
-        const bucket = this.methodBuckets.get(method);
-        if (!bucket || bucket.length === 0) {
-            return undefined;
-        }
-        // Try to match against routes
-        for (const route of bucket) {
-            if (route.segments.length !== segments.length) {
-                continue;
-            }
-            const params = {};
-            let matched = true;
-            for (let i = 0; i < route.segments.length; i += 1) {
-                const pattern = route.segments[i];
-                const value = segments[i];
-                if (pattern.startsWith(':')) {
-                    const key = pattern.slice(1);
-                    params[key] = value;
-                }
-                else if (pattern !== value) {
-                    matched = false;
-                    break;
-                }
-            }
-            if (matched) {
-                return {
-                    handler: route.handler,
-                    params,
-                    priority: route.priority,
-                };
-            }
-        }
-        return undefined;
-    }
-    getAllowedMethods(path) {
-        const segments = this.normalize(path);
-        const methods = [];
-        for (const [method, routes] of this.methodBuckets.entries()) {
-            for (const route of routes) {
-                if (route.segments.length !== segments.length) {
-                    continue;
-                }
-                let matched = true;
-                for (let i = 0; i < route.segments.length; i += 1) {
-                    const pattern = route.segments[i];
-                    const value = segments[i];
-                    if (pattern.startsWith(':')) {
-                        continue;
-                    }
-                    if (pattern !== value) {
-                        matched = false;
-                        break;
-                    }
-                }
-                if (matched) {
-                    methods.push(method);
-                    break;
-                }
-            }
-        }
-        return methods;
-    }
-    /**
-     * Freeze the router after server starts.
-     * Prevents further route registration and builds derived structures for optimized matching.
-     */
-    freeze() {
-        if (this.isFrozen) {
-            return;
-        }
-        this.isFrozen = true;
-        // Build derived structures for faster matching
-        for (const [method, routes] of this.methodBuckets.entries()) {
-            const tree = new radix_tree_1.RadixTree();
-            const staticMap = this.staticRoutes.get(method);
-            for (const route of routes) {
-                tree.insert(route.segments, route.handler, route.priority);
-                // Check if route is static (no params)
-                let isStatic = true;
-                for (const segment of route.segments) {
-                    if (segment.startsWith(':')) {
-                        isStatic = false;
-                        break;
-                    }
-                }
-                if (isStatic) {
-                    // Optimization: Pre-allocate static match result
-                    // Note: we use route.path directly as key
-                    staticMap.set(route.path, {
-                        handler: route.handler,
-                        params: {},
-                        priority: route.priority,
-                    });
-                    // Also handle trailing slash or no trailing slash?
-                    // For strict matching, we use exact path.
-                    // QHTTPX seems to normalize, so /json/ and /json might be different?
-                    // route.path comes from user.
-                }
-            }
-            this.radixTrees.set(method, tree);
-        }
-    }
-    isFrozenRouter() {
-        return this.isFrozen;
-    }
-    normalize(path) {
-        if (!path || path === '/') {
-            return [];
-        }
-        return path.split('/').filter((segment) => segment.length > 0);
-    }
-}
-exports.Router = Router;

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

@@ -1,25 +0,0 @@
-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/testing/index.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestClient = void 0;
-exports.createTestClient = createTestClient;
-class TestClient {
-    constructor(app) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.server = null;
-        this.baseURL = '';
-        this.app = app;
-    }
-    /**
-     * Starts the server on a random port.
-     * Automatically called by request methods if not started.
-     */
-    async start() {
-        if (this.server)
-            return;
-        const { port } = await this.app.listen(0);
-        this.server = this.app.serverInstance;
-        this.baseURL = `http://127.0.0.1:${port}`;
-    }
-    async stop() {
-        if (this.server) {
-            await this.app.close();
-            this.server = null;
-        }
-    }
-    async request(method, path, options = {}) {
-        if (!this.server) {
-            await this.start();
-        }
-        const url = new URL(path, this.baseURL);
-        if (options.query) {
-            Object.entries(options.query).forEach(([k, v]) => {
-                url.searchParams.append(k, String(v));
-            });
-        }
-        const headers = options.headers || {};
-        let bodyPayload;
-        if (options.body) {
-            if (typeof options.body === 'object' &&
-                !(options.body instanceof Uint8Array) &&
-                !(options.body instanceof ArrayBuffer) &&
-                !(options.body instanceof FormData) &&
-                !(options.body instanceof URLSearchParams)) {
-                bodyPayload = JSON.stringify(options.body);
-                if (!headers['content-type']) {
-                    headers['content-type'] = 'application/json';
-                }
-            }
-            else {
-                bodyPayload = options.body;
-            }
-        }
-        return fetch(url, {
-            method,
-            headers,
-            body: bodyPayload,
-        });
-    }
-    get(path, options) {
-        return this.request('GET', path, options);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    post(path, body, options) {
-        return this.request('POST', path, { ...options, body });
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    put(path, body, options) {
-        return this.request('PUT', path, { ...options, body });
-    }
-    delete(path, options) {
-        return this.request('DELETE', path, options);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    patch(path, body, options) {
-        return this.request('PATCH', path, { ...options, body });
-    }
-}
-exports.TestClient = TestClient;
-function createTestClient(app) {
-    return new TestClient(app);
-}

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

@@ -1,3 +0,0 @@
-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/cookies.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseCookies = parseCookies;
-exports.serializeCookie = serializeCookie;
-function parseCookies(header) {
-    const list = {};
-    if (!header) {
-        return list;
-    }
-    header.split(';').forEach((cookie) => {
-        const parts = cookie.split('=');
-        const name = parts.shift()?.trim();
-        if (name) {
-            const value = parts.join('=');
-            list[name] = decodeURIComponent(value);
-        }
-    });
-    return list;
-}
-function serializeCookie(name, value, options = {}) {
-    let str = `${name}=${encodeURIComponent(value)}`;
-    if (options.maxAge) {
-        str += `; Max-Age=${Math.floor(options.maxAge)}`;
-    }
-    if (options.domain) {
-        str += `; Domain=${options.domain}`;
-    }
-    if (options.path) {
-        str += `; Path=${options.path}`;
-    }
-    else {
-        str += '; Path=/';
-    }
-    if (options.expires) {
-        str += `; Expires=${options.expires.toUTCString()}`;
-    }
-    if (options.httpOnly) {
-        str += '; HttpOnly';
-    }
-    if (options.secure) {
-        str += '; Secure';
-    }
-    if (options.sameSite) {
-        switch (options.sameSite) {
-            case 'lax':
-                str += '; SameSite=Lax';
-                break;
-            case 'strict':
-                str += '; SameSite=Strict';
-                break;
-            case 'none':
-                str += '; SameSite=None';
-                break;
-            default:
-                break;
-        }
-    }
-    return str;
-}

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

@@ -1,12 +0,0 @@
-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/logger.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLoggerMiddleware = createLoggerMiddleware;
-function createLoggerMiddleware(options = {}) {
-    const sink = options.sink ??
-        ((entry) => {
-            const status = entry.status;
-            let color = '\x1b[37m';
-            if (status >= 200 && status < 300) {
-                color = '\x1b[32m';
-            }
-            else if (status === 404) {
-                color = '\x1b[33m';
-            }
-            else if (status >= 500) {
-                color = '\x1b[34m';
-            }
-            else if (status >= 400) {
-                color = '\x1b[35m';
-            }
-            const reset = '\x1b[0m';
-            const prefix = entry.requestId ? `${entry.requestId} ` : '';
-            const line = `${prefix}${entry.method} ${entry.path} ${status} ${entry.durationMs}ms`;
-            console.log(`${color}${line}${reset}`);
-        });
-    return async (ctx, next) => {
-        const start = ctx.requestStart ?? Date.now();
-        try {
-            await next();
-        }
-        finally {
-            const durationMs = Math.max(1, Date.now() - start);
-            const method = ctx.req.method || 'GET';
-            const path = ctx.url.pathname;
-            const status = ctx.res.statusCode || 200;
-            sink({
-                method,
-                path,
-                status,
-                durationMs,
-                requestId: ctx.requestId,
-            }, ctx);
-        }
-    };
-}

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

@@ -1,6 +0,0 @@
-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/signals.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.attachSignalHandlers = attachSignalHandlers;
-function attachSignalHandlers(app, options = {}) {
-    const signals = options.signals ?? ['SIGINT', 'SIGTERM'];
-    const timeoutMs = options.timeoutMs ?? 10000;
-    let shuttingDown = false;
-    const handler = async (signal) => {
-        if (shuttingDown) {
-            return;
-        }
-        shuttingDown = true;
-        console.log(`Received ${signal}, shutting down...`);
-        const timer = setTimeout(() => {
-            console.error('Shutdown timed out, forcing exit. (some connections might be lost)');
-            process.exit(1);
-        }, timeoutMs);
-        try {
-            await app.shutdown();
-            clearTimeout(timer);
-            process.exit(0);
-        }
-        catch (err) {
-            console.error('Error during shutdown:', err);
-            process.exit(1);
-        }
-    };
-    for (const signal of signals) {
-        process.on(signal, handler);
-    }
-}

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

@@ -1,6 +0,0 @@
-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/utils/sse.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSSE = createSSE;
-function createSSE(ctx) {
-    const res = ctx.res;
-    // Disable auto-end so we can keep the connection open
-    ctx.disableAutoEnd = true;
-    // Only write headers if not already sent
-    if (!res.headersSent) {
-        res.setHeader('Content-Type', 'text/event-stream');
-        res.setHeader('Cache-Control', 'no-cache');
-        res.setHeader('Connection', 'keep-alive');
-        res.setHeader('X-Accel-Buffering', 'no'); // For Nginx
-        // Send initial ping/comment to flush headers and establish connection
-        res.write(': connected\n\n');
-    }
-    const send = (data, event, id) => {
-        if (id)
-            res.write(`id: ${id}\n`);
-        if (event)
-            res.write(`event: ${event}\n`);
-        const payload = typeof data === 'string' ? data : JSON.stringify(data);
-        res.write(`data: ${payload}\n\n`);
-    };
-    const close = () => {
-        res.end();
-    };
-    ctx.req.on('close', () => {
-        // console.log('SSE client disconnected');
-    });
-    return { send, close };
-}

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

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