qhttpx 1.9.4 → 2.0.1

package/dist/src/radix-router.js

@@ -1,89 +0,0 @@
-"use strict";
-/**
- * Radix tree router compiled into a flat array structure for zero-allocation matching.
- * Built once at server startup (frozen).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RadixRouter = void 0;
-class RadixRouter {
-    constructor() {
-        this.roots = new Map();
-        this.isFrozen = false;
-    }
-    register(method, path, handler) {
-        if (this.isFrozen) {
-            console.warn(`Radix router is frozen. Late route registration (${method} ${path}) may not be optimized.`);
-        }
-        if (!this.roots.has(method)) {
-            this.roots.set(method, {});
-        }
-        const root = this.roots.get(method);
-        const segments = this.normalize(path);
-        let node = root;
-        for (const segment of segments) {
-            if (!node.children) {
-                node.children = new Map();
-            }
-            const isParam = segment.startsWith(':');
-            const key = isParam ? segment.slice(1) : segment;
-            if (!node.children.has(key)) {
-                node.children.set(key, {
-                    paramKey: isParam ? key : undefined,
-                });
-            }
-            node = node.children.get(key);
-        }
-        node.handler = handler;
-    }
-    match(method, path) {
-        const root = this.roots.get(method);
-        if (!root) {
-            return undefined;
-        }
-        const segments = this.normalize(path);
-        const params = {};
-        let node = root;
-        for (const segment of segments) {
-            if (!node.children) {
-                return undefined;
-            }
-            // Try exact match first
-            let child = node.children.get(segment);
-            // If no exact match, try param match
-            if (!child) {
-                for (const [key, candidate] of node.children.entries()) {
-                    if (candidate.paramKey && typeof key === 'string') {
-                        params[key] = segment;
-                        child = candidate;
-                        break;
-                    }
-                }
-            }
-            if (!child) {
-                return undefined;
-            }
-            node = child;
-        }
-        if (!node.handler) {
-            return undefined;
-        }
-        return { handler: node.handler, params };
-    }
-    freeze() {
-        if (this.isFrozen) {
-            return;
-        }
-        this.isFrozen = true;
-        // Future: compile to flat array structure here
-    }
-    isFrozenRouter() {
-        return this.isFrozen;
-    }
-    normalize(path) {
-        if (!path || path === '/') {
-            return [];
-        }
-        return path.split('/').filter((segment) => segment.length > 0);
-    }
-}
-exports.RadixRouter = RadixRouter;

package/dist/src/radix-tree.js

@@ -1,81 +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;
-    }
-}
-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 };
-    }
-    lookup(segments) {
-        // Use a stack-based approach or recursion. 
-        // For simplicity and correctness with backtracking, we'll use recursion.
-        // To minimize allocations, we pass the same params object and only copy on success?
-        // Actually, creating a params object is inevitable for the result.
-        return this.find(this.root, segments, 0);
-    }
-    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/resources.js

@@ -1,25 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateWorkerCount = calculateWorkerCount;
-exports.isResourceOverloaded = isResourceOverloaded;
-const os_1 = __importDefault(require("os"));
-function calculateWorkerCount(setting) {
-    if (typeof setting === 'number') {
-        if (!Number.isFinite(setting) || setting <= 0) {
-            return 1;
-        }
-        return Math.floor(setting);
-    }
-    const cpuCount = os_1.default.cpus().length || 1;
-    return Math.max(1, cpuCount);
-}
-function isResourceOverloaded(sample, thresholds) {
-    if (thresholds.maxRssBytes !== undefined &&
-        sample.rssBytes > thresholds.maxRssBytes) {
-        return true;
-    }
-    return false;
-}

package/dist/src/router.js

@@ -1,138 +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("./types");
-class Router {
-    constructor() {
-        // Per-method route buckets
-        this.methodBuckets = new Map([
-            ['GET', []],
-            ['POST', []],
-            ['PUT', []],
-            ['DELETE', []],
-        ]);
-        // Derived structures (built at freeze time)
-        this.radixTrees = 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({
-                segments,
-                handler,
-                priority: options?.priority ?? types_1.RoutePriority.STANDARD,
-            });
-        }
-    }
-    match(method, path) {
-        // Fast path for frozen router
-        if (this.isFrozen) {
-            const tree = this.radixTrees.get(method);
-            if (tree) {
-                const segments = this.normalize(path);
-                const match = tree.lookup(segments);
-                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();
-            for (const route of routes) {
-                tree.insert(route.segments, route.handler, route.priority);
-            }
-            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/scheduler.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Scheduler = void 0;
-const worker_queue_1 = require("./worker-queue");
-const types_1 = require("./types");
-class Scheduler {
-    constructor(options = {}) {
-        this.inFlight = 0;
-        this.nextWorkerIndex = 0;
-        const max = options.maxConcurrency ?? Infinity;
-        this.maxConcurrency = max > 0 ? max : Infinity;
-        // Initialize per-worker queues
-        this.workerCount = options.workers ?? 1;
-        this.perWorkerQueues = [];
-        for (let i = 0; i < this.workerCount; i += 1) {
-            this.perWorkerQueues.push(new worker_queue_1.WorkerQueue(1024));
-        }
-    }
-    getCurrentInFlight() {
-        return this.inFlight;
-    }
-    /**
-     * Get scheduler statistics (queued tasks per worker, etc.)
-     */
-    getStats() {
-        return {
-            inFlight: this.inFlight,
-            maxConcurrency: this.maxConcurrency,
-            workers: this.workerCount,
-            perWorkerStats: this.perWorkerQueues.map((q, i) => ({
-                workerId: i,
-                queued: q.getSize(),
-            })),
-        };
-    }
-    async run(task, options) {
-        const priority = options.priority ?? types_1.RoutePriority.STANDARD;
-        let threshold = this.maxConcurrency;
-        if (priority === types_1.RoutePriority.BEST_EFFORT) {
-            // Shed best-effort requests if we are above 80% capacity
-            threshold = Math.max(1, Math.floor(this.maxConcurrency * 0.8));
-        }
-        else if (priority === types_1.RoutePriority.STANDARD) {
-            // Shed standard requests if we are above 95% capacity
-            threshold = Math.max(1, Math.floor(this.maxConcurrency * 0.95));
-        }
-        // CRITICAL allows up to 100%
-        if (this.inFlight >= threshold) {
-            if (options.onOverloaded) {
-                options.onOverloaded();
-            }
-            return;
-        }
-        this.inFlight += 1;
-        let timeoutId;
-        try {
-            if (!options.timeoutMs || options.timeoutMs <= 0) {
-                const result = task();
-                if (result && typeof result.then === 'function') {
-                    await result;
-                }
-                return;
-            }
-            const taskPromise = Promise.resolve(task()).then(() => 'ok');
-            const timeoutPromise = new Promise((resolve) => {
-                timeoutId = setTimeout(() => {
-                    resolve('timeout');
-                }, options.timeoutMs);
-            });
-            const result = await Promise.race([taskPromise, timeoutPromise]);
-            if (result === 'timeout') {
-                if (options.onTimeout) {
-                    options.onTimeout();
-                }
-            }
-        }
-        finally {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-            }
-            this.inFlight -= 1;
-        }
-    }
-}
-exports.Scheduler = Scheduler;

