qhttpx 1.8.11 → 1.9.0

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

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

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

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

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

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

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

@@ -1,94 +0,0 @@
-"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/cli/index.d.ts

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

package/dist/src/cli/index.js

@@ -1,222 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const child_process_1 = require("child_process");
-const cluster_1 = __importDefault(require("cluster"));
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const args = process.argv.slice(2);
-const command = args[0];
-if (!command) {
-    printHelp();
-    process.exit(1);
-}
-const targetFile = args[1];
-if (command === 'start') {
-    if (!targetFile) {
-        console.error('Error: Please provide an entry file (e.g., qhttpx start dist/index.js)');
-        process.exit(1);
-    }
-    runStart(targetFile);
-}
-else if (command === 'dev') {
-    if (!targetFile) {
-        console.error('Error: Please provide an entry file (e.g., qhttpx dev src/index.ts)');
-        process.exit(1);
-    }
-    runDev(targetFile);
-}
-else if (command === 'new') {
-    if (!targetFile) {
-        console.error('Error: Please provide a project name (e.g., qhttpx new my-app)');
-        process.exit(1);
-    }
-    runNew(targetFile);
-}
-else {
-    console.error(`Unknown command: ${command}`);
-    printHelp();
-    process.exit(1);
-}
-function printHelp() {
-    console.log('Usage: qhttpx <command> [options]');
-    console.log('Commands:');
-    console.log('  start <file>   Run in production cluster mode (Node.js)');
-    console.log('  dev <file>     Run in development mode with hot reload (tsx)');
-    console.log('  new <name>     Create a new QHTTPX project');
-}
-function runStart(entry) {
-    const absoluteEntry = path_1.default.resolve(process.cwd(), entry);
-    if (cluster_1.default.isPrimary) {
-        const numCPUs = os_1.default.cpus().length;
-        console.log(`[QCLI] 🚀 Starting Cluster Mode`);
-        console.log(`[QCLI] 📂 Entry: ${absoluteEntry}`);
-        console.log(`[QCLI] 💻 Workers: ${numCPUs}`);
-        for (let i = 0; i < numCPUs; i++) {
-            cluster_1.default.fork();
-        }
-        cluster_1.default.on('exit', (worker) => {
-            console.log(`[QCLI] 💀 Worker ${worker.process.pid} died. Restarting...`);
-            cluster_1.default.fork();
-        });
-    }
-    else {
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
-            require(absoluteEntry);
-        }
-        catch (err) {
-            console.error(`[QCLI] Failed to load entry file: ${absoluteEntry}`);
-            console.error(err);
-            process.exit(1);
-        }
-    }
-}
-function runDev(entry) {
-    const absoluteEntry = path_1.default.resolve(process.cwd(), entry);
-    console.log(`[QCLI] 🛠️  Starting Dev Mode`);
-    console.log(`[QCLI] 📂 Entry: ${absoluteEntry}`);
-    let child = null;
-    const startChild = () => {
-        // Use tsx for dev execution
-        child = (0, child_process_1.spawn)('npx', ['tsx', absoluteEntry], {
-            stdio: 'inherit',
-            shell: true,
-            cwd: process.cwd()
-        });
-        child.on('close', (code) => {
-            if (code !== 0 && code !== null) {
-                console.log(`[QCLI] App crashed (code ${code}). Waiting for changes...`);
-            }
-        });
-    };
-    const restartChild = () => {
-        if (child) {
-            console.log('[QCLI] 🔄 File changed. Restarting...');
-            // On Windows, killing a shell-spawned process is tricky.
-            // But 'child.kill()' usually works for the handle.
-            // For deeper tree killing, we might need a library, but let's try standard kill.
-            child.kill();
-            child = null;
-        }
-        startChild();
-    };
-    startChild();
-    // Watcher
-    let debounceTimer;
-    const watchDir = path_1.default.dirname(absoluteEntry); // Watch the directory of the entry file (usually src)
-    console.log(`[QCLI] 👀 Watching: ${watchDir}`);
-    // Recursive watch is platform dependent, but 'recursive: true' works on Windows/macOS
-    try {
-        fs_1.default.watch(watchDir, { recursive: true }, (eventType, filename) => {
-            if (!filename)
-                return;
-            // Ignore node_modules and .git
-            if (filename.includes('node_modules') || filename.includes('.git'))
-                return;
-            clearTimeout(debounceTimer);
-            debounceTimer = setTimeout(() => {
-                restartChild();
-            }, 200); // 200ms debounce
-        });
-    }
-    catch {
-        console.warn('[QCLI] Recursive watch not supported or failed. Falling back to simple watch.');
-        // Fallback or just fail gracefully
-    }
-}
-function runNew(projectName) {
-    const projectDir = path_1.default.resolve(process.cwd(), projectName);
-    if (fs_1.default.existsSync(projectDir)) {
-        console.error(`Error: Directory ${projectName} already exists.`);
-        process.exit(1);
-    }
-    console.log(`[QCLI] ✨ Creating new QHTTPX project in ${projectName}...`);
-    fs_1.default.mkdirSync(projectDir);
-    fs_1.default.mkdirSync(path_1.default.join(projectDir, 'src'));
-    // package.json
-    const pkgJson = {
-        name: projectName,
-        version: '0.0.1',
-        type: 'module',
-        scripts: {
-            dev: 'qhttpx dev src/index.ts',
-            start: 'qhttpx start dist/index.js',
-            build: 'tsc'
-        },
-        dependencies: {
-            'qhttpx': '^1.8.6',
-            'dotenv': '^16.4.1'
-        },
-        devDependencies: {
-            'typescript': '^5.3.3',
-            '@types/node': '^20.11.16',
-            'tsx': '^4.7.0'
-        }
-    };
-    fs_1.default.writeFileSync(path_1.default.join(projectDir, 'package.json'), JSON.stringify(pkgJson, null, 2));
-    // tsconfig.json
-    const tsConfig = {
-        compilerOptions: {
-            target: 'ES2022',
-            module: 'Node16',
-            moduleResolution: 'Node16',
-            rootDir: 'src',
-            outDir: 'dist',
-            strict: true,
-            esModuleInterop: true,
-            skipLibCheck: true,
-            forceConsistentCasingInFileNames: true
-        },
-        include: ['src']
-    };
-    fs_1.default.writeFileSync(path_1.default.join(projectDir, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2));
-    // src/index.ts
-    const indexTs = `import { createHttpApp } from 'qhttpx';
-import 'dotenv/config';
-
-const app = createHttpApp({
-  // ⚡ Performance: Auto-coalesce duplicate requests
-  enableRequestFusion: true,
-
-  // 🛡️ Security: Built-in CORS & Rate Limiting
-  cors: true,
-  rateLimit: {
-    windowMs: 15 * 60 * 1000, // 15 min
-    max: 100, // 100 reqs per IP
-    trustProxy: true
-  },
-
-  // 🗜️ Optimization: Gzip/Brotli compression
-  compression: true
-});
-
-app.get('/', ({ json }) => {
-  json({ 
-    message: 'Welcome to QHTTPX 🚀', 
-    status: 'online',
-    timestamp: Date.now() 
-  });
-});
-
-app.listen(Number(process.env.PORT) || 3000, () => {
-  console.log(\`Server running on http://localhost:\${process.env.PORT || 3000}\`);
-});
-`;
-    fs_1.default.writeFileSync(path_1.default.join(projectDir, 'src', 'index.ts'), indexTs);
-    // .gitignore
-    const gitignore = `node_modules
-dist
-.env
-`;
-    fs_1.default.writeFileSync(path_1.default.join(projectDir, '.gitignore'), gitignore);
-    console.log(`[QCLI] ✅ Project created successfully!`);
-    console.log(`\nNext steps:`);
-    console.log(`  cd ${projectName}`);
-    console.log(`  npm install`);
-    console.log(`  npm run dev`);
-}

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

