qhttpx 1.8.0

package/dist/src/router/router.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+const radix_tree_1 = require("./radix-tree");
+const types_1 = require("../core/types");
+class Router {
+    constructor() {
+        // Per-method route buckets
+        this.methodBuckets = new Map([
+            ['GET', []],
+            ['POST', []],
+            ['PUT', []],
+            ['DELETE', []],
+            ['PATCH', []],
+            ['HEAD', []],
+            ['OPTIONS', []],
+        ]);
+        // Derived structures (built at freeze time)
+        this.radixTrees = new Map();
+        // Freeze state
+        this.isFrozen = false;
+    }
+    register(method, path, handler, options) {
+        if (this.isFrozen) {
+            console.warn(`Router is frozen. Late route registration (${method} ${path}) may not be optimized.`);
+        }
+        const segments = this.normalize(path);
+        const bucket = this.methodBuckets.get(method);
+        if (bucket) {
+            bucket.push({
+                path,
+                segments,
+                handler,
+                priority: options?.priority ?? types_1.RoutePriority.STANDARD,
+                schema: options?.schema,
+            });
+        }
+    }
+    getRoutes() {
+        return this.methodBuckets;
+    }
+    match(method, path) {
+        // Fast path for frozen router
+        if (this.isFrozen) {
+            const tree = this.radixTrees.get(method);
+            if (tree) {
+                const segments = this.normalize(path);
+                const match = tree.lookup(segments);
+                if (match) {
+                    return match;
+                }
+            }
+            return undefined;
+        }
+        // Slow path for unfrozen router (legacy behavior)
+        const segments = this.normalize(path);
+        const bucket = this.methodBuckets.get(method);
+        if (!bucket || bucket.length === 0) {
+            return undefined;
+        }
+        // Try to match against routes
+        for (const route of bucket) {
+            if (route.segments.length !== segments.length) {
+                continue;
+            }
+            const params = {};
+            let matched = true;
+            for (let i = 0; i < route.segments.length; i += 1) {
+                const pattern = route.segments[i];
+                const value = segments[i];
+                if (pattern.startsWith(':')) {
+                    const key = pattern.slice(1);
+                    params[key] = value;
+                }
+                else if (pattern !== value) {
+                    matched = false;
+                    break;
+                }
+            }
+            if (matched) {
+                return {
+                    handler: route.handler,
+                    params,
+                    priority: route.priority,
+                };
+            }
+        }
+        return undefined;
+    }
+    getAllowedMethods(path) {
+        const segments = this.normalize(path);
+        const methods = [];
+        for (const [method, routes] of this.methodBuckets.entries()) {
+            for (const route of routes) {
+                if (route.segments.length !== segments.length) {
+                    continue;
+                }
+                let matched = true;
+                for (let i = 0; i < route.segments.length; i += 1) {
+                    const pattern = route.segments[i];
+                    const value = segments[i];
+                    if (pattern.startsWith(':')) {
+                        continue;
+                    }
+                    if (pattern !== value) {
+                        matched = false;
+                        break;
+                    }
+                }
+                if (matched) {
+                    methods.push(method);
+                    break;
+                }
+            }
+        }
+        return methods;
+    }
+    /**
+     * Freeze the router after server starts.
+     * Prevents further route registration and builds derived structures for optimized matching.
+     */
+    freeze() {
+        if (this.isFrozen) {
+            return;
+        }
+        this.isFrozen = true;
+        // Build derived structures for faster matching
+        for (const [method, routes] of this.methodBuckets.entries()) {
+            const tree = new radix_tree_1.RadixTree();
+            for (const route of routes) {
+                tree.insert(route.segments, route.handler, route.priority);
+            }
+            this.radixTrees.set(method, tree);
+        }
+    }
+    isFrozenRouter() {
+        return this.isFrozen;
+    }
+    normalize(path) {
+        if (!path || path === '/') {
+            return [];
+        }
+        return path.split('/').filter((segment) => segment.length > 0);
+    }
+}
+exports.Router = Router;

