qhttpx 1.8.12 → 1.9.0

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

@@ -1,90 +0,0 @@
-"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.d.ts

@@ -1,11 +0,0 @@
-import { DatabaseAdapter, DatabaseConfig } from '../types';
-export declare class MongoAdapter implements DatabaseAdapter {
-    private client;
-    private db;
-    private config;
-    constructor(config: DatabaseConfig);
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    query<T = any>(query: string | object, params?: any[]): Promise<T>;
-    isConnected(): boolean;
-}

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

@@ -1,141 +0,0 @@
-"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.d.ts

@@ -1,10 +0,0 @@
-import { DatabaseAdapter, DatabaseConfig } from '../types';
-export declare class PostgresAdapter implements DatabaseAdapter {
-    private pool;
-    private config;
-    constructor(config: DatabaseConfig);
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    query<T = any>(sql: string, params?: any[]): Promise<T>;
-    isConnected(): boolean;
-}

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

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

package/dist/src/database/adapters/sqlite.d.ts

@@ -1,10 +0,0 @@
-import { DatabaseAdapter, DatabaseConfig } from '../types';
-export declare class SQLiteAdapter implements DatabaseAdapter {
-    private db;
-    private config;
-    constructor(config: DatabaseConfig);
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    query<T = any>(sql: string, params?: any[]): Promise<T>;
-    isConnected(): boolean;
-}

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

