qhttpx 1.8.12 → 1.9.1

package/dist/src/core/fusion.js

@@ -1,183 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequestFusion = void 0;
-const crypto_1 = require("crypto");
-class RequestFusion {
-    constructor(options = {}) {
-        this.inflight = new Map();
-        this.cache = new Map();
-        this.options = typeof options === 'boolean' ? {} : options;
-        if (!this.options.vary) {
-            this.options.vary = ['authorization', 'cookie'];
-        }
-    }
-    async coalesce(ctx, next) {
-        const key = this.getKey(ctx);
-        // 1. Check Cache (Short-lived "Micro-TTL")
-        if (this.options.windowMs && this.options.windowMs > 0) {
-            const cached = this.cache.get(key);
-            if (cached) {
-                if (Date.now() < cached.expires) {
-                    this.applyResult(ctx, cached.result);
-                    return;
-                }
-                else {
-                    this.cache.delete(key);
-                }
-            }
-        }
-        // 2. Check In-Flight
-        if (this.inflight.has(key)) {
-            try {
-                const result = await this.inflight.get(key);
-                this.applyResult(ctx, result);
-                return;
-            }
-            catch (err) {
-                // If leader failed, we should probably fail too or retry?
-                // For now, let's propagate the error.
-                throw err;
-            }
-        }
-        // 3. Be the Leader
-        let resolve;
-        let reject;
-        const promise = new Promise((res, rej) => {
-            resolve = res;
-            reject = rej;
-        });
-        this.inflight.set(key, promise);
-        // Hijack context methods to capture result
-        // Cast to any to allow overwriting readonly methods
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const mutableCtx = ctx;
-        const originalJson = mutableCtx.json;
-        const originalSend = mutableCtx.send;
-        const originalHtml = mutableCtx.html;
-        const originalRedirect = mutableCtx.redirect;
-        let captured = false;
-        // Helper to cleanup and resolve
-        const finish = (result) => {
-            if (captured)
-                return;
-            captured = true;
-            resolve(result);
-            // Cache if needed
-            if (this.options.windowMs && this.options.windowMs > 0) {
-                this.cache.set(key, {
-                    result,
-                    expires: Date.now() + this.options.windowMs
-                });
-                // Cleanup cache later
-                setTimeout(() => this.cache.delete(key), this.options.windowMs);
-            }
-            // Remove from inflight immediately (unless we rely on cache for window)
-            // Actually, if we have windowMs, we rely on cache.
-            // If windowMs=0, we remove immediately.
-            this.inflight.delete(key);
-        };
-        mutableCtx.json = (payload, status = 200) => {
-            finish({ type: 'json', payload, status });
-            return originalJson.call(ctx, payload, status);
-        };
-        mutableCtx.send = (payload, status = 200) => {
-            finish({ type: 'send', payload, status });
-            return originalSend.call(ctx, payload, status);
-        };
-        mutableCtx.html = (payload, status = 200) => {
-            finish({ type: 'html', payload, status });
-            return originalHtml.call(ctx, payload, status);
-        };
-        mutableCtx.redirect = (url, status = 302) => {
-            finish({ type: 'redirect', payload: url, status });
-            return originalRedirect.call(ctx, url, status);
-        };
-        try {
-            await next(ctx);
-            // If next() completes but no response method was called, 
-            // it implies the handler might be async and forgot to await, 
-            // or it's a 404/middleware issue.
-            // If not captured yet, we can't resolve the followers properly.
-            // They will hang unless we reject or resolve with something.
-            // However, typical QHTTPX usage implies ctx.json/send is called.
-        }
-        catch (err) {
-            reject(err);
-            this.inflight.delete(key);
-            // Restore methods
-            mutableCtx.json = originalJson;
-            mutableCtx.send = originalSend;
-            mutableCtx.html = originalHtml;
-            mutableCtx.redirect = originalRedirect;
-            throw err;
-        }
-    }
-    applyResult(ctx, result) {
-        switch (result.type) {
-            case 'json':
-                ctx.json(result.payload, result.status);
-                break;
-            case 'send': {
-                if (typeof result.payload === 'string' || Buffer.isBuffer(result.payload)) {
-                    ctx.send(result.payload, result.status);
-                }
-                else {
-                    ctx.send(String(result.payload), result.status);
-                }
-                break;
-            }
-            case 'html': {
-                if (typeof result.payload === 'string') {
-                    ctx.html(result.payload, result.status);
-                }
-                else {
-                    ctx.html(String(result.payload), result.status);
-                }
-                break;
-            }
-            case 'redirect': {
-                if (typeof result.payload === 'string') {
-                    ctx.redirect(result.payload, result.status);
-                }
-                else {
-                    ctx.redirect(String(result.payload), result.status);
-                }
-                break;
-            }
-        }
-    }
-    getKey(ctx) {
-        // Base: Method + Path
-        let data = `${ctx.req.method}|${ctx.url?.pathname}|`;
-        // Query
-        if (ctx.query) {
-            // Deterministic sort
-            const keys = Object.keys(ctx.query).sort();
-            for (const k of keys) {
-                data += `${k}=${ctx.query[k]}|`;
-            }
-        }
-        // Body (if parsed)
-        if (ctx.body) {
-            // We assume body is simple JSON.
-            // For objects, order matters for hashing.
-            // fast-json-stringify or JSON.stringify isn't always deterministic key order.
-            // But for performance, JSON.stringify is often "good enough" if keys aren't shuffled.
-            // For strict correctness, we should use a canonical stringify, but that's slow.
-            // Let's use JSON.stringify for now.
-            data += JSON.stringify(ctx.body);
-        }
-        // Vary Headers
-        if (this.options.vary) {
-            for (const header of this.options.vary) {
-                const val = ctx.req.headers[header.toLowerCase()];
-                if (val) {
-                    data += `|${header}:${val}`;
-                }
-            }
-        }
-        // We hash it to keep the key size manageable
-        return (0, crypto_1.createHash)('sha1').update(data).digest('hex');
-    }
-}
-exports.RequestFusion = RequestFusion;

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