package/dist/src/testing/index.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestClient = void 0;
+exports.createTestClient = createTestClient;
+class TestClient {
+    constructor(app) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.server = null;
+        this.baseURL = '';
+        this.app = app;
+    }
+    /**
+     * Starts the server on a random port.
+     * Automatically called by request methods if not started.
+     */
+    async start() {
+        if (this.server)
+            return;
+        const { port } = await this.app.listen(0);
+        this.server = this.app.serverInstance;
+        this.baseURL = `http://127.0.0.1:${port}`;
+    }
+    async stop() {
+        if (this.server) {
+            await this.app.close();
+            this.server = null;
+        }
+    }
+    async request(method, path, options = {}) {
+        if (!this.server) {
+            await this.start();
+        }
+        const url = new URL(path, this.baseURL);
+        if (options.query) {
+            Object.entries(options.query).forEach(([k, v]) => {
+                url.searchParams.append(k, String(v));
+            });
+        }
+        const headers = options.headers || {};
+        let bodyPayload;
+        if (options.body) {
+            if (typeof options.body === 'object' &&
+                !(options.body instanceof Uint8Array) &&
+                !(options.body instanceof ArrayBuffer) &&
+                !(options.body instanceof FormData) &&
+                !(options.body instanceof URLSearchParams)) {
+                bodyPayload = JSON.stringify(options.body);
+                if (!headers['content-type']) {
+                    headers['content-type'] = 'application/json';
+                }
+            }
+            else {
+                bodyPayload = options.body;
+            }
+        }
+        return fetch(url, {
+            method,
+            headers,
+            body: bodyPayload,
+        });
+    }
+    get(path, options) {
+        return this.request('GET', path, options);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    post(path, body, options) {
+        return this.request('POST', path, { ...options, body });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    put(path, body, options) {
+        return this.request('PUT', path, { ...options, body });
+    }
+    delete(path, options) {
+        return this.request('DELETE', path, options);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    patch(path, body, options) {
+        return this.request('PATCH', path, { ...options, body });
+    }
+}
+exports.TestClient = TestClient;
+function createTestClient(app) {
+    return new TestClient(app);
+}

package/dist/src/utils/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/utils/logger.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLoggerMiddleware = createLoggerMiddleware;
+function createLoggerMiddleware(options = {}) {
+    const sink = options.sink ??
+        ((entry) => {
+            const status = entry.status;
+            let color = '\x1b[37m';
+            if (status >= 200 && status < 300) {
+                color = '\x1b[32m';
+            }
+            else if (status === 404) {
+                color = '\x1b[33m';
+            }
+            else if (status >= 500) {
+                color = '\x1b[34m';
+            }
+            else if (status >= 400) {
+                color = '\x1b[35m';
+            }
+            const reset = '\x1b[0m';
+            const prefix = entry.requestId ? `${entry.requestId} ` : '';
+            const line = `${prefix}${entry.method} ${entry.path} ${status} ${entry.durationMs}ms`;
+            console.log(`${color}${line}${reset}`);
+        });
+    return async (ctx, next) => {
+        const start = ctx.requestStart ?? Date.now();
+        try {
+            await next();
+        }
+        finally {
+            const durationMs = Math.max(1, Date.now() - start);
+            const method = ctx.req.method || 'GET';
+            const path = ctx.url.pathname;
+            const status = ctx.res.statusCode || 200;
+            sink({
+                method,
+                path,
+                status,
+                durationMs,
+                requestId: ctx.requestId,
+            }, ctx);
+        }
+    };
+}

package/dist/src/utils/signals.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachSignalHandlers = attachSignalHandlers;
+function attachSignalHandlers(app, options = {}) {
+    const signals = options.signals ?? ['SIGINT', 'SIGTERM'];
+    const timeoutMs = options.timeoutMs ?? 10000;
+    let shuttingDown = false;
+    const handler = async (signal) => {
+        if (shuttingDown) {
+            return;
+        }
+        shuttingDown = true;
+        console.log(`Received ${signal}, shutting down...`);
+        const timer = setTimeout(() => {
+            console.error('Shutdown timed out, forcing exit. (some connections might be lost)');
+            process.exit(1);
+        }, timeoutMs);
+        try {
+            await app.shutdown();
+            clearTimeout(timer);
+            process.exit(0);
+        }
+        catch (err) {
+            console.error('Error during shutdown:', err);
+            process.exit(1);
+        }
+    };
+    for (const signal of signals) {
+        process.on(signal, handler);
+    }
+}

package/dist/src/utils/sse.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSSE = createSSE;
+function createSSE(ctx) {
+    const res = ctx.res;
+    // Disable auto-end so we can keep the connection open
+    ctx.disableAutoEnd = true;
+    // Only write headers if not already sent
+    if (!res.headersSent) {
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.setHeader('X-Accel-Buffering', 'no'); // For Nginx
+        // Send initial ping/comment to flush headers and establish connection
+        res.write(': connected\n\n');
+    }
+    const send = (data, event, id) => {
+        if (id)
+            res.write(`id: ${id}\n`);
+        if (event)
+            res.write(`event: ${event}\n`);
+        const payload = typeof data === 'string' ? data : JSON.stringify(data);
+        res.write(`data: ${payload}\n\n`);
+    };
+    const close = () => {
+        res.end();
+    };
+    ctx.req.on('close', () => {
+        // console.log('SSE client disconnected');
+    });
+    return { send, close };
+}

package/dist/src/validation/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./simple"), exports);
+__exportStar(require("./zod"), exports);

package/dist/src/validation/simple.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleValidator = void 0;
+const types_1 = require("./types");
+class SimpleValidator {
+    validate(schema, data) {
+        try {
+            // If schema is not a SimpleSchema object, we can't validate it with this validator
+            // But for simplicity, we assume the user passes a valid SimpleSchema if they use this validator.
+            const validData = this.check(schema, data);
+            return { success: true, data: validData };
+        }
+        catch (err) {
+            return {
+                success: false,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                error: new types_1.ValidationError(err.message || 'Validation failed')
+            };
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    check(schema, data, path = '') {
+        if (schema.required !== false && (data === undefined || data === null)) {
+            throw new Error(`Field '${path}' is required`);
+        }
+        if (data === undefined || data === null) {
+            return data;
+        }
+        switch (schema.type) {
+            case 'string':
+                if (typeof data !== 'string')
+                    throw new Error(`Field '${path}' must be a string`);
+                if (schema.min !== undefined && data.length < schema.min)
+                    throw new Error(`Field '${path}' too short (min ${schema.min})`);
+                if (schema.max !== undefined && data.length > schema.max)
+                    throw new Error(`Field '${path}' too long (max ${schema.max})`);
+                if (schema.pattern && !new RegExp(schema.pattern).test(data))
+                    throw new Error(`Field '${path}' format invalid`);
+                if (schema.enum && !schema.enum.includes(data))
+                    throw new Error(`Field '${path}' must be one of [${schema.enum.join(', ')}]`);
+                return data;
+            case 'number':
+                // Try to coerce if it's a string looking like a number (useful for query params)
+                let num = data;
+                if (typeof data === 'string' && !isNaN(Number(data))) {
+                    num = Number(data);
+                }
+                if (typeof num !== 'number' || isNaN(num))
+                    throw new Error(`Field '${path}' must be a number`);
+                if (schema.min !== undefined && num < schema.min)
+                    throw new Error(`Field '${path}' too small (min ${schema.min})`);
+                if (schema.max !== undefined && num > schema.max)
+                    throw new Error(`Field '${path}' too large (max ${schema.max})`);
+                if (schema.enum && !schema.enum.includes(num))
+                    throw new Error(`Field '${path}' must be one of [${schema.enum.join(', ')}]`);
+                return num;
+            case 'boolean':
+                if (typeof data === 'boolean')
+                    return data;
+                if (data === 'true')
+                    return true;
+                if (data === 'false')
+                    return false;
+                throw new Error(`Field '${path}' must be a boolean`);
+            case 'array':
+                if (!Array.isArray(data))
+                    throw new Error(`Field '${path}' must be an array`);
+                if (schema.min !== undefined && data.length < schema.min)
+                    throw new Error(`Field '${path}' too few items (min ${schema.min})`);
+                if (schema.max !== undefined && data.length > schema.max)
+                    throw new Error(`Field '${path}' too many items (max ${schema.max})`);
+                if (schema.items) {
+                    return data.map((item, i) => this.check(schema.items, item, `${path}[${i}]`));
+                }
+                return data;
+            case 'object':
+                if (typeof data !== 'object' || Array.isArray(data))
+                    throw new Error(`Field '${path}' must be an object`);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const result = {};
+                const props = schema.properties || {};
+                // Check known properties
+                for (const key in props) {
+                    const propSchema = props[key];
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const propValue = data[key];
+                    result[key] = this.check(propSchema, propValue, path ? `${path}.${key}` : key);
+                }
+                // Pass through unknown properties? 
+                // For strictness, maybe we should strip them?
+                // Let's keep unknown properties for now to be safe, or make it configurable.
+                // For now: Only keep validated properties if properties are defined.
+                if (Object.keys(props).length > 0) {
+                    return result;
+                }
+                return data;
+            default:
+                return data;
+        }
+    }
+}
+exports.SimpleValidator = SimpleValidator;

package/dist/src/validation/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = void 0;
+class ValidationError extends Error {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(details) {
+        super('Validation Error');
+        this.details = details;
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;

package/dist/src/validation/zod.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodValidator = void 0;
+const types_1 = require("./types");
+class ZodValidator {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async validate(schema, data) {
+        try {
+            const zodSchema = schema;
+            const result = await zodSchema.parseAsync(data);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            return { success: false, error: new types_1.ValidationError(error) };
+        }
+    }
+}
+exports.ZodValidator = ZodValidator;

package/dist/src/views/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);

package/dist/src/views/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tests/adapters.test.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const postgres_1 = require("../src/database/adapters/postgres");
+const mongo_1 = require("../src/database/adapters/mongo");
+// Define mocks
+const pgPoolQuery = vitest_1.vi.fn(() => Promise.resolve({ rows: [], command: 'SELECT' }));
+const pgConnect = vitest_1.vi.fn(() => Promise.resolve({ release: vitest_1.vi.fn() }));
+const pgEnd = vitest_1.vi.fn();
+vitest_1.vi.mock('pg', () => {
+    const Pool = function () {
+        return {
+            connect: pgConnect,
+            query: pgPoolQuery,
+            end: pgEnd,
+            on: vitest_1.vi.fn(),
+            ended: false
+        };
+    };
+    return {
+        default: { Pool },
+        Pool
+    };
+});
+const mongoFind = vitest_1.vi.fn(() => ({
+    toArray: vitest_1.vi.fn(() => Promise.resolve([])),
+    limit: vitest_1.vi.fn(),
+    skip: vitest_1.vi.fn()
+}));
+const mongoConnect = vitest_1.vi.fn(() => Promise.resolve());
+const mongoClose = vitest_1.vi.fn();
+vitest_1.vi.mock('mongodb', () => {
+    const MongoClient = function () {
+        return {
+            connect: mongoConnect,
+            db: vitest_1.vi.fn(() => ({
+                collection: vitest_1.vi.fn(() => ({
+                    find: mongoFind,
+                    findOne: vitest_1.vi.fn(),
+                    insertOne: vitest_1.vi.fn(),
+                    // add other methods as needed
+                    updateOne: vitest_1.vi.fn(),
+                    updateMany: vitest_1.vi.fn(),
+                    deleteOne: vitest_1.vi.fn(),
+                    deleteMany: vitest_1.vi.fn(),
+                    aggregate: vitest_1.vi.fn(() => ({ toArray: vitest_1.vi.fn(() => Promise.resolve([])) }))
+                }))
+            })),
+            close: mongoClose
+        };
+    };
+    return {
+        default: { MongoClient },
+        MongoClient
+    };
+});
+(0, vitest_1.describe)('Database Adapters', () => {
+    (0, vitest_1.describe)('PostgresAdapter', () => {
+        let adapter;
+        (0, vitest_1.beforeEach)(() => {
+            adapter = new postgres_1.PostgresAdapter({ type: 'postgres', database: 'test' });
+            vitest_1.vi.clearAllMocks();
+        });
+        (0, vitest_1.it)('should connect and disconnect', async () => {
+            await adapter.connect();
+            (0, vitest_1.expect)(pgConnect).toHaveBeenCalled();
+            (0, vitest_1.expect)(adapter.isConnected()).toBe(true);
+            await adapter.disconnect();
+            (0, vitest_1.expect)(pgEnd).toHaveBeenCalled();
+            // Since our mock object is static in the factory, we can't easily check 'pool' null state 
+            // via the mock, but we can check the adapter state if it relies on the pool property.
+            // The adapter sets this.pool = null.
+            (0, vitest_1.expect)(adapter.isConnected()).toBe(false);
+        });
+        (0, vitest_1.it)('should execute query', async () => {
+            await adapter.connect();
+            await adapter.query('SELECT * FROM users');
+            (0, vitest_1.expect)(pgPoolQuery).toHaveBeenCalledWith('SELECT * FROM users', undefined);
+        });
+    });
+    (0, vitest_1.describe)('MongoAdapter', () => {
+        let adapter;
+        (0, vitest_1.beforeEach)(() => {
+            adapter = new mongo_1.MongoAdapter({ type: 'mongo', url: 'mongodb://localhost' });
+            vitest_1.vi.clearAllMocks();
+        });
+        (0, vitest_1.it)('should connect and disconnect', async () => {
+            await adapter.connect();
+            (0, vitest_1.expect)(mongoConnect).toHaveBeenCalled();
+            (0, vitest_1.expect)(adapter.isConnected()).toBe(true);
+            await adapter.disconnect();
+            (0, vitest_1.expect)(mongoClose).toHaveBeenCalled();
+            (0, vitest_1.expect)(adapter.isConnected()).toBe(false);
+        });
+        (0, vitest_1.it)('should execute find query via object syntax', async () => {
+            await adapter.connect();
+            await adapter.query({ collection: 'users', action: 'find', filter: { id: 1 } });
+            (0, vitest_1.expect)(mongoFind).toHaveBeenCalledWith({ id: 1 });
+        });
+        (0, vitest_1.it)('should execute find query via string syntax', async () => {
+            await adapter.connect();
+            await adapter.query('users.find', [{ id: 1 }]);
+            (0, vitest_1.expect)(mongoFind).toHaveBeenCalledWith({ id: 1 });
+        });
+    });
+});