qhttpx 1.8.0

package/dist/src/core/stream.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSseStream = createSseStream;
+exports.sendStream = sendStream;
+function createSseStream(ctx, options = {}) {
+    const res = ctx.res;
+    if (!res.headersSent) {
+        res.statusCode = 200;
+        res.setHeader('content-type', 'text/event-stream; charset=utf-8');
+        res.setHeader('cache-control', 'no-cache');
+        res.setHeader('connection', 'keep-alive');
+    }
+    const anyRes = res;
+    if (anyRes.flushHeaders) {
+        anyRes.flushHeaders();
+    }
+    if (typeof options.retryMs === 'number') {
+        res.write(`retry: ${options.retryMs}\n\n`);
+    }
+    const send = (data, event) => {
+        if (res.writableEnded) {
+            return;
+        }
+        const payload = typeof data === 'string' ? data : JSON.stringify(data);
+        let chunk = '';
+        if (event) {
+            chunk += `event: ${event}\n`;
+        }
+        chunk += `data: ${payload}\n\n`;
+        res.write(chunk);
+        if (anyRes.flush) {
+            anyRes.flush();
+        }
+    };
+    const close = () => {
+        if (!res.writableEnded) {
+            res.end();
+        }
+    };
+    return { send, close };
+}
+function sendStream(ctx, stream, options = {}) {
+    const res = ctx.res;
+    if (!res.headersSent) {
+        if (options.status !== undefined) {
+            res.statusCode = options.status;
+        }
+        if (options.contentType) {
+            res.setHeader('content-type', options.contentType);
+        }
+    }
+    return new Promise((resolve, reject) => {
+        stream.on('error', (err) => {
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.setHeader('content-type', 'text/plain; charset=utf-8');
+            }
+            if (!res.writableEnded) {
+                res.end('Internal Server Error');
+            }
+            reject(err);
+        });
+        stream.on('end', () => {
+            if (!res.writableEnded) {
+                res.end();
+            }
+            resolve();
+        });
+        stream.pipe(res, { end: false });
+    });
+}

package/dist/src/core/tasks.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskEngine = void 0;
+class TaskEngine {
+    constructor(scheduler) {
+        this.tasks = new Map();
+        this.registeredTasksCount = 0;
+        this.totalEnqueued = 0;
+        this.totalCompleted = 0;
+        this.totalFailed = 0;
+        this.totalOverloaded = 0;
+        this.totalRetried = 0;
+        this.scheduler = scheduler;
+    }
+    register(name, handler, options = {}) {
+        if (!this.tasks.has(name)) {
+            this.registeredTasksCount += 1;
+        }
+        this.tasks.set(name, {
+            name,
+            handler,
+            options,
+        });
+    }
+    async enqueue(name, payload) {
+        const def = this.tasks.get(name);
+        if (!def) {
+            throw new Error(`Task "${name}" is not registered`);
+        }
+        this.totalEnqueued += 1;
+        await this.executeWithRetry(def, payload);
+    }
+    getMetrics() {
+        return {
+            registeredTasks: this.registeredTasksCount,
+            totalEnqueued: this.totalEnqueued,
+            totalCompleted: this.totalCompleted,
+            totalFailed: this.totalFailed,
+            totalOverloaded: this.totalOverloaded,
+            totalRetried: this.totalRetried,
+        };
+    }
+    async executeWithRetry(def, payload) {
+        const maxRetries = def.options.maxRetries ?? 0;
+        const backoffMs = def.options.backoffMs ?? 0;
+        let attempt = 0;
+        for (;;) {
+            let overloaded = false;
+            let error;
+            await this.scheduler.run(async () => {
+                try {
+                    await def.handler(payload);
+                }
+                catch (err) {
+                    error = err;
+                }
+            }, {
+                onOverloaded: () => {
+                    overloaded = true;
+                },
+            });
+            if (!overloaded && !error) {
+                this.totalCompleted += 1;
+                return;
+            }
+            if (attempt >= maxRetries) {
+                if (error) {
+                    this.totalFailed += 1;
+                    throw error;
+                }
+                if (overloaded) {
+                    this.totalOverloaded += 1;
+                    throw new Error(`Task "${def.name}" overloaded`);
+                }
+                return;
+            }
+            attempt += 1;
+            this.totalRetried += 1;
+            if (backoffMs > 0) {
+                await new Promise((resolve) => {
+                    setTimeout(resolve, backoffMs);
+                });
+            }
+        }
+    }
+}
+exports.TaskEngine = TaskEngine;

