qhttpx 1.8.0

package/dist/src/core/resources.js

@@ -0,0 +1,25 @@
+"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/core/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/core/scope.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QHTTPXScope = void 0;
+/**
+ * A Scope represents a prefixed or isolated context for plugins.
+ * It proxies methods to the main QHTTPX instance but handles prefixing.
+ */
+class QHTTPXScope {
+    constructor(app, prefix = '') {
+        this.app = app;
+        this.prefix = prefix;
+    }
+    /**
+     * Registers a sub-plugin within this scope.
+     * Prefixes are concatenated (e.g. /v1 + /users = /v1/users).
+     */
+    async register(plugin, options) {
+        const newPrefix = this.joinPaths(this.prefix, options?.prefix || '');
+        const scope = new QHTTPXScope(this.app, newPrefix);
+        await plugin(scope, options);
+    }
+    use(middleware) {
+        // Middleware in scopes is currently global (TODO: Encapsulated middleware)
+        this.app.use(middleware);
+    }
+    get(path, handler) {
+        this.app._registerRoute('GET', this.joinPaths(this.prefix, path), handler);
+    }
+    post(path, handler) {
+        this.app._registerRoute('POST', this.joinPaths(this.prefix, path), handler);
+    }
+    put(path, handler) {
+        this.app._registerRoute('PUT', this.joinPaths(this.prefix, path), handler);
+    }
+    delete(path, handler) {
+        this.app._registerRoute('DELETE', this.joinPaths(this.prefix, path), handler);
+    }
+    patch(path, handler) {
+        this.app._registerRoute('PATCH', this.joinPaths(this.prefix, path), handler);
+    }
+    options(path, handler) {
+        this.app._registerRoute('OPTIONS', this.joinPaths(this.prefix, path), handler);
+    }
+    head(path, handler) {
+        this.app._registerRoute('HEAD', this.joinPaths(this.prefix, path), handler);
+    }
+    // Helper to access the main app if needed
+    getApp() {
+        return this.app;
+    }
+    joinPaths(head, tail) {
+        if (!head)
+            return tail;
+        if (!tail)
+            return head;
+        // Ensure clean slash joining
+        const headSlash = head.endsWith('/');
+        const tailSlash = tail.startsWith('/');
+        if (headSlash && tailSlash) {
+            return head + tail.slice(1);
+        }
+        if (!headSlash && !tailSlash) {
+            return head + '/' + tail;
+        }
+        return head + tail;
+    }
+}
+exports.QHTTPXScope = QHTTPXScope;

package/dist/src/core/serializer.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fastJsonStringify = fastJsonStringify;
+exports.getStringifier = getStringifier;
+const fast_json_stringify_1 = __importDefault(require("fast-json-stringify"));
+// Cache of compiled stringifiers per schema
+const stringifierCache = new Map();
+// Default fast JSON stringifier for generic objects
+const defaultStringifier = (0, fast_json_stringify_1.default)({
+    type: 'object',
+    additionalProperties: true,
+});
+/**
+ * Fast JSON serializer using fast-json-stringify
+ * For best performance, use schema-based stringifiers per route
+ */
+function fastJsonStringify(value, schema) {
+    if (schema) {
+        const schemaKey = JSON.stringify(schema);
+        let stringifier = stringifierCache.get(schemaKey);
+        if (!stringifier) {
+            stringifier = (0, fast_json_stringify_1.default)(schema);
+            stringifierCache.set(schemaKey, stringifier);
+        }
+        return stringifier(value);
+    }
+    return defaultStringifier(value);
+}
+/**
+ * Get a pre-compiled stringifier for a specific schema
+ * Use this in route handlers for maximum performance
+ */
+function getStringifier(schema) {
+    const schemaKey = JSON.stringify(schema);
+    let stringifier = stringifierCache.get(schemaKey);
+    if (!stringifier) {
+        stringifier = (0, fast_json_stringify_1.default)(schema);
+        stringifierCache.set(schemaKey, stringifier);
+    }
+    return stringifier;
+}