@@ -1,42 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SQLiteAdapter = void 0;
-const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
-class SQLiteAdapter {
-    constructor(config) {
-        this.db = null;
-        this.config = config;
-    }
-    async connect() {
-        const filename = this.config.database || ':memory:';
-        this.db = new better_sqlite3_1.default(filename, this.config.options);
-    }
-    async disconnect() {
-        if (this.db) {
-            this.db.close();
-            this.db = null;
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async query(sql, params) {
-        if (!this.db) {
-            throw new Error('Database not connected');
-        }
-        const stmt = this.db.prepare(sql);
-        // better-sqlite3 handles '?' params automatically
-        // Determine if it's a read or write operation
-        if (sql.trim().toLowerCase().startsWith('select')) {
-            return stmt.all(params || []);
-        }
-        else {
-            return stmt.run(params || []);
-        }
-    }
-    isConnected() {
-        return this.db !== null && this.db.open;
-    }
-}
-exports.SQLiteAdapter = SQLiteAdapter;

package/dist/src/database/coalescer.d.ts

@@ -1,14 +0,0 @@
-import { DatabaseAdapter } from './types';
-export declare class QueryCoalescer<T = unknown> {
-    private pending;
-    private timeout;
-    private readonly adapter;
-    constructor(adapter: DatabaseAdapter);
-    /**
-      * Intercepts a query and attempts to coalesce it with others.
-      * Only supports simple queries of the form "SELECT ... WHERE col = ?" for now.
-      */
-    query(query: string, params?: unknown[]): Promise<T>;
-    private scheduleFlush;
-    private flush;
-}

package/dist/src/database/coalescer.js

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryCoalescer = void 0;
-// eslint-enable @typescript-eslint/no-explicit-any
-class QueryCoalescer {
-    constructor(adapter) {
-        this.pending = new Map();
-        this.timeout = null;
-        this.adapter = adapter;
-    }
-    /**
-      * Intercepts a query and attempts to coalesce it with others.
-      * Only supports simple queries of the form "SELECT ... WHERE col = ?" for now.
-      */
-    async query(query, params) {
-        // Basic check for coalescing eligibility:
-        // 1. Must have exactly one parameter (for simplicity in this v1)
-        // 2. Must contain " = ?" pattern
-        if (!params || params.length !== 1 || !query.includes(' = ?')) {
-            return this.adapter.query(query, params);
-        }
-        return new Promise((resolve, reject) => {
-            if (!this.pending.has(query)) {
-                this.pending.set(query, []);
-            }
-            this.pending.get(query).push({
-                query,
-                paramValue: params[0],
-                resolve: resolve,
-                reject
-            });
-            this.scheduleFlush();
-        });
-    }
-    scheduleFlush() {
-        if (this.timeout)
-            return;
-        // Use microtask or short timeout to gather queries from the current event loop tick
-        this.timeout = setTimeout(() => this.flush(), 0);
-    }
-    async flush() {
-        this.timeout = null;
-        const currentBatch = this.pending;
-        this.pending = new Map(); // Clear for next batch
-        for (const [originalQuery, items] of currentBatch.entries()) {
-            if (items.length === 1) {
-                // No fusion needed
-                const item = items[0];
-                try {
-                    const result = await this.adapter.query(item.query, [item.paramValue]);
-                    item.resolve(result);
-                }
-                catch (err) {
-                    item.reject(err);
-                }
-                continue;
-            }
-            // Fuse queries
-            // Transform "SELECT * FROM table WHERE id = ?" 
-            // into "SELECT * FROM table WHERE id IN (?, ?, ...)"
-            // Basic string manipulation (safe enough for this controlled feature)
-            // We assume the query ends with " = ?" or contains it clearly.
-            const fusedQuery = originalQuery.replace(' = ?', ` IN (${items.map(() => '?').join(', ')})`);
-            const allParams = items.map(i => i.paramValue);
-            try {
-                const results = await this.adapter.query(fusedQuery, allParams);
-                // Distribute results back to callers
-                // We need to map results back to params.
-                // This is the tricky part: standard SQL doesn't guarantee order matching input IN clause.
-                // We must assume the result objects contain the key used in WHERE.
-                // Extract the column name from the query
-                // "WHERE id = ?" -> "id"
-                const match = originalQuery.match(/WHERE\s+(\w+)\s*=\s*\?/i);
-                if (!match) {
-                    // Fallback if we can't parse: execute individually (should not happen given check above)
-                    await Promise.all(items.map(async (item) => {
-                        try {
-                            const r = await this.adapter.query(item.query, [item.paramValue]);
-                            item.resolve(r);
-                        }
-                        catch (e) {
-                            item.reject(e);
-                        }
-                    }));
-                    continue;
-                }
-                const keyColumn = match[1];
-                // Map results by key
-                // Note: This assumes the result is an array of objects
-                // If the adapter returns something else, this might fail.
-                if (!Array.isArray(results)) {
-                    // Fallback for non-array results
-                    // Just give everyone the full result? No, that's wrong.
-                    // If it's not an array, we probably can't split it.
-                    // Reject? Or execute individually?
-                    // Let's execute individually as fallback.
-                    await Promise.all(items.map(async (item) => {
-                        try {
-                            const r = await this.adapter.query(item.query, [item.paramValue]);
-                            item.resolve(r);
-                        }
-                        catch (e) {
-                            item.reject(e);
-                        }
-                    }));
-                    continue;
-                }
-                const resultMap = new Map();
-                results.forEach(row => {
-                    if (typeof row === 'object' && row !== null && keyColumn in row) {
-                        const typedRow = row;
-                        const key = typedRow[keyColumn];
-                        if (typeof key === 'string' || typeof key === 'number') {
-                            if (!resultMap.has(key)) {
-                                resultMap.set(key, []);
-                            }
-                            resultMap.get(key).push(row);
-                        }
-                    }
-                });
-                items.forEach(item => {
-                    const key = typeof item.paramValue === 'string' || typeof item.paramValue === 'number' ? item.paramValue : undefined;
-                    const res = key !== undefined ? resultMap.get(key) || [] : [];
-                    item.resolve(res);
-                });
-            }
-            catch (err) {
-                // Fail all
-                items.forEach(item => item.reject(err));
-            }
-        }
-    }
-}
-exports.QueryCoalescer = QueryCoalescer;

package/dist/src/database/manager.d.ts

@@ -1,35 +0,0 @@
-import { DatabaseAdapter, DatabaseConfig, DatabaseEngineOptions } from './types';
-export type AdapterConstructor = new (config: DatabaseConfig) => DatabaseAdapter;
-export declare class DatabaseManager {
-    private config;
-    private static adapterRegistry;
-    private connections;
-    constructor(config: DatabaseEngineOptions);
-    /**
-     * Manually register an already initialized adapter instance
-     * @param name The connection name
-     * @param adapter The initialized adapter instance
-     */
-    registerConnection(name: string, adapter: DatabaseAdapter): void;
-    /**
-     * Register a new database adapter type
-     * @param type The type identifier (e.g., 'postgres', 'mysql', 'mongo')
-     * @param adapter The adapter class
-     */
-    static registerAdapter(type: string, adapter: AdapterConstructor): void;
-    /**
-     * Connect to a specific database or the default one
-     * @param name Connection name from config
-     */
-    connect(name?: string): Promise<DatabaseAdapter>;
-    /**
-     * Disconnect a specific connection or all connections
-     * @param name Connection name (optional). If not provided, disconnects all.
-     */
-    disconnect(name?: string): Promise<void>;
-    /**
-     * Get an active connection
-     * @param name Connection name
-     */
-    get(name?: string): DatabaseAdapter;
-}