qhttpx 1.8.11 → 1.9.0

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

@@ -1,45 +0,0 @@
-import type { TaskEngine, TaskMetrics } from './tasks';
-import { Scheduler } from './scheduler';
-export type LatencySnapshot = {
-    p50: number | null;
-    p95: number | null;
-    p99: number | null;
-};
-export type MetricsSnapshot = {
-    totalRequests: number;
-    inFlightRequests: number;
-    totalErrors: number;
-    totalTimeouts: number;
-    requestsPerSecond: number;
-    latency: LatencySnapshot;
-    scheduler: {
-        inFlight: number;
-    };
-    tasks?: TaskMetrics;
-    memory: {
-        rssBytes: number;
-        heapUsedBytes: number;
-    };
-};
-export declare class Metrics {
-    private readonly scheduler;
-    private readonly taskEngine?;
-    private readonly latencies;
-    private readonly maxLatencies;
-    private readonly enabled;
-    private totalRequests;
-    private inFlightRequests;
-    private totalErrors;
-    private totalTimeouts;
-    constructor(scheduler: Scheduler, options?: {
-        maxLatencies?: number;
-        enabled?: boolean;
-    }, taskEngine?: TaskEngine);
-    onRequestStart(): void;
-    onRequestEnd(durationMs: number, statusCode: number): void;
-    onTimeout(): void;
-    snapshot(): MetricsSnapshot;
-    private recordLatency;
-    private latencySnapshot;
-    private percentile;
-}

package/dist/src/core/metrics.js

@@ -1,111 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Metrics = void 0;
-class Metrics {
-    constructor(scheduler, options = {}, taskEngine) {
-        this.latencies = [];
-        this.totalRequests = 0;
-        this.inFlightRequests = 0;
-        this.totalErrors = 0;
-        this.totalTimeouts = 0;
-        this.scheduler = scheduler;
-        this.taskEngine = taskEngine;
-        this.maxLatencies = options.maxLatencies ?? 1000;
-        this.enabled = options.enabled ?? true;
-    }
-    onRequestStart() {
-        if (!this.enabled) {
-            return;
-        }
-        this.inFlightRequests += 1;
-    }
-    onRequestEnd(durationMs, statusCode) {
-        if (!this.enabled) {
-            return;
-        }
-        this.totalRequests += 1;
-        if (this.inFlightRequests > 0) {
-            this.inFlightRequests -= 1;
-        }
-        if (statusCode >= 500) {
-            this.totalErrors += 1;
-        }
-        this.recordLatency(durationMs);
-    }
-    onTimeout() {
-        if (!this.enabled) {
-            return;
-        }
-        this.totalTimeouts += 1;
-    }
-    snapshot() {
-        const uptime = process.uptime();
-        const requestsPerSecond = uptime > 0 ? this.totalRequests / uptime : this.totalRequests;
-        const latency = this.latencySnapshot();
-        const memoryUsage = process.memoryUsage();
-        let tasks;
-        if (this.taskEngine) {
-            tasks = this.taskEngine.getMetrics();
-        }
-        return {
-            totalRequests: this.totalRequests,
-            inFlightRequests: this.inFlightRequests,
-            totalErrors: this.totalErrors,
-            totalTimeouts: this.totalTimeouts,
-            requestsPerSecond,
-            latency,
-            scheduler: {
-                inFlight: this.scheduler.getCurrentInFlight(),
-            },
-            tasks,
-            memory: {
-                rssBytes: memoryUsage.rss,
-                heapUsedBytes: memoryUsage.heapUsed,
-            },
-        };
-    }
-    recordLatency(durationMs) {
-        if (!this.enabled) {
-            return;
-        }
-        if (!Number.isFinite(durationMs) || durationMs < 0) {
-            return;
-        }
-        this.latencies.push(durationMs);
-        if (this.latencies.length > this.maxLatencies) {
-            this.latencies.shift();
-        }
-    }
-    latencySnapshot() {
-        if (this.latencies.length === 0) {
-            return {
-                p50: null,
-                p95: null,
-                p99: null,
-            };
-        }
-        const sorted = [...this.latencies].sort((a, b) => a - b);
-        const p50 = this.percentile(sorted, 0.5);
-        const p95 = this.percentile(sorted, 0.95);
-        const p99 = this.percentile(sorted, 0.99);
-        return {
-            p50,
-            p95,
-            p99,
-        };
-    }
-    percentile(sorted, p) {
-        if (sorted.length === 0) {
-            return 0;
-        }
-        if (p <= 0) {
-            return sorted[0];
-        }
-        if (p >= 1) {
-            return sorted[sorted.length - 1];
-        }
-        const index = Math.floor(p * (sorted.length - 1));
-        return sorted[index];
-    }
-}
-exports.Metrics = Metrics;