package/dist/src/core/types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpError = exports.RoutePriority = void 0;
+var RoutePriority;
+(function (RoutePriority) {
+    RoutePriority["CRITICAL"] = "critical";
+    RoutePriority["STANDARD"] = "standard";
+    RoutePriority["BEST_EFFORT"] = "best-effort";
+})(RoutePriority || (exports.RoutePriority = RoutePriority = {}));
+class HttpError extends Error {
+    constructor(status, message, options = {}) {
+        super(message ?? 'HTTP Error');
+        this.status = status;
+        this.code = options.code;
+        this.details = options.details;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.HttpError = HttpError;

package/dist/src/core/websocket.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketManager = void 0;
+const url_1 = require("url");
+const ws_1 = require("ws");
+class WebSocketManager {
+    constructor(requestIdGenerator) {
+        this.requestIdGenerator = requestIdGenerator;
+        this.handlers = [];
+        this.rooms = new Map();
+        this.wss = new ws_1.WebSocketServer({ noServer: true });
+    }
+    register(path, handler) {
+        this.handlers.push({ path, handler });
+    }
+    async handleUpgrade(req, socket, head) {
+        const rawUrl = req.url || '/';
+        const host = req.headers.host || 'localhost';
+        const urlObj = new url_1.URL(rawUrl, `http://${host}`);
+        const path = urlObj.pathname;
+        const handlerEntry = this.handlers.find((entry) => entry.path === path);
+        if (!handlerEntry) {
+            socket.destroy();
+            return;
+        }
+        this.wss.handleUpgrade(req, socket, head, (ws) => {
+            const qws = ws;
+            qws.id = this.requestIdGenerator();
+            qws.join = (room) => this.join(room, qws);
+            qws.leave = (room) => this.leave(room, qws);
+            qws.on('close', () => {
+                this.leaveAll(qws);
+            });
+            handlerEntry.handler(qws, req);
+        });
+    }
+    join(room, ws) {
+        if (!this.rooms.has(room)) {
+            this.rooms.set(room, new Set());
+        }
+        this.rooms.get(room).add(ws);
+    }
+    leave(room, ws) {
+        const set = this.rooms.get(room);
+        if (set) {
+            set.delete(ws);
+            if (set.size === 0) {
+                this.rooms.delete(room);
+            }
+        }
+    }
+    leaveAll(ws) {
+        for (const [room, set] of this.rooms) {
+            if (set.has(ws)) {
+                set.delete(ws);
+                if (set.size === 0) {
+                    this.rooms.delete(room);
+                }
+            }
+        }
+    }
+    to(room) {
+        return {
+            emit: (data) => {
+                const set = this.rooms.get(room);
+                if (set) {
+                    const payload = typeof data === 'string' ? data : JSON.stringify(data);
+                    for (const client of set) {
+                        if (client.readyState === ws_1.WebSocket.OPEN) {
+                            client.send(payload);
+                        }
+                    }
+                }
+            },
+        };
+    }
+    broadcast(data) {
+        const payload = typeof data === 'string' ? data : JSON.stringify(data);
+        for (const client of this.wss.clients) {
+            if (client.readyState === ws_1.WebSocket.OPEN) {
+                client.send(payload);
+            }
+        }
+    }
+}
+exports.WebSocketManager = WebSocketManager;

package/dist/src/core/worker-queue.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Lock-free (or lock-minimal) work queue for per-worker task distribution.
+ * Uses a simple ring buffer for high throughput.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerQueue = void 0;
+class WorkerQueue {
+    constructor(capacity = 1024) {
+        this.writeIndex = 0;
+        this.readIndex = 0;
+        this.size = 0;
+        if (capacity <= 0 || !Number.isInteger(capacity)) {
+            throw new Error('Capacity must be a positive integer');
+        }
+        // Ensure capacity is a power of 2 for efficient modulo with bitmask
+        this.capacity = Math.pow(2, Math.ceil(Math.log2(capacity)));
+        this.buffer = new Array(this.capacity);
+    }
+    /**
+     * Enqueue a work item. Returns true if successful, false if queue is full.
+     */
+    enqueue(item) {
+        if (this.size >= this.capacity) {
+            return false;
+        }
+        this.buffer[this.writeIndex] = item;
+        this.writeIndex = (this.writeIndex + 1) & (this.capacity - 1);
+        this.size += 1;
+        return true;
+    }
+    /**
+     * Dequeue a work item. Returns undefined if queue is empty.
+     */
+    dequeue() {
+        if (this.size <= 0) {
+            return undefined;
+        }
+        const item = this.buffer[this.readIndex];
+        this.buffer[this.readIndex] = undefined;
+        this.readIndex = (this.readIndex + 1) & (this.capacity - 1);
+        this.size -= 1;
+        return item;
+    }
+    /**
+     * Peek at the next item without removing it.
+     */
+    peek() {
+        if (this.size <= 0) {
+            return undefined;
+        }
+        return this.buffer[this.readIndex];
+    }
+    /**
+     * Check if the queue is empty.
+     */
+    isEmpty() {
+        return this.size === 0;
+    }
+    /**
+     * Get the current size of the queue.
+     */
+    getSize() {
+        return this.size;
+    }
+    /**
+     * Get the capacity of the queue.
+     */
+    getCapacity() {
+        return this.capacity;
+    }
+}
+exports.WorkerQueue = WorkerQueue;

package/dist/src/database/adapters/memory.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryAdapter = void 0;
+class MemoryAdapter {
+    constructor(config) {
+        this.config = config;
+        this.connected = false;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.collections = new Map();
+    }
+    async connect() {
+        // Simulate connection delay
+        await new Promise(resolve => setTimeout(resolve, 100));
+        this.connected = true;
+    }
+    async disconnect() {
+        this.connected = false;
+        this.collections.clear();
+    }
+    isConnected() {
+        return this.connected;
+    }
+    /**
+      * Execute a query against the in-memory database
+      * @param query Object specifying collection, action, and parameters
+      * @example
+      * // Find
+      * query({ collection: 'users', action: 'find', filter: { id: 1 } })
+      * // Insert
+      * query({ collection: 'users', action: 'insert', data: { name: 'Alice' } })
+      */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async query(query) {
+        if (!this.connected) {
+            throw new Error('Database not connected');
+        }
+        const { collection, action, data, filter } = query;
+        if (!collection || !action) {
+            throw new Error('Query must specify collection and action');
+        }
+        if (!this.collections.has(collection)) {
+            this.collections.set(collection, []);
+        }
+        const store = this.collections.get(collection);
+        switch (action) {
+            case 'find':
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                if (!filter)
+                    return store;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return store.filter(item => this.matches(item, filter));
+            case 'findOne':
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                if (!filter)
+                    return store[0];
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return store.find(item => this.matches(item, filter));
+            case 'insert':
+                const newItem = { id: Date.now(), ...data };
+                store.push(newItem);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return newItem;
+            case 'update':
+                let updatedCount = 0;
+                store.forEach((item, index) => {
+                    if (this.matches(item, filter)) {
+                        store[index] = { ...item, ...data };
+                        updatedCount++;
+                    }
+                });
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return updatedCount;
+            case 'delete':
+                const initialLength = store.length;
+                const newStore = store.filter(item => !this.matches(item, filter));
+                this.collections.set(collection, newStore);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return (initialLength - newStore.length);
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    matches(item, filter) {
+        if (!filter)
+            return true;
+        return Object.entries(filter).every(([key, value]) => item[key] === value);
+    }
+}
+exports.MemoryAdapter = MemoryAdapter;

package/dist/src/database/adapters/mongo.js

@@ -0,0 +1,141 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoAdapter = void 0;
+class MongoAdapter {
+    constructor(config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.client = null;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.db = null;
+        this.config = config;
+    }
+    async connect() {
+        if (this.client)
+            return;
+        try {
+            const mongodb = await Promise.resolve().then(() => __importStar(require('mongodb')));
+            const { MongoClient } = mongodb.default || mongodb;
+            const url = this.config.url || `mongodb://${this.config.host || 'localhost'}:${this.config.port || 27017}`;
+            this.client = new MongoClient(url, {
+                auth: this.config.username ? {
+                    username: this.config.username,
+                    password: this.config.password
+                } : undefined,
+                ...this.config.options
+            });
+            await this.client.connect();
+            this.db = this.client.db(this.config.database);
+        }
+        catch (err) {
+            if (err.message.includes('Cannot find module')) {
+                throw new Error('MongoDB driver not found. Please run: npm install mongodb');
+            }
+            throw err;
+        }
+    }
+    async disconnect() {
+        if (this.client) {
+            await this.client.close();
+            this.client = null;
+            this.db = null;
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async query(query, params) {
+        if (!this.db) {
+            throw new Error('Database not connected');
+        }
+        // MongoDB "query" is usually a collection.find() or similar.
+        // We need a convention here.
+        // Convention: query is a JSON object with { collection: 'name', action: 'find', filter: {}, ... }
+        // OR: query is just the collection name, and params[0] is the operation?
+        // Let's go with a structured object for maximum flexibility if passed as object.
+        // If query is string, maybe it's just collection name?
+        // Let's support a simple object-based API:
+        // db.query({ collection: 'users', action: 'find', filter: { id: 1 } })
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let op = query;
+        if (typeof query === 'string') {
+            // Fallback or simple format?
+            // Maybe "users.find" ?
+            const parts = query.split('.');
+            if (parts.length >= 2) {
+                op = {
+                    collection: parts[0],
+                    action: parts[1],
+                    filter: params?.[0]
+                };
+            }
+            else {
+                throw new Error('Invalid MongoDB query format. Use object or "collection.action" string.');
+            }
+        }
+        const collection = this.db.collection(op.collection);
+        switch (op.action) {
+            case 'find':
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const cursor = collection.find(op.filter || {});
+                if (op.limit)
+                    cursor.limit(op.limit);
+                if (op.skip)
+                    cursor.skip(op.skip);
+                return (await cursor.toArray());
+            case 'findOne':
+                return (await collection.findOne(op.filter || {}));
+            case 'insertOne':
+                return (await collection.insertOne(op.doc || params?.[0]));
+            case 'insertMany':
+                return (await collection.insertMany(op.docs || params?.[0]));
+            case 'updateOne':
+                return (await collection.updateOne(op.filter, op.update || params?.[1]));
+            case 'updateMany':
+                return (await collection.updateMany(op.filter, op.update || params?.[1]));
+            case 'deleteOne':
+                return (await collection.deleteOne(op.filter));
+            case 'deleteMany':
+                return (await collection.deleteMany(op.filter));
+            case 'aggregate':
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return (await collection.aggregate((op.pipeline || params)).toArray());
+            default:
+                throw new Error(`Unsupported MongoDB action: ${op.action}`);
+        }
+    }
+    isConnected() {
+        return this.client !== null;
+    }
+}
+exports.MongoAdapter = MongoAdapter;

package/dist/src/database/adapters/postgres.js

@@ -0,0 +1,111 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresAdapter = void 0;
+class PostgresAdapter {
+    constructor(config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.pool = null;
+        this.config = config;
+    }
+    async connect() {
+        if (this.pool)
+            return;
+        try {
+            // Dynamic import
+            const pg = await Promise.resolve().then(() => __importStar(require('pg')));
+            const { Pool } = pg.default || pg;
+            this.pool = new Pool({
+                host: this.config.host,
+                port: this.config.port || 5432,
+                user: this.config.username,
+                password: this.config.password,
+                database: this.config.database,
+                // Postgres-specific options can be passed via config.options
+                ...this.config.options
+            });
+            // Verify connection
+            const client = await this.pool.connect();
+            client.release();
+        }
+        catch (err) {
+            if (err.message.includes('Cannot find module')) {
+                throw new Error('PostgreSQL driver not found. Please run: npm install pg');
+            }
+            throw err;
+        }
+    }
+    async disconnect() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async query(sql, params) {
+        if (!this.pool) {
+            throw new Error('Database not connected');
+        }
+        try {
+            // pg supports parameterized queries using $1, $2, etc.
+            // But our Coalescer might be sending '?' if it's generic.
+            // If the user writes 'SELECT * FROM users WHERE id = $1', that's fine.
+            // If they write '?', we might need to convert it?
+            // For now, we assume the user provides SQL compatible with the underlying driver.
+            // Or we could implement a simple '?' -> '$n' converter if we want to standardize.
+            // Standardizing is better for the generic "engine" feel.
+            if (sql.includes('?')) {
+                let i = 1;
+                sql = sql.replace(/\?/g, () => `$${i++}`);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = await this.pool.query(sql, params);
+            // Return rows for SELECT, or result meta for others?
+            // Our interface implies T.
+            // Usually users expect rows array for SELECT.
+            if (result.command === 'SELECT' || result.command === 'INSERT' && result.rows.length > 0) {
+                return result.rows;
+            }
+            return result;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    isConnected() {
+        return this.pool !== null && !this.pool.ended;
+    }
+}
+exports.PostgresAdapter = PostgresAdapter;