qhttpx 1.8.0

package/src/database/adapters/memory.ts

@@ -0,0 +1,99 @@
+import { DatabaseAdapter, DatabaseConfig } from '../types';
+
+export class MemoryAdapter implements DatabaseAdapter {
+  private connected: boolean = false;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private collections: Map<string, any[]> = new Map();
+
+  constructor(private config: DatabaseConfig) {}
+
+  async connect(): Promise<void> {
+    // Simulate connection delay
+    await new Promise(resolve => setTimeout(resolve, 100));
+    this.connected = true;
+  }
+
+  async disconnect(): Promise<void> {
+    this.connected = false;
+    this.collections.clear();
+  }
+
+  isConnected(): boolean {
+    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<T = any>(query: any): Promise<T> {
+    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 as any;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return store.filter(item => this.matches(item, filter)) as any;
+      
+      case 'findOne':
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (!filter) return store[0] as any;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return store.find(item => this.matches(item, filter)) as any;
+
+      case 'insert':
+        const newItem = { id: Date.now(), ...data };
+        store.push(newItem);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return newItem as any;
+
+      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 as any;
+
+      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) as any;
+
+      default:
+        throw new Error(`Unknown action: ${action}`);
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private matches(item: any, filter: any): boolean {
+    if (!filter) return true;
+    return Object.entries(filter).every(([key, value]) => item[key] === value);
+  }
+}

package/src/database/adapters/mongo.ts

@@ -0,0 +1,116 @@
+import { DatabaseAdapter, DatabaseConfig } from '../types';
+
+export class MongoAdapter implements DatabaseAdapter {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private client: any = null;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private db: any = null;
+  private config: DatabaseConfig;
+
+  constructor(config: DatabaseConfig) {
+    this.config = config;
+  }
+
+  async connect(): Promise<void> {
+    if (this.client) return;
+
+    try {
+      const mongodb = await import('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 as Error).message.includes('Cannot find module')) {
+        throw new Error('MongoDB driver not found. Please run: npm install mongodb');
+      }
+      throw err;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.client) {
+      await this.client.close();
+      this.client = null;
+      this.db = null;
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async query<T = any>(query: string | object, params?: any[]): Promise<T> {
+    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: any = 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: any = collection.find(op.filter || {});
+            if (op.limit) cursor.limit(op.limit);
+            if (op.skip) cursor.skip(op.skip);
+            return (await cursor.toArray()) as unknown as T;
+        case 'findOne':
+            return (await collection.findOne(op.filter || {})) as unknown as T;
+        case 'insertOne':
+            return (await collection.insertOne(op.doc || params?.[0])) as unknown as T;
+        case 'insertMany':
+            return (await collection.insertMany(op.docs || params?.[0])) as unknown as T;
+        case 'updateOne':
+            return (await collection.updateOne(op.filter, op.update || params?.[1])) as unknown as T;
+        case 'updateMany':
+            return (await collection.updateMany(op.filter, op.update || params?.[1])) as unknown as T;
+        case 'deleteOne':
+            return (await collection.deleteOne(op.filter)) as unknown as T;
+        case 'deleteMany':
+            return (await collection.deleteMany(op.filter)) as unknown as T;
+        case 'aggregate':
+             // eslint-disable-next-line @typescript-eslint/no-explicit-any
+             return (await collection.aggregate((op.pipeline || params) as any).toArray()) as unknown as T;
+        default:
+            throw new Error(`Unsupported MongoDB action: ${op.action}`);
+    }
+  }
+
+  isConnected(): boolean {
+    return this.client !== null;
+  }
+}

package/src/database/adapters/postgres.ts

@@ -0,0 +1,86 @@
+import { DatabaseAdapter, DatabaseConfig } from '../types';
+
+export class PostgresAdapter implements DatabaseAdapter {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private pool: any = null;
+  private config: DatabaseConfig;
+
+  constructor(config: DatabaseConfig) {
+    this.config = config;
+  }
+
+  async connect(): Promise<void> {
+    if (this.pool) return;
+
+    try {
+      // Dynamic import
+      const pg = await import('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 as Error).message.includes('Cannot find module')) {
+        throw new Error('PostgreSQL driver not found. Please run: npm install pg');
+      }
+      throw err;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async query<T = any>(sql: string, params?: any[]): Promise<T> {
+     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: any = 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 as unknown as T;
+        }
+        return result as unknown as T;
+    } catch (err) {
+        throw err;
+    }
+  }
+
+  isConnected(): boolean {
+    return this.pool !== null && !this.pool.ended;
+  }
+}

package/src/database/adapters/sqlite.ts

@@ -0,0 +1,44 @@
+import Database from 'better-sqlite3';
+import { DatabaseAdapter, DatabaseConfig } from '../types';
+
+export class SQLiteAdapter implements DatabaseAdapter {
+  private db: Database.Database | null = null;
+  private config: DatabaseConfig;
+
+  constructor(config: DatabaseConfig) {
+    this.config = config;
+  }
+
+  async connect(): Promise<void> {
+    const filename = this.config.database || ':memory:';
+    this.db = new Database(filename, this.config.options);
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async query<T = any>(sql: string, params?: any[]): Promise<T> {
+     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 || []) as T;
+    } else {
+      return stmt.run(params || []) as unknown as T;
+    }
+  }
+
+  isConnected(): boolean {
+    return this.db !== null && this.db.open;
+  }
+}

package/src/database/coalescer.ts

@@ -0,0 +1,153 @@
+import { DatabaseAdapter } from './types';
+
+interface PendingQuery<T> {
+  query: string;
+  paramValue: unknown;
+  resolve: (value: T) => void;
+  reject: (reason?: unknown) => void;
+}
+// eslint-enable @typescript-eslint/no-explicit-any
+
+export class QueryCoalescer<T = unknown> {
+  private pending: Map<string, PendingQuery<T>[]> = new Map();
+  private timeout: NodeJS.Timeout | null = null;
+  private readonly adapter: DatabaseAdapter;
+
+  constructor(adapter: DatabaseAdapter) {
+    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.
+    */
+  public async query(query: string, params?: unknown[]): Promise<T> {
+    // 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<T>((resolve, reject) => {
+      if (!this.pending.has(query)) {
+        this.pending.set(query, []);
+      }
+      
+      this.pending.get(query)!.push({
+        query,
+        paramValue: params[0],
+        resolve: resolve as (value: T) => void,
+        reject
+      });
+
+      this.scheduleFlush();
+    });
+  }
+
+  private 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); 
+  }
+
+  private 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<unknown[]>(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<string | number, T[]>();
+        results.forEach(row => {
+            if (typeof row === 'object' && row !== null && keyColumn in row) {
+                const typedRow = row as Record<string, unknown>;
+                const key = typedRow[keyColumn];
+                if (typeof key === 'string' || typeof key === 'number') {
+                    if (!resultMap.has(key)) {
+                        resultMap.set(key, []);
+                    }
+                    resultMap.get(key)!.push(row as T);
+                }
+            }
+        });
+
+        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 as T);
+        });
+
+      } catch (err) {
+        // Fail all
+        items.forEach(item => item.reject(err));
+      }
+    }
+  }
+}