package/dist/src/core/native-adapter.d.ts

@@ -1,11 +0,0 @@
-import net from 'net';
-import { QHTTPX } from './server';
-export declare class NativeAdapter {
-    private app;
-    private nativeServer;
-    private responsePool;
-    constructor(app: QHTTPX);
-    listen(port: number, cb?: () => void): net.Server | Promise<{
-        port: number;
-    }>;
-}

package/dist/src/core/native-adapter.js

@@ -1,211 +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.NativeAdapter = void 0;
-const net_1 = __importDefault(require("net"));
-const stream_1 = require("stream");
-const native_1 = require("../native");
-class MockIncomingMessage extends stream_1.Readable {
-    constructor(socket, method, url, headers) {
-        super();
-        this.httpVersion = '1.1';
-        this.socket = socket;
-        this.method = method;
-        this.url = url;
-        this.headers = headers;
-    }
-    _read() {
-        // No-op, data is pushed manually
-    }
-}
-class MockServerResponse extends stream_1.Writable {
-    constructor(socket, nativeServer) {
-        super();
-        this.statusCode = 200;
-        this.headersSent = false;
-        this.headers = {};
-        this.socket = socket;
-        this.nativeServer = nativeServer;
-    }
-    setHeader(name, value) {
-        this.headers[name.toLowerCase()] = value;
-        return this;
-    }
-    getHeader(name) {
-        return this.headers[name.toLowerCase()];
-    }
-    getHeaders() {
-        return { ...this.headers };
-    }
-    hasHeader(name) {
-        return Object.prototype.hasOwnProperty.call(this.headers, name.toLowerCase());
-    }
-    removeHeader(name) {
-        delete this.headers[name.toLowerCase()];
-    }
-    writeHead(statusCode, headers) {
-        this.statusCode = statusCode;
-        if (headers) {
-            for (const key in headers) {
-                this.setHeader(key, headers[key]);
-            }
-        }
-        return this;
-    }
-    reset(socket) {
-        this.socket = socket;
-        this.statusCode = 200;
-        this.headersSent = false;
-        this.headers = {};
-        this.removeAllListeners();
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    _write(chunk, encoding, callback) {
-        if (!this.headersSent) {
-            this.sendHeaders();
-        }
-        this.socket.write(chunk, encoding, callback);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    end(arg1, arg2, arg3) {
-        if (arg1 && typeof arg1 !== 'function') {
-            if (!this.headersSent) {
-                // Optimization: Use native createResponse / createJSONResponse if possible
-                try {
-                    let respBuffer;
-                    // Check for JSON object (not buffer/string)
-                    if (typeof arg1 === 'object' && !Buffer.isBuffer(arg1)) {
-                        respBuffer = this.nativeServer.createJSONResponse(arg1);
-                    }
-                    else {
-                        const body = arg1;
-                        const headers = {};
-                        for (const k in this.headers) {
-                            const v = this.headers[k];
-                            headers[k] = Array.isArray(v) ? v.join(', ') : String(v);
-                        }
-                        respBuffer = this.nativeServer.createResponse(this.statusCode, headers, body);
-                    }
-                    // Try direct writeResponse if FD is available
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const fd = this.socket._handle?.fd;
-                    if (typeof fd === 'number' && fd >= 0) {
-                        this.nativeServer.writeResponse(fd, [respBuffer]);
-                    }
-                    else {
-                        this.socket.write(respBuffer);
-                    }
-                    this.headersSent = true;
-                    if (arg2 && typeof arg2 === 'function')
-                        arg2();
-                    else if (arg3 && typeof arg3 === 'function')
-                        arg3();
-                    return this;
-                }
-                catch {
-                    // Fallback
-                }
-            }
-            this.write(arg1, arg2);
-        }
-        if (!this.headersSent) {
-            this.sendHeaders();
-        }
-        super.end();
-        if (arg1 && typeof arg1 === 'function')
-            arg1();
-        else if (arg2 && typeof arg2 === 'function')
-            arg2();
-        else if (arg3 && typeof arg3 === 'function')
-            arg3();
-        return this;
-    }
-    sendHeaders() {
-        let head = `HTTP/1.1 ${this.statusCode} OK\r\n`; // Status msg todo
-        for (const key in this.headers) {
-            const val = this.headers[key];
-            if (Array.isArray(val)) {
-                for (const v of val) {
-                    head += `${key}: ${v}\r\n`;
-                }
-            }
-            else {
-                head += `${key}: ${val}\r\n`;
-            }
-        }
-        head += '\r\n';
-        this.socket.write(head);
-        this.headersSent = true;
-    }
-}
-class MockResponsePool {
-    constructor(nativeServer) {
-        this.pool = [];
-        this.nativeServer = nativeServer;
-    }
-    acquire(socket) {
-        const res = this.pool.pop();
-        if (res) {
-            res.reset(socket);
-            return res;
-        }
-        return new MockServerResponse(socket, this.nativeServer);
-    }
-    release(res) {
-        // Simple cap to prevent memory leak if something goes wrong
-        if (this.pool.length < 2000) {
-            this.pool.push(res);
-        }
-    }
-}
-class NativeAdapter {
-    constructor(app) {
-        this.app = app;
-        this.nativeServer = new native_1.NativeServer();
-        this.responsePool = new MockResponsePool(this.nativeServer);
-    }
-    listen(port, cb) {
-        if (!this.nativeServer.isAvailable) {
-            console.warn('Native server not available, falling back to Node.js HTTP');
-            return this.app.listen(port, cb);
-        }
-        const server = net_1.default.createServer((socket) => {
-            let buffer = Buffer.alloc(0);
-            socket.on('data', (chunk) => {
-                buffer = buffer.length === 0 ? chunk : Buffer.concat([buffer, chunk]);
-                // Try parsing
-                const res = this.nativeServer.parse(buffer);
-                if (res) {
-                    // Parsed successfully
-                    const req = new MockIncomingMessage(socket, res.method, res.path, res.headers);
-                    const response = this.responsePool.acquire(socket);
-                    response.on('finish', () => {
-                        this.responsePool.release(response);
-                    });
-                    // Push body if any
-                    if (res.bodyOffset < buffer.length) {
-                        req.push(buffer.slice(res.bodyOffset));
-                    }
-                    req.push(null); // End of body (assuming single packet for now or content-length handling needed for real impl)
-                    // Reset buffer for pipelining support (not implemented here, assuming connection: close or one req per packet for simplicity)
-                    buffer = Buffer.alloc(0);
-                    // Dispatch to QHTTPX
-                    this.app.handleRequest(req, response);
-                }
-                else if (res === null) {
-                    // Error
-                    socket.destroy();
-                }
-                // else undefined -> partial, wait for more data
-            });
-            socket.on('error', () => {
-                // console.error(err);
-            });
-        });
-        server.listen(port, cb);
-        return server;
-    }
-}
-exports.NativeAdapter = NativeAdapter;

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

@@ -1,9 +0,0 @@
-export type WorkerSetting = 'auto' | number;
-export declare function calculateWorkerCount(setting: WorkerSetting): number;
-export type ResourceThresholds = {
-    maxRssBytes?: number;
-};
-export type ResourceSample = {
-    rssBytes: number;
-};
-export declare function isResourceOverloaded(sample: ResourceSample, thresholds: ResourceThresholds): boolean;

package/dist/src/core/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/core/scheduler.d.ts

@@ -1,34 +0,0 @@
-import { RoutePriority } from './types';
-export type SchedulerOptions = {
-    maxConcurrency?: number;
-    workers?: number;
-};
-export type RunOptions = {
-    priority?: RoutePriority;
-    onOverloaded?: () => void;
-    timeoutMs?: number;
-    onTimeout?: () => void;
-};
-export type SchedulerStats = {
-    inFlight: number;
-    maxConcurrency: number;
-    workers: number;
-    perWorkerStats: {
-        workerId: number;
-        queued: number;
-    }[];
-};
-export declare class Scheduler {
-    private inFlight;
-    private readonly maxConcurrency;
-    private readonly workerCount;
-    private readonly perWorkerQueues;
-    private nextWorkerIndex;
-    constructor(options?: SchedulerOptions);
-    getCurrentInFlight(): number;
-    /**
-     * Get scheduler statistics (queued tasks per worker, etc.)
-     */
-    getStats(): SchedulerStats;
-    run(task: () => void | Promise<void>, options: RunOptions): Promise<void>;
-}

package/dist/src/core/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/core/scope.d.ts

@@ -1,26 +0,0 @@
-import { QHTTPX } from './server';
-import { QHTTPXHandler, QHTTPXRouteOptions, QHTTPXMiddleware, QHTTPXPlugin, QHTTPXPluginOptions } from './types';
-/**
- * A Scope represents a prefixed or isolated context for plugins.
- * It proxies methods to the main QHTTPX instance but handles prefixing.
- */
-export declare class QHTTPXScope {
-    private readonly app;
-    private readonly prefix;
-    constructor(app: QHTTPX, prefix?: string);
-    /**
-     * Registers a sub-plugin within this scope.
-     * Prefixes are concatenated (e.g. /v1 + /users = /v1/users).
-     */
-    register<Options extends QHTTPXPluginOptions>(plugin: QHTTPXPlugin<Options>, options?: Options): Promise<void>;
-    use(middleware: QHTTPXMiddleware): void;
-    get(path: string, handler: QHTTPXHandler | QHTTPXRouteOptions): void;
-    post(path: string, handler: QHTTPXHandler | QHTTPXRouteOptions): void;
-    put(path: string, handler: QHTTPXHandler | QHTTPXRouteOptions): void;
-    delete(path: string, handler: QHTTPXHandler | QHTTPXRouteOptions): void;
-    patch(path: string, handler: QHTTPXHandler | QHTTPXRouteOptions): void;
-    options(path: string, handler: QHTTPXHandler | QHTTPXRouteOptions): void;
-    head(path: string, handler: QHTTPXHandler | QHTTPXRouteOptions): void;
-    getApp(): QHTTPX;
-    private joinPaths;
-}

package/dist/src/core/scope.js

@@ -1,68 +0,0 @@
-"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.d.ts

@@ -1,10 +0,0 @@
-/**
- * Fast JSON serializer using fast-json-stringify
- * For best performance, use schema-based stringifiers per route
- */
-export declare function fastJsonStringify(value: unknown, schema?: unknown): string;
-/**
- * Get a pre-compiled stringifier for a specific schema
- * Use this in route handlers for maximum performance
- */
-export declare function getStringifier(schema: unknown): (value: unknown) => string;

package/dist/src/core/serializer.js

@@ -1,44 +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.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;
-}