@@ -1,22 +0,0 @@
-import pino from 'pino';
-export type LogLevel = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace';
-export interface LoggerOptions {
-    level?: LogLevel;
-    pretty?: boolean;
-    name?: string;
-}
-export declare class Logger {
-    private pino;
-    constructor(options?: LoggerOptions);
-    info(msg: string, ...args: any[]): void;
-    info(obj: object, msg?: string, ...args: any[]): void;
-    error(msg: string, ...args: any[]): void;
-    error(obj: object, msg?: string, ...args: any[]): void;
-    warn(msg: string, ...args: any[]): void;
-    warn(obj: object, msg?: string, ...args: any[]): void;
-    debug(msg: string, ...args: any[]): void;
-    debug(obj: object, msg?: string, ...args: any[]): void;
-    fatal(msg: string, ...args: any[]): void;
-    fatal(obj: object, msg?: string, ...args: any[]): void;
-    child(bindings: pino.Bindings): Logger;
-}

package/dist/src/core/logger.js

@@ -1,49 +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.Logger = void 0;
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const pino_1 = __importDefault(require("pino"));
-class Logger {
-    constructor(options = {}) {
-        const isDev = process.env.NODE_ENV !== 'production';
-        const pretty = options.pretty ?? isDev;
-        this.pino = (0, pino_1.default)({
-            name: options.name || 'qhttpx',
-            level: options.level || 'info',
-            transport: pretty
-                ? {
-                    target: 'pino-pretty',
-                    options: {
-                        colorize: true,
-                        translateTime: 'HH:MM:ss Z',
-                        ignore: 'pid,hostname',
-                    },
-                }
-                : undefined,
-        });
-    }
-    info(arg1, ...args) {
-        this.pino.info(arg1, ...args);
-    }
-    error(arg1, ...args) {
-        this.pino.error(arg1, ...args);
-    }
-    warn(arg1, ...args) {
-        this.pino.warn(arg1, ...args);
-    }
-    debug(arg1, ...args) {
-        this.pino.debug(arg1, ...args);
-    }
-    fatal(arg1, ...args) {
-        this.pino.fatal(arg1, ...args);
-    }
-    child(bindings) {
-        const child = new Logger();
-        child.pino = this.pino.child(bindings);
-        return child;
-    }
-}
-exports.Logger = Logger;

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;
-}