@mantiq/database 0.1.4 → 0.3.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mantiq/database",
-  "version": "0.1.4",
+  "version": "0.3.0-rc.1",
   "description": "Query builder, ORM, migrations, seeders, factories — with SQLite, Postgres, MySQL and MongoDB support",
   "type": "module",
   "license": "MIT",
@@ -40,7 +40,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target bun",
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun --packages=external",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"

package/src/DatabaseManager.ts

@@ -1,5 +1,4 @@
 import type { DatabaseConnection } from './contracts/Connection.ts'
-import type { MongoDatabaseConnection } from './contracts/MongoConnection.ts'
 import { SQLiteConnection } from './drivers/SQLiteConnection.ts'
 import { PostgresConnection } from './drivers/PostgresConnection.ts'
 import { MySQLConnection } from './drivers/MySQLConnection.ts'
@@ -9,31 +8,31 @@ import { ConnectionError } from './errors/ConnectionError.ts'
 export interface SQLConfig {
   driver: 'sqlite' | 'postgres' | 'mysql'
   database: string
-  host?: string
-  port?: number
-  user?: string
-  password?: string
-  ssl?: boolean
-  pool?: { min?: number; max?: number }
+  host?: string | undefined
+  port?: number | undefined
+  user?: string | undefined
+  password?: string | undefined
+  ssl?: boolean | undefined
+  pool?: { min?: number | undefined; max?: number | undefined } | undefined
 }
 
 export interface MongoConfig {
   driver: 'mongodb'
   uri: string
   database: string
-  options?: Record<string, any>
+  options?: Record<string, any> | undefined
 }
 
 export type ConnectionConfig = SQLConfig | MongoConfig
 
 export interface DatabaseConfig {
-  default?: string
+  default?: string | undefined
   connections: Record<string, ConnectionConfig>
 }
 
 export class DatabaseManager {
   private sqlConnections = new Map<string, DatabaseConnection>()
-  private mongoConnections = new Map<string, MongoDatabaseConnection>()
+  private mongoConnections = new Map<string, MongoConnection>()
 
   constructor(private readonly config: DatabaseConfig) {}
 
@@ -51,7 +50,7 @@ export class DatabaseManager {
   }
 
   /** Get a MongoDB connection by name */
-  mongo(name?: string): MongoDatabaseConnection {
+  mongo(name?: string): MongoConnection {
     const connName = name ?? this.config.default ?? 'default'
     if (this.mongoConnections.has(connName)) return this.mongoConnections.get(connName)!
 

package/src/contracts/Connection.ts

@@ -1,10 +1,23 @@
-import type { QueryBuilder } from '../query/Builder.ts'
+import type { QueryBuilder, QueryState } from '../query/Builder.ts'
 import type { SchemaBuilder } from '../schema/SchemaBuilder.ts'
 
 export interface DatabaseConnection {
+  // ── Universal execution (works on ALL drivers) ──────────────────────────
+  executeSelect(state: QueryState): Promise<Record<string, any>[]>
+  executeInsert(table: string, data: Record<string, any>): Promise<number>
+  executeInsertGetId(table: string, data: Record<string, any>): Promise<number | string>
+  executeUpdate(table: string, state: QueryState, data: Record<string, any>): Promise<number>
+  executeDelete(table: string, state: QueryState): Promise<number>
+  executeTruncate(table: string): Promise<void>
+  executeAggregate(state: QueryState, fn: 'count' | 'sum' | 'avg' | 'min' | 'max', column: string): Promise<number>
+  executeExists(state: QueryState): Promise<boolean>
+
+  // ── Raw SQL escape hatch (throws DriverNotSupportedError on non-SQL) ───
   select(sql: string, bindings?: any[]): Promise<Record<string, any>[]>
   statement(sql: string, bindings?: any[]): Promise<number>
-  insertGetId(sql: string, bindings?: any[]): Promise<number | bigint>
+  insertGetId(sql: string, bindings?: any[]): Promise<number | bigint | string>
+
+  // ── Shared ──────────────────────────────────────────────────────────────
   transaction<T>(callback: (connection: DatabaseConnection) => Promise<T>): Promise<T>
   table(name: string): QueryBuilder
   schema(): SchemaBuilder

package/src/drivers/BaseSQLConnection.ts

@@ -0,0 +1,111 @@
+import type { DatabaseConnection } from '../contracts/Connection.ts'
+import type { Grammar } from '../contracts/Grammar.ts'
+import type { QueryState } from '../query/Builder.ts'
+import type { SchemaBuilder } from '../schema/SchemaBuilder.ts'
+import { QueryBuilder } from '../query/Builder.ts'
+import { Expression } from '../query/Expression.ts'
+
+/**
+ * Abstract base for all SQL connections. Provides `executeXxx()` methods
+ * by compiling QueryState via Grammar and delegating to the raw SQL methods
+ * that each driver must implement.
+ */
+export abstract class BaseSQLConnection implements DatabaseConnection {
+  abstract readonly _grammar: Grammar
+
+  // ── Subclasses implement these (raw SQL execution) ──────────────────────
+  abstract select(sql: string, bindings?: any[]): Promise<Record<string, any>[]>
+  abstract statement(sql: string, bindings?: any[]): Promise<number>
+  abstract insertGetId(sql: string, bindings?: any[]): Promise<number | bigint | string>
+  abstract transaction<T>(callback: (connection: DatabaseConnection) => Promise<T>): Promise<T>
+  abstract schema(): SchemaBuilder
+  abstract getDriverName(): string
+
+  getTablePrefix(): string {
+    return ''
+  }
+
+  table(name: string): QueryBuilder {
+    return new QueryBuilder(this, name)
+  }
+
+  // ── Universal executeXxx (compile via Grammar → run via raw methods) ────
+
+  async executeSelect(state: QueryState): Promise<Record<string, any>[]> {
+    const { sql, bindings } = this._grammar.compileSelect(state)
+    return this.select(sql, bindings)
+  }
+
+  async executeInsert(table: string, data: Record<string, any>): Promise<number> {
+    const { sql, bindings } = this._grammar.compileInsert(table, data)
+    return this.statement(sql, bindings)
+  }
+
+  async executeInsertGetId(table: string, data: Record<string, any>): Promise<number | string> {
+    const { sql, bindings } = this._grammar.compileInsertGetId(table, data)
+    const id = await this.insertGetId(sql, bindings)
+    // SQL drivers always return numeric IDs (bigint from SQLite, string from pg for BIGSERIAL)
+    return Number(id)
+  }
+
+  async executeUpdate(table: string, state: QueryState, data: Record<string, any>): Promise<number> {
+    const { sql, bindings } = this._grammar.compileUpdate(table, state, data)
+    return this.statement(sql, bindings)
+  }
+
+  async executeDelete(table: string, state: QueryState): Promise<number> {
+    const { sql, bindings } = this._grammar.compileDelete(table, state)
+    return this.statement(sql, bindings)
+  }
+
+  async executeTruncate(table: string): Promise<void> {
+    const sql = this._grammar.compileTruncate(table)
+    await this.statement(sql, [])
+  }
+
+  async executeAggregate(state: QueryState, fn: 'count' | 'sum' | 'avg' | 'min' | 'max', column: string): Promise<number> {
+    const aggState: QueryState = {
+      ...state,
+      columns: [new Expression(`${fn.toUpperCase()}(${column}) as aggregate`)],
+      orders: [],  // aggregates don't need ORDER BY
+    }
+    const { sql, bindings } = this._grammar.compileSelect(aggState)
+    const rows = await this.select(sql, bindings)
+    return Number(rows[0]?.['aggregate'] ?? 0)
+  }
+
+  async executeExists(state: QueryState): Promise<boolean> {
+    const existsState: QueryState = {
+      ...state,
+      columns: [new Expression('1 as exists_check')],
+      limitValue: 1,
+      orders: [],
+    }
+    const { sql, bindings } = this._grammar.compileSelect(existsState)
+    const rows = await this.select(sql, bindings)
+    return rows.length > 0
+  }
+
+  /**
+   * Creates executeXxx methods for a transactional connection wrapper.
+   * Call this in transaction() to give the txConn the universal methods.
+   */
+  protected applyExecuteMethods(txConn: any): void {
+    txConn.executeSelect = (state: QueryState) =>
+      BaseSQLConnection.prototype.executeSelect.call({ ...txConn, _grammar: this._grammar }, state)
+    txConn.executeInsert = (table: string, data: Record<string, any>) =>
+      BaseSQLConnection.prototype.executeInsert.call({ ...txConn, _grammar: this._grammar }, table, data)
+    txConn.executeInsertGetId = (table: string, data: Record<string, any>) =>
+      BaseSQLConnection.prototype.executeInsertGetId.call({ ...txConn, _grammar: this._grammar }, table, data)
+    txConn.executeUpdate = (table: string, state: QueryState, data: Record<string, any>) =>
+      BaseSQLConnection.prototype.executeUpdate.call({ ...txConn, _grammar: this._grammar }, table, state, data)
+    txConn.executeDelete = (table: string, state: QueryState) =>
+      BaseSQLConnection.prototype.executeDelete.call({ ...txConn, _grammar: this._grammar }, table, state)
+    txConn.executeTruncate = (table: string) =>
+      BaseSQLConnection.prototype.executeTruncate.call({ ...txConn, _grammar: this._grammar }, table)
+    txConn.executeAggregate = (state: QueryState, fn: 'count' | 'sum' | 'avg' | 'min' | 'max', column: string) =>
+      BaseSQLConnection.prototype.executeAggregate.call({ ...txConn, _grammar: this._grammar }, state, fn, column)
+    txConn.executeExists = (state: QueryState) =>
+      BaseSQLConnection.prototype.executeExists.call({ ...txConn, _grammar: this._grammar }, state)
+  }
+}

package/src/drivers/MSSQLConnection.ts

@@ -1,5 +1,6 @@
 import type { DatabaseConnection } from '../contracts/Connection.ts'
 import type { SchemaBuilder } from '../schema/SchemaBuilder.ts'
+import { BaseSQLConnection } from './BaseSQLConnection.ts'
 import { QueryBuilder } from '../query/Builder.ts'
 import { MSSQLGrammar } from './MSSQLGrammar.ts'
 import { SchemaBuilderImpl } from '../schema/SchemaBuilder.ts'
@@ -17,19 +18,21 @@ export interface MSSQLConfig {
   pool?: { min?: number; max?: number }
 }
 
-export class MSSQLConnection implements DatabaseConnection {
+export class MSSQLConnection extends BaseSQLConnection {
   readonly _grammar = new MSSQLGrammar()
   private pool: any = null
   private config: MSSQLConfig
 
   constructor(config: MSSQLConfig) {
+    super()
     this.config = config
   }
 
   private async getPool(): Promise<any> {
     if (!this.pool) {
       try {
-        const mssql = await import('mssql')
+        const mssqlModule = 'mssql'
+        const mssql: any = await import(mssqlModule)
         const sql = mssql.default ?? mssql
         this.pool = await sql.connect({
           server: this.config.host ?? 'localhost',
@@ -95,38 +98,39 @@ export class MSSQLConnection implements DatabaseConnection {
 
   async transaction<T>(callback: (connection: DatabaseConnection) => Promise<T>): Promise<T> {
     const pool = await this.getPool()
-    const mssql = await import('mssql')
+    const mssqlModule = 'mssql'
+    const mssql: any = await import(mssqlModule)
     const sql = mssql.default ?? mssql
     const transaction = new sql.Transaction(pool)
     await transaction.begin()
     try {
-      const txConn: DatabaseConnection = {
-        select: async (s, b = []) => {
+      const txConn: any = {
+        _grammar: this._grammar,
+        select: async (s: string, b: any[] = []) => {
           const req = transaction.request()
           b.forEach((val: any, i: number) => req.input(`p${i + 1}`, val))
           const r = await req.query(s)
           return r.recordset ?? []
         },
-        statement: async (s, b = []) => {
+        statement: async (s: string, b: any[] = []) => {
           const req = transaction.request()
           b.forEach((val: any, i: number) => req.input(`p${i + 1}`, val))
           const r = await req.query(s)
           return r.rowsAffected?.[0] ?? 0
         },
-        insertGetId: async (s, b = []) => {
+        insertGetId: async (s: string, b: any[] = []) => {
           const req = transaction.request()
           b.forEach((val: any, i: number) => req.input(`p${i + 1}`, val))
           const r = await req.query(s)
           return r.recordset?.[0]?.id ?? 0
         },
-        transaction: (cb) => cb(txConn),
-        table: (name) => new QueryBuilder(txConn, name),
+        transaction: (cb: any) => cb(txConn),
+        table: (name: string) => new QueryBuilder(txConn, name),
         schema: () => new SchemaBuilderImpl(txConn),
         getDriverName: () => 'mssql',
         getTablePrefix: () => '',
       }
-      // @ts-ignore — attach grammar
-      txConn._grammar = this._grammar
+      this.applyExecuteMethods(txConn)
       const result = await callback(txConn)
       await transaction.commit()
       return result
@@ -136,10 +140,6 @@ export class MSSQLConnection implements DatabaseConnection {
     }
   }
 
-  table(name: string): QueryBuilder {
-    return new QueryBuilder(this, name)
-  }
-
   schema(): SchemaBuilder {
     return new SchemaBuilderImpl(this)
   }
@@ -147,8 +147,4 @@ export class MSSQLConnection implements DatabaseConnection {
   getDriverName(): string {
     return 'mssql'
   }
-
-  getTablePrefix(): string {
-    return ''
-  }
 }