package/dist/src/security.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSecurityHeadersMiddleware = createSecurityHeadersMiddleware;
-exports.createSecureDefaults = createSecureDefaults;
-exports.createRateLimitMiddleware = createRateLimitMiddleware;
-const cors_1 = require("./cors");
-function createSecurityHeadersMiddleware(options = {}) {
-    const { contentSecurityPolicy = "default-src 'self'", referrerPolicy = 'no-referrer', xFrameOptions = 'SAMEORIGIN', xContentTypeOptions = 'nosniff', xXssProtection = '1; mode=block', strictTransportSecurity, } = options;
-    return async (ctx, next) => {
-        if (contentSecurityPolicy) {
-            ctx.res.setHeader('content-security-policy', contentSecurityPolicy);
-        }
-        if (referrerPolicy) {
-            ctx.res.setHeader('referrer-policy', referrerPolicy);
-        }
-        if (xFrameOptions) {
-            ctx.res.setHeader('x-frame-options', xFrameOptions);
-        }
-        if (xContentTypeOptions) {
-            ctx.res.setHeader('x-content-type-options', xContentTypeOptions);
-        }
-        if (xXssProtection) {
-            ctx.res.setHeader('x-xss-protection', xXssProtection);
-        }
-        if (strictTransportSecurity) {
-            ctx.res.setHeader('strict-transport-security', strictTransportSecurity);
-        }
-        await next();
-    };
-}
-function createSecureDefaults(options = {}) {
-    const middlewares = [];
-    middlewares.push((0, cors_1.createCorsMiddleware)(options.cors));
-    middlewares.push(createSecurityHeadersMiddleware(options.securityHeaders));
-    return middlewares;
-}
-function createRateLimitMiddleware(options) {
-    const maxRequests = options.maxRequests;
-    const windowMs = options.windowMs;
-    const keyGenerator = options.keyGenerator ??
-        ((ctx) => {
-            const addr = ctx.req.socket.remoteAddress;
-            return addr || 'anonymous';
-        });
-    const buckets = new Map();
-    return async (ctx, next) => {
-        const now = Date.now();
-        const key = keyGenerator(ctx);
-        const existing = buckets.get(key);
-        let bucket = existing;
-        if (!bucket || bucket.resetAt <= now) {
-            bucket = {
-                count: 0,
-                resetAt: now + windowMs,
-            };
-            buckets.set(key, bucket);
-        }
-        bucket.count += 1;
-        if (bucket.count > maxRequests) {
-            if (!ctx.res.headersSent) {
-                ctx.res.statusCode = 429;
-                ctx.res.setHeader('content-type', 'text/plain; charset=utf-8');
-            }
-            ctx.res.end('Too Many Requests');
-            return;
-        }
-        await next();
-    };
-}