package/src/database/manager.ts

@@ -0,0 +1,97 @@
+import { DatabaseAdapter, DatabaseConfig, DatabaseEngineOptions } from './types';
+
+export type AdapterConstructor = new (config: DatabaseConfig) => DatabaseAdapter;
+
+export class DatabaseManager {
+  private static adapterRegistry: Map<string, AdapterConstructor> = new Map();
+  private connections: Map<string, DatabaseAdapter> = new Map();
+
+  constructor(private config: DatabaseEngineOptions) {}
+
+  /**
+   * Manually register an already initialized adapter instance
+   * @param name The connection name
+   * @param adapter The initialized adapter instance
+   */
+  public registerConnection(name: string, adapter: DatabaseAdapter) {
+    this.connections.set(name, adapter);
+  }
+
+  /**
+   * Register a new database adapter type
+   * @param type The type identifier (e.g., 'postgres', 'mysql', 'mongo')
+   * @param adapter The adapter class
+   */
+  public static registerAdapter(type: string, adapter: AdapterConstructor) {
+    DatabaseManager.adapterRegistry.set(type, adapter);
+  }
+
+  /**
+   * Connect to a specific database or the default one
+   * @param name Connection name from config
+   */
+  public async connect(name?: string): Promise<DatabaseAdapter> {
+    const connectionName = name || this.config.default;
+    if (!connectionName) {
+      throw new Error('No connection name provided and no default connection configured.');
+    }
+
+    // Return existing connection if available and connected
+    const existingConnection = this.connections.get(connectionName);
+    if (existingConnection && existingConnection.isConnected()) {
+      return existingConnection;
+    }
+
+    const dbConfig = this.config.connections[connectionName];
+    if (!dbConfig) {
+      throw new Error(`Connection configuration for '${connectionName}' not found.`);
+    }
+
+    const AdapterClass = DatabaseManager.adapterRegistry.get(dbConfig.type);
+    if (!AdapterClass) {
+      throw new Error(`No adapter registered for database type '${dbConfig.type}'.`);
+    }
+
+    const adapter = new AdapterClass(dbConfig);
+    await adapter.connect();
+    this.connections.set(connectionName, adapter);
+    
+    return adapter;
+  }
+
+  /**
+   * Disconnect a specific connection or all connections
+   * @param name Connection name (optional). If not provided, disconnects all.
+   */
+  public async disconnect(name?: string): Promise<void> {
+    if (name) {
+      const adapter = this.connections.get(name);
+      if (adapter) {
+        await adapter.disconnect();
+        this.connections.delete(name);
+      }
+    } else {
+      const promises = Array.from(this.connections.values()).map(adapter => adapter.disconnect());
+      await Promise.all(promises);
+      this.connections.clear();
+    }
+  }
+
+  /**
+   * Get an active connection
+   * @param name Connection name
+   */
+  public get(name?: string): DatabaseAdapter {
+    const connectionName = name || this.config.default;
+    if (!connectionName) {
+      throw new Error('No connection name provided and no default connection configured.');
+    }
+
+    const adapter = this.connections.get(connectionName);
+    if (!adapter) {
+      throw new Error(`Connection '${connectionName}' is not active. Call connect() first.`);
+    }
+
+    return adapter;
+  }
+}