@@ -1,17 +0,0 @@
-export type InferRequestType<T> = T extends {
-    request: infer R;
-} ? R : never;
-export type InferResponseType<T> = T extends {
-    response: infer R;
-} ? R : never;
-export declare function hc<T extends Record<string, any>>(baseUrl: string, options?: RequestInit): Client<T>;
-type Client<T> = {
-    [K in keyof T]: T[K] extends Function ? never : Client<T[K]>;
-} & {
-    $get: (args?: any) => Promise<any>;
-    $post: (args?: any) => Promise<any>;
-    $put: (args?: any) => Promise<any>;
-    $delete: (args?: any) => Promise<any>;
-    $patch: (args?: any) => Promise<any>;
-};
-export {};

package/dist/src/client/index.js

@@ -1,72 +0,0 @@
-"use strict";
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unsafe-function-type */
-// RPC Client for QHTTPX
-// Allows end-to-end type safety similar to Hono's 'hc' or Elysia's 'eden'
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hc = hc;
-// Proxy-based client generator
-function hc(baseUrl, options = {}) {
-    const handler = {
-        get(target, prop, receiver) {
-            if (typeof prop !== 'string')
-                return Reflect.get(target, prop, receiver);
-            // If it's a method call like .$get()
-            if (prop.startsWith('$')) {
-                const method = prop.slice(1).toUpperCase();
-                return async (args = {}) => {
-                    let url = baseUrl;
-                    const path = target.__path || '';
-                    // Replace params in path :id
-                    let finalPath = path;
-                    if (args.param) {
-                        Object.entries(args.param).forEach(([key, value]) => {
-                            finalPath = finalPath.replace(`:${key}`, String(value));
-                        });
-                    }
-                    url += finalPath;
-                    // Append query params
-                    if (args.query) {
-                        const searchParams = new URLSearchParams();
-                        Object.entries(args.query).forEach(([key, value]) => {
-                            searchParams.append(key, String(value));
-                        });
-                        url += `?${searchParams.toString()}`;
-                    }
-                    const fetchOptions = {
-                        ...options,
-                        method,
-                        headers: {
-                            ...options.headers,
-                            ...(args.header || {}),
-                            ...(args.json ? { 'Content-Type': 'application/json' } : {}),
-                        },
-                    };
-                    if (args.json) {
-                        fetchOptions.body = JSON.stringify(args.json);
-                    }
-                    else if (args.form) {
-                        // Handle FormData
-                        fetchOptions.body = args.form;
-                    }
-                    const res = await fetch(url, fetchOptions);
-                    // Return a wrapper that allows typed access
-                    return {
-                        ok: res.ok,
-                        status: res.status,
-                        statusText: res.statusText,
-                        headers: res.headers,
-                        json: () => res.json(),
-                        text: () => res.text(),
-                        blob: () => res.blob(),
-                    };
-                };
-            }
-            // It's a path segment
-            const newPath = (target.__path || '') + '/' + prop;
-            const proxy = new Proxy({ __path: newPath }, handler);
-            return proxy;
-        }
-    };
-    return new Proxy({ __path: '' }, handler);
-}

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

