qhttpx 1.9.1 → 1.9.3

package/dist/src/router/router.js

@@ -0,0 +1,186 @@
+"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/router.js

@@ -0,0 +1,138 @@
+"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

@@ -0,0 +1,85 @@
+"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

@@ -0,0 +1,69 @@
+"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();
+    };
+}