qhttpx 1.9.2 → 1.9.3

package/dist/src/benchmarks/compare.js

@@ -0,0 +1,288 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const autocannon_1 = __importDefault(require("autocannon"));
+const index_1 = require("../index");
+const fastify_1 = __importDefault(require("fastify"));
+const express_1 = __importDefault(require("express"));
+const hono_1 = require("hono");
+const node_server_1 = require("@hono/node-server");
+const koa_1 = __importDefault(require("koa"));
+const polka_1 = __importDefault(require("polka"));
+const http_1 = __importDefault(require("http"));
+const PORT = 3000;
+const DURATION = 300; // Testing duration
+const CONNECTIONS = 500; // Connections
+const PIPELINING = 20; // Request pipelining
+const results = [];
+function printProgress(name, timeLeft, total) {
+    const percent = Math.max(0, Math.min(100, Math.round(((total - timeLeft) / total) * 100)));
+    const barLength = 30;
+    const filled = Math.round((barLength * percent) / 100);
+    const bar = '█'.repeat(filled) + '░'.repeat(barLength - filled);
+    // Clear line and move cursor to start
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+    process.stdout.write(`${name} [${bar}] ${percent}% | Time Left: ${timeLeft}s`);
+}
+const frameworks = [
+    {
+        name: 'QHTTPX (Native)',
+        control: () => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let app;
+            return {
+                start: async () => {
+                    return new Promise((resolve) => {
+                        app = (0, index_1.createHttpApp)();
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        app.get('/', ({ json }) => json({ hello: 'world' }));
+                        app.listen(PORT, () => resolve());
+                    });
+                },
+                stop: async () => {
+                    await app.close();
+                },
+            };
+        },
+    },
+    {
+        name: 'Fastify',
+        control: () => {
+            const app = (0, fastify_1.default)();
+            app.get('/', async () => ({ hello: 'world' }));
+            return {
+                start: async () => {
+                    await app.listen({ port: PORT });
+                },
+                stop: async () => {
+                    await app.close();
+                },
+            };
+        },
+    },
+    {
+        name: 'Hono (Node)',
+        control: () => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let server;
+            return {
+                start: async () => {
+                    const app = new hono_1.Hono();
+                    app.get('/', (c) => c.json({ hello: 'world' }));
+                    return new Promise((resolve, reject) => {
+                        try {
+                            server = (0, node_server_1.serve)({ fetch: app.fetch, port: PORT }, () => resolve());
+                            server.on('error', reject);
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                    });
+                },
+                stop: async () => {
+                    return new Promise((resolve) => {
+                        if (server && typeof server.close === 'function') {
+                            server.removeAllListeners('error');
+                            server.close(() => resolve());
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                },
+            };
+        },
+    },
+    {
+        name: 'Express',
+        control: () => {
+            let server;
+            return {
+                start: async () => {
+                    return new Promise((resolve) => {
+                        const app = (0, express_1.default)();
+                        app.disable('etag');
+                        app.disable('x-powered-by');
+                        app.get('/', (req, res) => res.json({ hello: 'world' }));
+                        server = app.listen(PORT, () => resolve());
+                    });
+                },
+                stop: async () => {
+                    return new Promise((resolve) => {
+                        server.close(() => resolve());
+                    });
+                },
+            };
+        },
+    },
+    {
+        name: 'Koa',
+        control: () => {
+            let server;
+            return {
+                start: async () => {
+                    return new Promise((resolve) => {
+                        const app = new koa_1.default();
+                        app.use((ctx) => {
+                            ctx.body = { hello: 'world' };
+                        });
+                        server = app.listen(PORT, () => resolve());
+                    });
+                },
+                stop: async () => {
+                    return new Promise((resolve) => {
+                        server.close(() => resolve());
+                    });
+                },
+            };
+        },
+    },
+    {
+        name: 'Polka',
+        control: () => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let server;
+            return {
+                start: async () => {
+                    return new Promise((resolve) => {
+                        const app = (0, polka_1.default)();
+                        app.get('/', (req, res) => {
+                            res.setHeader('Content-Type', 'application/json');
+                            res.end(JSON.stringify({ hello: 'world' }));
+                        });
+                        server = app.listen(PORT, () => resolve());
+                    });
+                },
+                stop: async () => {
+                    return new Promise((resolve) => {
+                        server.server.close(() => resolve());
+                    });
+                },
+            };
+        },
+    },
+    {
+        name: 'Restify',
+        control: () => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let server;
+            return {
+                start: async () => {
+                    return new Promise((resolve, reject) => {
+                        try {
+                            // eslint-disable-next-line @typescript-eslint/no-require-imports
+                            const restify = require('restify');
+                            server = restify.createServer();
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            server.get('/', (req, res, next) => {
+                                res.send({ hello: 'world' });
+                                next();
+                            });
+                            server.listen(PORT, () => resolve());
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                    });
+                },
+                stop: async () => {
+                    return new Promise((resolve) => {
+                        if (server)
+                            server.close(() => resolve());
+                        else
+                            resolve();
+                    });
+                },
+            };
+        },
+    },
+    {
+        name: 'Node Native',
+        control: () => {
+            let server;
+            return {
+                start: async () => {
+                    return new Promise((resolve) => {
+                        server = http_1.default.createServer((req, res) => {
+                            res.setHeader('Content-Type', 'application/json');
+                            res.end(JSON.stringify({ hello: 'world' }));
+                        });
+                        server.listen(PORT, () => resolve());
+                    });
+                },
+                stop: async () => {
+                    return new Promise((resolve) => {
+                        server.close(() => resolve());
+                    });
+                },
+            };
+        },
+    },
+];
+async function run() {
+    const origLog = console.log;
+    const origError = console.error;
+    const origWarn = console.warn;
+    origLog(`\nStarting Benchmark Comparison`);
+    origLog(`Duration: ${DURATION}s | Connections: ${CONNECTIONS}\n`);
+    for (const fw of frameworks) {
+        origLog(`Preparing ${fw.name}...`);
+        const ctrl = fw.control();
+        try {
+            await ctrl.start();
+            // Wait for server to be fully ready
+            await new Promise((r) => setTimeout(r, 500));
+            const startTime = Date.now();
+            const interval = setInterval(() => {
+                const elapsed = (Date.now() - startTime) / 1000;
+                const timeLeft = Math.max(0, Math.round(DURATION - elapsed));
+                printProgress(fw.name, timeLeft, DURATION);
+            }, 200);
+            // Suppress autocannon logs
+            console.log = () => { };
+            console.error = () => { };
+            console.warn = () => { };
+            const result = await (0, autocannon_1.default)({
+                url: `http://localhost:${PORT}`,
+                connections: CONNECTIONS,
+                pipelining: PIPELINING,
+                duration: DURATION,
+            });
+            console.log = origLog;
+            console.error = origError;
+            console.warn = origWarn;
+            clearInterval(interval);
+            printProgress(fw.name, 0, DURATION);
+            origLog('\n');
+            results.push({
+                name: fw.name,
+                reqs: result.requests.average,
+                latency: result.latency.average,
+                p50: result.latency.p50,
+                p90: result.latency.p90,
+                p99: result.latency.p99,
+                max: result.latency.max,
+                throughput: (result.throughput.average / 1024 / 1024).toFixed(2),
+            });
+            await ctrl.stop();
+        }
+        catch (err) {
+            console.log = origLog;
+            console.error = origError;
+            console.warn = origWarn;
+            origError(`Error benchmarking ${fw.name}:`, err);
+            try {
+                await ctrl.stop();
+            }
+            catch { }
+        }
+        // Cool down - allow time for port to be released
+        await new Promise((r) => setTimeout(r, 3000));
+    }
+    origLog('\n--- Final Results ---');
+    console.table(results.sort((a, b) => b.reqs - a.reqs));
+}
+run().catch(console.error);

package/dist/src/benchmarks/quantam-users.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/benchmarks/quantam-users.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const quantam_async_1 = require("quantam-async");
+const index_1 = require("../index");
+async function run() {
+    const app = new index_1.QHTTPX({
+        maxConcurrency: 512,
+        requestTimeoutMs: 10000,
+    });
+    app.get('/json', (ctx) => {
+        ctx.json({ message: 'hello from qhttpx' });
+    });
+    const { port } = await app.listen(0, '127.0.0.1');
+    const url = `http://127.0.0.1:${port}/json`;
+    const requestsPerUser = 10;
+    const userCount = 10000;
+    const maxConcurrentUsers = 1000;
+    const flow = (0, quantam_async_1.quantam)()
+        .name('user-flow')
+        .step(async (userId) => {
+        for (let i = 0; i < requestsPerUser; i += 1) {
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`user ${userId} request ${i} failed with status ${response.status}`);
+            }
+            await response.text();
+        }
+        return userId;
+    })
+        .retry(3, 50)
+        .timeout(30000);
+    const inputs = [];
+    for (let i = 0; i < userCount; i += 1) {
+        inputs.push(i);
+    }
+    const start = Date.now();
+    try {
+        await flow.runMany(inputs, {
+            concurrency: maxConcurrentUsers,
+        });
+    }
+    catch (err) {
+        console.error('Quantam runMany error', err);
+    }
+    const durationSec = (Date.now() - start) / 1000;
+    const totalRequests = userCount * requestsPerUser;
+    const rps = totalRequests / durationSec;
+    console.log(`Quantam bench: users=${userCount}, requestsPerUser=${requestsPerUser}, ` +
+        `totalRequests=${totalRequests}, duration=${durationSec.toFixed(2)}s, rps=${rps.toFixed(0)}, concurrency=${maxConcurrentUsers}`);
+    await app.close();
+    process.exit(0);
+}
+run().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/src/benchmarks/simple-json.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/benchmarks/simple-json.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const autocannon_1 = __importDefault(require("autocannon"));
+const index_1 = require("../index");
+function runAutocannon(url) {
+    return new Promise((resolve, reject) => {
+        const instance = (0, autocannon_1.default)({
+            url,
+            connections: 100,
+            pipelining: 10,
+            duration: 40,
+        }, (err, result) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(result);
+        });
+        instance.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+async function run() {
+    const payloadBuffer = Buffer.from(JSON.stringify({ message: 'hello from qhttpx' }));
+    const app = new index_1.QHTTPX({
+        maxConcurrency: 512,
+        metricsEnabled: false,
+        jsonSerializer: () => payloadBuffer,
+    });
+    app.get('/json', (ctx) => {
+        ctx.json({ message: 'hello from qhttpx' });
+    });
+    const { port } = await app.listen(0, '127.0.0.1');
+    const url = `http://127.0.0.1:${port}/json`;
+    console.log('Running warmup (1/2)...');
+    await runAutocannon(url);
+    console.log('Running benchmark (2/2)...');
+    const result = await runAutocannon(url);
+    autocannon_1.default.printResult(result);
+    const totalRequests = result.requests.total;
+    const sent = result.requests.sent;
+    const avgRps = result.requests.average.toFixed(0);
+    const p99 = result.latency.p99.toFixed(1);
+    const connections = result.connections;
+    const pipelining = result.pipelining;
+    // Summary line that shows up clearly in CI/dev logs
+    console.log(`QHTTPX bench: total=${totalRequests} (sent=${sent}) req, ` +
+        `${avgRps} req/sec, p99=${p99}ms, connections=${connections}, ` +
+        `pipelining=${pipelining}`);
+    await app.close();
+    process.exit(0);
+}
+run().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/src/benchmarks/ultra-mode.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/benchmarks/ultra-mode.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const autocannon_1 = __importDefault(require("autocannon"));
+const index_1 = require("../index");
+async function runAutocannon(name, url) {
+    const result = await (0, autocannon_1.default)({
+        url,
+        connections: 200,
+        pipelining: 10,
+        duration: 10,
+    });
+    const total = result.requests.total;
+    const sent = result.requests.sent;
+    const rps = result.requests.average;
+    const p99 = result.latency.p99;
+    console.log(`${name} bench: total=${total} (sent=${sent}) req, ` +
+        `${rps.toFixed(0)} req/sec, p99=${p99.toFixed(1)}ms, connections=${result.connections}, pipelining=${result.pipelining}`);
+    return {
+        name,
+        total,
+        sent,
+        rps,
+        p99,
+    };
+}
+async function startQHTTPXBalanced() {
+    const payloadBuffer = Buffer.from(JSON.stringify({ message: 'hello from qhttpx' }));
+    const app = new index_1.QHTTPX({
+        maxConcurrency: 1024,
+        metricsEnabled: false,
+        performanceMode: 'balanced',
+        jsonSerializer: () => payloadBuffer,
+    });
+    app.get('/json', (ctx) => {
+        ctx.json({ message: 'hello from qhttpx' });
+    });
+    const { port } = await app.listen(0, '127.0.0.1');
+    const url = `http://127.0.0.1:${port}/json`;
+    return { app, url };
+}
+async function startQHTTPXUltra() {
+    const payloadBuffer = Buffer.from(JSON.stringify({ message: 'hello from qhttpx ultra' }));
+    const app = new index_1.QHTTPX({
+        maxConcurrency: 1024,
+        performanceMode: 'ultra',
+        jsonSerializer: () => payloadBuffer,
+    });
+    app.get('/json', (ctx) => {
+        ctx.json({ message: 'hello from qhttpx ultra' });
+    });
+    const { port } = await app.listen(0, '127.0.0.1');
+    const url = `http://127.0.0.1:${port}/json`;
+    return { app, url };
+}
+async function run() {
+    const results = [];
+    console.log('=== QHTTPX Balanced Mode ===');
+    const balanced = await startQHTTPXBalanced();
+    try {
+        const r = await runAutocannon('QHTTPX-Balanced', balanced.url);
+        results.push(r);
+    }
+    finally {
+        await balanced.app.close();
+    }
+    console.log('\n=== QHTTPX Ultra Mode ===');
+    const ultra = await startQHTTPXUltra();
+    try {
+        const r = await runAutocannon('QHTTPX-Ultra', ultra.url);
+        results.push(r);
+    }
+    finally {
+        await ultra.app.close();
+    }
+    console.log('\n=== Summary ===');
+    for (const r of results) {
+        console.log(`${r.name}: ${r.rps.toFixed(0)} req/sec, p99=${r.p99.toFixed(1)}ms, total=${r.total}`);
+    }
+    // Calculate improvement
+    const balanced_rps = results[0]?.rps || 0;
+    const ultra_rps = results[1]?.rps || 0;
+    if (ultra_rps > 0 && balanced_rps > 0) {
+        const improvement = ((ultra_rps - balanced_rps) / balanced_rps * 100).toFixed(1);
+        console.log(`\nUltra vs Balanced improvement: ${improvement}%`);
+    }
+    process.exit(0);
+}
+run().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/src/buffer-pool.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Buffer pool for response bodies (small, medium, large).
+ * Reuses allocated buffers to reduce GC pressure.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferPool = void 0;
+class BufferPool {
+    constructor(config = {}) {
+        this.smallBuffers = [];
+        this.mediumBuffers = [];
+        this.largeBuffers = [];
+        this.smallSize = config.smallSize ?? 4096; // 4KB
+        this.mediumSize = config.mediumSize ?? 65536; // 64KB
+        this.largeSize = config.largeSize ?? 262144; // 256KB
+        this.smallPoolSize = config.smallPoolSize ?? 32;
+        this.mediumPoolSize = config.mediumPoolSize ?? 8;
+        this.largePoolSize = config.largePoolSize ?? 2;
+        // Preallocate buffers
+        for (let i = 0; i < this.smallPoolSize; i += 1) {
+            this.smallBuffers.push(Buffer.allocUnsafe(this.smallSize));
+        }
+        for (let i = 0; i < this.mediumPoolSize; i += 1) {
+            this.mediumBuffers.push(Buffer.allocUnsafe(this.mediumSize));
+        }
+        for (let i = 0; i < this.largePoolSize; i += 1) {
+            this.largeBuffers.push(Buffer.allocUnsafe(this.largeSize));
+        }
+    }
+    /**
+     * Acquire a buffer suitable for the given size.
+     * Returns a buffer from the appropriate pool.
+     */
+    acquire(size) {
+        if (size <= this.smallSize) {
+            return this.smallBuffers.pop() || Buffer.allocUnsafe(this.smallSize);
+        }
+        if (size <= this.mediumSize) {
+            return this.mediumBuffers.pop() || Buffer.allocUnsafe(this.mediumSize);
+        }
+        return this.largeBuffers.pop() || Buffer.allocUnsafe(this.largeSize);
+    }
+    /**
+     * Release a buffer back to the appropriate pool.
+     */
+    release(buffer) {
+        if (buffer.length === this.smallSize && this.smallBuffers.length < this.smallPoolSize) {
+            this.smallBuffers.push(buffer);
+        }
+        else if (buffer.length === this.mediumSize &&
+            this.mediumBuffers.length < this.mediumPoolSize) {
+            this.mediumBuffers.push(buffer);
+        }
+        else if (buffer.length === this.largeSize &&
+            this.largeBuffers.length < this.largePoolSize) {
+            this.largeBuffers.push(buffer);
+        }
+    }
+    /**
+     * Get the number of available buffers in each pool.
+     */
+    getPoolStatus() {
+        return {
+            small: this.smallBuffers.length,
+            medium: this.mediumBuffers.length,
+            large: this.largeBuffers.length,
+        };
+    }
+}
+exports.BufferPool = BufferPool;

package/dist/src/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};