@@ -1,24 +0,0 @@
-import { QHTTPXContext, QHTTPXOpHandler } from './types';
-import { DatabaseManager } from '../database/manager';
-export declare class BatchExecutor {
-    private ops;
-    private dbManager?;
-    private coalescers;
-    constructor(dbManager?: DatabaseManager);
-    register(name: string, handler: QHTTPXOpHandler): void;
-    handleBatch(ctx: QHTTPXContext, batch: Array<{
-        op: string;
-        params: unknown;
-        id?: unknown;
-    }>): Promise<{
-        results: ({
-            error: string;
-            id: unknown;
-            result?: undefined;
-        } | {
-            result: any;
-            id: unknown;
-            error?: undefined;
-        })[];
-    }>;
-}

package/dist/src/core/batch.js

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BatchExecutor = void 0;
-const coalescer_1 = require("../database/coalescer");
-class BatchExecutor {
-    constructor(dbManager) {
-        this.ops = new Map();
-        this.coalescers = new Map();
-        this.dbManager = dbManager;
-    }
-    register(name, handler) {
-        this.ops.set(name, handler);
-    }
-    async handleBatch(ctx, batch) {
-        if (!Array.isArray(batch)) {
-            throw new Error('Batch must be an array');
-        }
-        // If we have a DB manager, we want to intercept queries for fusion
-        // We create a proxy for the DB manager attached to the context
-        let batchCtx = ctx;
-        if (this.dbManager && ctx.db) {
-            // Create a localized context that intercepts DB calls
-            // We need to ensure that when `ctx.db.get()` is called, it returns a wrapped adapter
-            // But `ctx.db` is the manager itself.
-            // We can't easily wrap the manager instance shared across requests.
-            // Instead, we can wrap the `ctx.db` property for this request scope.
-            const originalDb = ctx.db;
-            // Create a proxy for the database manager
-            const dbProxy = new Proxy(originalDb, {
-                get: (target, prop, receiver) => {
-                    if (prop === 'get' || prop === 'connect') {
-                        return (name) => {
-                            const adapter = target.get(name);
-                            // Check if we have a coalescer for this connection
-                            const connName = name || 'default'; // Simplify for now
-                            let coalescer = this.coalescers.get(connName);
-                            // In a real per-request batch scope, we should create a new Coalescer 
-                            // OR reset the existing one?
-                            // Actually, the Coalescer uses a short timeout (next tick). 
-                            // So it is safe to share across concurrent requests IF we want global batching.
-                            // BUT "auto transaction scope" implies per-request isolation.
-                            // For "Query Fusion", global batching is even better (cross-request fusion).
-                            // However, for this task, let's stick to per-request or global safely.
-                            // Since Coalescer flushes on next tick, sharing it is fine and efficient.
-                            if (!coalescer) {
-                                coalescer = new coalescer_1.QueryCoalescer(adapter);
-                                this.coalescers.set(connName, coalescer);
-                            }
-                            // Return a proxy to the adapter that uses the coalescer
-                            return {
-                                ...adapter,
-                                query: (query, params) => coalescer.query(query, params),
-                                isConnected: () => adapter.isConnected(),
-                                connect: () => adapter.connect(),
-                                disconnect: () => adapter.disconnect()
-                            };
-                        };
-                    }
-                    return Reflect.get(target, prop, receiver);
-                }
-            });
-            // Create a new context object that inherits from original but overrides db
-            // We use Object.create to prototype inherit, but ctx is a flat object in QHTTPX.
-            // We must shallow copy.
-            batchCtx = { ...ctx, db: dbProxy };
-        }
-        // Helper for internal calls
-        // "ctx.call" implementation
-        // The user wants: `ctx.call("getUser", { id: 5 })`
-        // We attach this to the context
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        batchCtx.call = async (op, params) => {
-            const handler = this.ops.get(op);
-            if (!handler) {
-                throw new Error(`Unknown operation: ${op}`);
-            }
-            return handler(params, batchCtx);
-        };
-        // Execute all ops
-        // We can run them in parallel since we want to fuse queries
-        const results = await Promise.all(batch.map(async (item) => {
-            try {
-                const handler = this.ops.get(item.op);
-                if (!handler) {
-                    return { error: `Unknown operation: ${item.op}`, id: item.id };
-                }
-                const result = await handler(item.params, batchCtx);
-                return { result, id: item.id };
-            }
-            catch (err) {
-                return { error: (err instanceof Error ? err.message : String(err)), id: item.id };
-            }
-        }));
-        return { results };
-    }
-}
-exports.BatchExecutor = BatchExecutor;

package/dist/src/core/body-parser.d.ts

@@ -1,15 +0,0 @@
-import { IncomingMessage } from 'http';
-export type BodyParserOptions = {
-    maxBodyBytes?: number;
-};
-export type ParsedBody = {
-    body: unknown;
-    files?: Record<string, unknown>;
-};
-export interface IBodyParser {
-    parse(req: IncomingMessage, options?: BodyParserOptions): Promise<any>;
-}
-export declare class BodyParser {
-    static parse(req: IncomingMessage, options?: BodyParserOptions): Promise<any>;
-    private static parseMultipart;
-}