package/src/database/types.ts

@@ -0,0 +1,24 @@
+export interface DatabaseConfig {
+  type: string;
+  url?: string;
+  host?: string;
+  port?: number;
+  username?: string;
+  password?: string;
+  database?: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  options?: Record<string, any>;
+}
+
+export interface DatabaseAdapter {
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  query<T = any>(query: string | object, params?: any[]): Promise<T>;
+  isConnected(): boolean;
+}
+
+export interface DatabaseEngineOptions {
+  default?: string;
+  connections: Record<string, DatabaseConfig>;
+}

package/src/index.ts

@@ -0,0 +1,42 @@
+import { QHTTPX } from './core/server';
+import type { QHTTPXOptions } from './core/types';
+import { createApiPreset } from './middleware/presets';
+
+export { QHTTPX } from './core/server';
+export * from './core/types';
+export * from './middleware/cors';
+export * from './middleware/security';
+export * from './middleware/static';
+export * from './middleware/compression';
+export * from './core/stream';
+export * from './utils/logger';
+export { BufferPool, BufferPoolConfig } from './core/buffer-pool';
+export * from './testing';
+export * from './utils/signals';
+export * from './middleware/presets';
+export * from './utils/cookies';
+export * from './utils/sse';
+export { fastJsonStringify, getStringifier } from './core/serializer';
+export * from './database/types';
+export * from './database/manager';
+export * from './database/adapters/memory';
+export * from './views';
+export * from './validation';
+export * from './database/adapters/sqlite';
+export * from './database/adapters/postgres';
+export * from './database/adapters/mongo';
+export * from './core/fusion';
+export * from './validation/types';
+export * from './validation/simple';
+export * from './openapi/generator';
+export * from './client';
+
+export function createHttpApp(options: QHTTPXOptions = {}): QHTTPX {
+  const app = new QHTTPX(options);
+  // Skip middleware in ultra mode for maximum performance
+  if (options.performanceMode !== 'ultra') {
+    const middlewares = createApiPreset();
+    middlewares.forEach((mw) => app.use(mw));
+  }
+  return app;
+}