qhttpx 1.9.2 → 1.9.3

package/dist/src/cli/index.js

@@ -0,0 +1,222 @@
+#!/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

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

@@ -0,0 +1,72 @@
+"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/config.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+function loadConfig(options = {}) {
+    const env = options.env ?? process.env;
+    const defaults = options.defaults ?? {};
+    const prefix = options.prefix ?? 'QHTTPX_';
+    const getNumber = (key) => {
+        const value = env[prefix + key];
+        if (!value) {
+            return undefined;
+        }
+        const n = Number(value);
+        if (!Number.isFinite(n) || n <= 0) {
+            return undefined;
+        }
+        return n;
+    };
+    const getBoolean = (key) => {
+        const value = env[prefix + key];
+        if (!value) {
+            return undefined;
+        }
+        const lower = value.toLowerCase();
+        if (lower === 'true' || lower === '1') {
+            return true;
+        }
+        if (lower === 'false' || lower === '0') {
+            return false;
+        }
+        return undefined;
+    };
+    const maxConcurrency = getNumber('MAX_CONCURRENCY');
+    const requestTimeoutMs = getNumber('REQUEST_TIMEOUT_MS');
+    const maxMemoryBytes = getNumber('MAX_MEMORY_BYTES');
+    const maxBodyBytes = getNumber('MAX_BODY_BYTES');
+    const keepAliveTimeoutMs = getNumber('KEEP_ALIVE_TIMEOUT_MS');
+    const headersTimeoutMs = getNumber('HEADERS_TIMEOUT_MS');
+    const metricsEnabled = getBoolean('METRICS_ENABLED');
+    return {
+        ...defaults,
+        maxConcurrency: maxConcurrency ?? defaults.maxConcurrency,
+        requestTimeoutMs: requestTimeoutMs ?? defaults.requestTimeoutMs,
+        maxMemoryBytes: maxMemoryBytes ?? defaults.maxMemoryBytes,
+        maxBodyBytes: maxBodyBytes ?? defaults.maxBodyBytes,
+        keepAliveTimeoutMs: keepAliveTimeoutMs ?? defaults.keepAliveTimeoutMs,
+        headersTimeoutMs: headersTimeoutMs ?? defaults.headersTimeoutMs,
+        metricsEnabled: metricsEnabled ?? defaults.metricsEnabled,
+    };
+}

package/dist/src/cookies.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCookies = parseCookies;
+exports.serializeCookie = serializeCookie;
+function parseCookies(header) {
+    const list = {};
+    if (!header) {
+        return list;
+    }
+    header.split(';').forEach((cookie) => {
+        const parts = cookie.split('=');
+        const name = parts.shift()?.trim();
+        if (name) {
+            const value = parts.join('=');
+            list[name] = decodeURIComponent(value);
+        }
+    });
+    return list;
+}
+function serializeCookie(name, value, options = {}) {
+    let str = `${name}=${encodeURIComponent(value)}`;
+    if (options.maxAge) {
+        str += `; Max-Age=${Math.floor(options.maxAge)}`;
+    }
+    if (options.domain) {
+        str += `; Domain=${options.domain}`;
+    }
+    if (options.path) {
+        str += `; Path=${options.path}`;
+    }
+    else {
+        str += '; Path=/';
+    }
+    if (options.expires) {
+        str += `; Expires=${options.expires.toUTCString()}`;
+    }
+    if (options.httpOnly) {
+        str += '; HttpOnly';
+    }
+    if (options.secure) {
+        str += '; Secure';
+    }
+    if (options.sameSite) {
+        switch (options.sameSite) {
+            case 'lax':
+                str += '; SameSite=Lax';
+                break;
+            case 'strict':
+                str += '; SameSite=Strict';
+                break;
+            case 'none':
+                str += '; SameSite=None';
+                break;
+            default:
+                break;
+        }
+    }
+    return str;
+}

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

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

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

@@ -0,0 +1,15 @@
+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;
+}

package/dist/src/core/body-parser.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BodyParser = void 0;
+const querystring_1 = require("querystring");
+const busboy_1 = __importDefault(require("busboy"));
+class BodyParser {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static async parse(req, options = {}) {
+        const method = (req.method || 'GET').toUpperCase();
+        if (method === 'GET' || method === 'HEAD') {
+            return { body: undefined };
+        }
+        const contentType = req.headers['content-type'] || '';
+        if (contentType.includes('multipart/form-data')) {
+            return this.parseMultipart(req, options);
+        }
+        const chunks = [];
+        let totalBytes = 0;
+        const maxBodyBytes = options.maxBodyBytes;
+        for await (const chunk of req) {
+            const bufferChunk = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+            chunks.push(bufferChunk);
+            totalBytes += bufferChunk.length;
+            if (maxBodyBytes !== undefined && totalBytes > maxBodyBytes) {
+                throw new Error('QHTTPX_BODY_TOO_LARGE');
+            }
+        }
+        if (chunks.length === 0) {
+            return { body: undefined };
+        }
+        const buffer = Buffer.concat(chunks);
+        if (typeof contentType === 'string' &&
+            contentType.includes('application/json')) {
+            const text = buffer.toString('utf8');
+            try {
+                return { body: JSON.parse(text) };
+            }
+            catch {
+                throw new Error('QHTTPX_INVALID_JSON');
+            }
+        }
+        if (typeof contentType === 'string' &&
+            contentType.includes('application/x-www-form-urlencoded')) {
+            const text = buffer.toString('utf8');
+            return { body: (0, querystring_1.parse)(text) };
+        }
+        return { body: buffer };
+    }
+    static parseMultipart(req, options) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return new Promise((resolve, reject) => {
+            let bb;
+            try {
+                bb = (0, busboy_1.default)({ headers: req.headers, limits: { fileSize: options.maxBodyBytes } });
+            }
+            catch (err) {
+                return reject(err);
+            }
+            const body = {};
+            const files = {};
+            bb.on('field', (name, val) => {
+                if (Object.prototype.hasOwnProperty.call(body, name)) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    if (Array.isArray(body[name])) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        body[name].push(val);
+                    }
+                    else {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        body[name] = [body[name], val];
+                    }
+                }
+                else {
+                    body[name] = val;
+                }
+            });
+            bb.on('file', (name, file, info) => {
+                const { filename, encoding, mimeType } = info;
+                const chunks = [];
+                file.on('data', (chunk) => {
+                    chunks.push(chunk);
+                });
+                file.on('end', () => {
+                    const buffer = Buffer.concat(chunks);
+                    const fileData = {
+                        filename,
+                        encoding,
+                        mimeType,
+                        data: buffer,
+                        size: buffer.length,
+                    };
+                    if (Object.prototype.hasOwnProperty.call(files, name)) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        if (Array.isArray(files[name])) {
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            files[name].push(fileData);
+                        }
+                        else {
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            files[name] = [files[name], fileData];
+                        }
+                    }
+                    else {
+                        files[name] = fileData;
+                    }
+                });
+            });
+            bb.on('close', () => {
+                resolve({ body, files });
+            });
+            bb.on('error', (err) => {
+                reject(err);
+            });
+            req.pipe(bb);
+        });
+    }
+}
+exports.BodyParser = BodyParser;