@mantiq/database 0.1.4 → 0.3.0-rc.1

package/src/drivers/MongoConnection.ts

@@ -1,5 +1,6 @@
+import type { DatabaseConnection } from '../contracts/Connection.ts'
+import type { SchemaBuilder } from '../schema/SchemaBuilder.ts'
 import type {
-  MongoDatabaseConnection,
   MongoCollectionContract,
   MongoFilter,
   MongoUpdateDoc,
@@ -10,159 +11,160 @@ import type {
   MongoDeleteResult,
   MongoQueryBuilder,
 } from '../contracts/MongoConnection.ts'
+import type { QueryState, WhereClause } from '../query/Builder.ts'
+import { QueryBuilder } from '../query/Builder.ts'
+import { Expression } from '../query/Expression.ts'
 import { MongoQueryBuilderImpl } from './MongoQueryBuilderImpl.ts'
 import { ConnectionError } from '../errors/ConnectionError.ts'
-import { QueryError } from '../errors/QueryError.ts'
+import { DriverNotSupportedError } from '../errors/DriverNotSupportedError.ts'
 
 export interface MongoConfig {
   uri: string
   database: string
-  options?: Record<string, any>
+  options?: Record<string, any> | undefined
 }
 
-class MongoCollectionImpl implements MongoCollectionContract {
-  constructor(
-    private readonly col: any,
-    private readonly name: string,
-  ) {}
+// ── Operator translation map ──────────────────────────────────────────────────
 
-  find(filter: MongoFilter = {}): MongoQueryBuilder {
-    return new MongoQueryBuilderImpl(
-      this.name,
-      async (opts) => {
-        let cursor = this.col.find(opts.filter ?? {})
-        if (opts.projection) cursor = cursor.project(opts.projection)
-        if (opts.sort) cursor = cursor.sort(opts.sort)
-        if (opts.skip) cursor = cursor.skip(opts.skip)
-        if (opts.limit) cursor = cursor.limit(opts.limit)
-        return cursor.toArray()
-      },
-      async (f) => this.col.countDocuments(f),
-    )
-  }
+const OPERATOR_MAP: Record<string, string> = {
+  '=': '$eq',
+  '!=': '$ne',
+  '<>': '$ne',
+  '>': '$gt',
+  '>=': '$gte',
+  '<': '$lt',
+  '<=': '$lte',
+}
 
-  async findOne(filter: MongoFilter = {}): Promise<Record<string, any> | null> {
-    return this.col.findOne(filter)
-  }
+// ── MongoConnection — implements the universal DatabaseConnection interface ──
 
-  async findById(id: any): Promise<Record<string, any> | null> {
-    const { ObjectId } = await import('mongodb')
-    return this.col.findOne({ _id: typeof id === 'string' ? new ObjectId(id) : id })
-  }
+export class MongoConnection implements DatabaseConnection {
+  private client: any = null
+  private db: any = null
+  private config: MongoConfig
 
-  async insertOne(doc: Record<string, any>): Promise<MongoInsertResult> {
-    const result = await this.col.insertOne(doc)
-    return { insertedId: result.insertedId, acknowledged: result.acknowledged }
+  constructor(config: MongoConfig) {
+    this.config = config
   }
 
-  async insertMany(docs: Record<string, any>[]): Promise<MongoInsertManyResult> {
-    const result = await this.col.insertMany(docs)
-    return {
-      insertedIds: Object.values(result.insertedIds),
-      acknowledged: result.acknowledged,
-      insertedCount: result.insertedCount,
+  private async getDb(): Promise<any> {
+    if (!this.db) {
+      try {
+        const mongoModule = 'mongodb'
+        const { MongoClient } = await import(/* webpackIgnore: true */ mongoModule)
+        this.client = new MongoClient(this.config.uri, this.config.options ?? {})
+        await this.client.connect()
+        this.db = this.client.db(this.config.database)
+      } catch (e: any) {
+        throw new ConnectionError(`MongoDB connection failed: ${e.message}`, 'mongodb', e)
+      }
     }
+    return this.db
   }
 
-  async updateOne(filter: MongoFilter, update: MongoUpdateDoc): Promise<MongoUpdateResult> {
-    const result = await this.col.updateOne(filter, update)
-    return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount, acknowledged: result.acknowledged }
-  }
+  // ── Universal executeXxx methods ──────────────────────────────────────────
 
-  async updateMany(filter: MongoFilter, update: MongoUpdateDoc): Promise<MongoUpdateResult> {
-    const result = await this.col.updateMany(filter, update)
-    return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount, acknowledged: result.acknowledged }
-  }
+  async executeSelect(state: QueryState): Promise<Record<string, any>[]> {
+    this.guardNoJoins(state)
+    this.guardNoHavings(state)
 
-  async replaceOne(filter: MongoFilter, replacement: Record<string, any>): Promise<MongoUpdateResult> {
-    const result = await this.col.replaceOne(filter, replacement)
-    return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount, acknowledged: result.acknowledged }
+    const db = await this.getDb()
+    const col = db.collection(state.table)
+    const filter = this.translateWheres(state.wheres)
+    const projection = this.translateColumns(state.columns)
+    const sort = this.translateOrders(state.orders)
+
+    let cursor = col.find(filter)
+    if (projection) cursor = cursor.project(projection)
+    if (sort) cursor = cursor.sort(sort)
+    if (state.offsetValue !== null) cursor = cursor.skip(state.offsetValue)
+    if (state.limitValue !== null) cursor = cursor.limit(state.limitValue)
+
+    return cursor.toArray()
   }
 
-  async upsert(filter: MongoFilter, update: MongoUpdateDoc): Promise<MongoUpdateResult> {
-    const result = await this.col.updateOne(filter, update, { upsert: true })
-    return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount, acknowledged: result.acknowledged }
+  async executeInsert(table: string, data: Record<string, any>): Promise<number> {
+    const db = await this.getDb()
+    const result = await db.collection(table).insertOne(data)
+    return result.acknowledged ? 1 : 0
   }
 
-  async deleteOne(filter: MongoFilter): Promise<MongoDeleteResult> {
-    const result = await this.col.deleteOne(filter)
-    return { deletedCount: result.deletedCount, acknowledged: result.acknowledged }
+  async executeInsertGetId(table: string, data: Record<string, any>): Promise<number | string> {
+    const db = await this.getDb()
+    const result = await db.collection(table).insertOne(data)
+    const id = result.insertedId
+    return typeof id === 'object' ? id.toString() : id
   }
 
-  async deleteMany(filter: MongoFilter): Promise<MongoDeleteResult> {
-    const result = await this.col.deleteMany(filter)
-    return { deletedCount: result.deletedCount, acknowledged: result.acknowledged }
+  async executeUpdate(table: string, state: QueryState, data: Record<string, any>): Promise<number> {
+    const db = await this.getDb()
+    const filter = this.translateWheres(state.wheres)
+    const result = await db.collection(table).updateMany(filter, { $set: data })
+    return result.modifiedCount
   }
 
-  async aggregate(pipeline: MongoPipelineStage[]): Promise<Record<string, any>[]> {
-    return this.col.aggregate(pipeline).toArray()
+  async executeDelete(table: string, state: QueryState): Promise<number> {
+    const db = await this.getDb()
+    const filter = this.translateWheres(state.wheres)
+    const result = await db.collection(table).deleteMany(filter)
+    return result.deletedCount
   }
 
-  async count(filter: MongoFilter = {}): Promise<number> {
-    return this.col.countDocuments(filter)
+  async executeTruncate(table: string): Promise<void> {
+    const db = await this.getDb()
+    await db.collection(table).deleteMany({})
   }
 
-  async createIndex(spec: Record<string, any>, options?: Record<string, any>): Promise<string> {
-    return this.col.createIndex(spec, options)
+  async executeAggregate(state: QueryState, fn: 'count' | 'sum' | 'avg' | 'min' | 'max', column: string): Promise<number> {
+    const db = await this.getDb()
+    const filter = this.translateWheres(state.wheres)
+
+    if (fn === 'count') {
+      return db.collection(state.table).countDocuments(filter)
+    }
+
+    const aggOp = `$${fn}`
+    const aggField = column === '*' ? 1 : `$${column}`
+    const pipeline: any[] = [
+      { $match: filter },
+      { $group: { _id: null, result: { [aggOp]: aggField } } },
+    ]
+    const [row] = await db.collection(state.table).aggregate(pipeline).toArray()
+    return Number(row?.result ?? 0)
   }
 
-  async drop(): Promise<boolean> {
-    return this.col.drop()
+  async executeExists(state: QueryState): Promise<boolean> {
+    const db = await this.getDb()
+    const filter = this.translateWheres(state.wheres)
+    const count = await db.collection(state.table).countDocuments(filter, { limit: 1 })
+    return count > 0
   }
-}
 
-export class MongoConnection implements MongoDatabaseConnection {
-  private client: any = null
-  private db: any = null
-  private config: MongoConfig
+  // ── Raw SQL methods — throw on MongoDB ────────────────────────────────────
 
-  constructor(config: MongoConfig) {
-    this.config = config
+  async select(sql: string, bindings?: any[]): Promise<Record<string, any>[]> {
+    throw new DriverNotSupportedError('mongodb', 'raw SQL queries')
   }
 
-  private async getDb(): Promise<any> {
-    if (!this.db) {
-      try {
-        const { MongoClient } = await import('mongodb')
-        this.client = new MongoClient(this.config.uri, this.config.options ?? {})
-        await this.client.connect()
-        this.db = this.client.db(this.config.database)
-      } catch (e: any) {
-        throw new ConnectionError(`MongoDB connection failed: ${e.message}`, 'mongodb', e)
-      }
-    }
-    return this.db
+  async statement(sql: string, bindings?: any[]): Promise<number> {
+    throw new DriverNotSupportedError('mongodb', 'raw SQL queries')
   }
 
-  collection(name: string): MongoCollectionContract {
-    // Lazily get collection — actual DB ops will connect
-    const self = this
-    const col = {
-      async getCol() {
-        const db = await self.getDb()
-        return db.collection(name)
-      },
-    }
-
-    // We need to return a proxy that defers the actual collection resolution
-    return new LazyMongoCollection(name, async () => {
-      const db = await self.getDb()
-      return db.collection(name)
-    })
+  async insertGetId(sql: string, bindings?: any[]): Promise<number | bigint | string> {
+    throw new DriverNotSupportedError('mongodb', 'raw SQL queries')
   }
 
-  async command(command: Record<string, any>): Promise<any> {
-    const db = await this.getDb()
-    return db.command(command)
+  // ── Shared interface ──────────────────────────────────────────────────────
+
+  table(name: string): QueryBuilder {
+    return new QueryBuilder(this, name)
   }
 
-  async listCollections(): Promise<string[]> {
-    const db = await this.getDb()
-    const collections = await db.listCollections().toArray()
-    return collections.map((c: any) => c.name)
+  schema(): SchemaBuilder {
+    throw new DriverNotSupportedError('mongodb', 'schema builder (MongoDB is schemaless — use native() for indexes)')
   }
 
-  async transaction<T>(callback: (conn: MongoDatabaseConnection) => Promise<T>): Promise<T> {
+  async transaction<T>(callback: (conn: DatabaseConnection) => Promise<T>): Promise<T> {
     const client = await this.getClient()
     const session = client.startSession()
     try {
@@ -179,22 +181,194 @@ export class MongoConnection implements MongoDatabaseConnection {
     }
   }
 
-  private async getClient(): Promise<any> {
-    await this.getDb()
-    return this.client
-  }
-
   getDriverName(): string {
     return 'mongodb'
   }
 
+  getTablePrefix(): string {
+    return ''
+  }
+
+  // ── Native escape hatch — direct MongoDB access ───────────────────────────
+
+  /** Returns the native MongoDB collection for advanced operations. */
+  collection(name: string): MongoCollectionContract {
+    return new LazyMongoCollection(name, async () => {
+      const db = await this.getDb()
+      return db.collection(name)
+    })
+  }
+
+  /** Returns the underlying MongoDB Db instance. */
+  async native(): Promise<any> {
+    return this.getDb()
+  }
+
+  async command(command: Record<string, any>): Promise<any> {
+    const db = await this.getDb()
+    return db.command(command)
+  }
+
+  async listCollections(): Promise<string[]> {
+    const db = await this.getDb()
+    const collections = await db.listCollections().toArray()
+    return collections.map((c: any) => c.name)
+  }
+
   async disconnect(): Promise<void> {
     await this.client?.close()
     this.client = null
     this.db = null
   }
+
+  private async getClient(): Promise<any> {
+    await this.getDb()
+    return this.client
+  }
+
+  // ── QueryState → MongoDB translation ──────────────────────────────────────
+
+  private translateWheres(wheres: WhereClause[]): Record<string, any> {
+    if (wheres.length === 0) return {}
+
+    const andClauses: Record<string, any>[] = []
+    const orGroups: Record<string, any>[][] = []
+    let currentAnd: Record<string, any>[] = []
+
+    for (const w of wheres) {
+      const clause = this.translateSingleWhere(w)
+
+      if (w.boolean === 'or' && currentAnd.length > 0) {
+        // Push accumulated AND clauses as one OR branch
+        orGroups.push(currentAnd)
+        currentAnd = [clause]
+      } else {
+        currentAnd.push(clause)
+      }
+    }
+
+    // Final group
+    if (orGroups.length > 0) {
+      orGroups.push(currentAnd)
+      return { $or: orGroups.map((group) => group.length === 1 ? group[0]! : { $and: group }) }
+    }
+
+    if (currentAnd.length === 1) return currentAnd[0]!
+    return { $and: currentAnd }
+  }
+
+  private translateSingleWhere(w: WhereClause): Record<string, any> {
+    switch (w.type) {
+      case 'basic': {
+        const col = w.column!
+        const op = w.operator ?? '='
+        const val = w.value
+
+        if (op === '=' || op === '$eq') {
+          return { [col]: val }
+        }
+
+        if (op === 'like' || op === 'LIKE') {
+          return { [col]: { $regex: this.likeToRegex(val), $options: 'i' } }
+        }
+
+        if (op === 'not like' || op === 'NOT LIKE') {
+          return { [col]: { $not: { $regex: this.likeToRegex(val), $options: 'i' } } }
+        }
+
+        const mongoOp = OPERATOR_MAP[op]
+        if (mongoOp) {
+          return { [col]: { [mongoOp]: val } }
+        }
+
+        throw new DriverNotSupportedError('mongodb', `operator "${op}"`)
+      }
+
+      case 'in':
+        return { [w.column!]: { $in: w.values! } }
+
+      case 'notIn':
+        return { [w.column!]: { $nin: w.values! } }
+
+      case 'null':
+        return { [w.column!]: null }
+
+      case 'notNull':
+        return { [w.column!]: { $ne: null } }
+
+      case 'between':
+        return { [w.column!]: { $gte: w.range![0], $lte: w.range![1] } }
+
+      case 'nested':
+        return this.translateWheres(w.nested ?? [])
+
+      case 'raw':
+        throw new DriverNotSupportedError('mongodb', 'whereRaw (use standard where methods instead)')
+
+      case 'column':
+        throw new DriverNotSupportedError('mongodb', 'whereColumn (use $expr in native queries instead)')
+
+      default:
+        throw new DriverNotSupportedError('mongodb', `where type "${w.type}"`)
+    }
+  }
+
+  private translateColumns(columns: (string | Expression)[]): Record<string, 1> | undefined {
+    if (columns.length === 1 && columns[0] === '*') return undefined
+    if (columns.some((c) => c instanceof Expression)) {
+      // Allow expressions only if they're simple strings (column names)
+      // For actual SQL expressions, throw
+      const hasRealExpressions = columns.some((c) => c instanceof Expression && (c.value.includes('(') || c.value.includes(' ')))
+      if (hasRealExpressions) {
+        throw new DriverNotSupportedError('mongodb', 'selectRaw with SQL expressions')
+      }
+    }
+
+    const projection: Record<string, 1> = {}
+    for (const col of columns) {
+      const name = col instanceof Expression ? col.value : col
+      projection[name] = 1
+    }
+    return projection
+  }
+
+  private translateOrders(orders: Array<{ column: string | Expression; direction: 'asc' | 'desc' }>): Record<string, 1 | -1> | undefined {
+    if (orders.length === 0) return undefined
+    const sort: Record<string, 1 | -1> = {}
+    for (const o of orders) {
+      if (o.column instanceof Expression) {
+        throw new DriverNotSupportedError('mongodb', 'orderBy with raw Expression')
+      }
+      sort[o.column] = o.direction === 'asc' ? 1 : -1
+    }
+    return sort
+  }
+
+  /** Converts SQL LIKE pattern to regex: % → .*, _ → . */
+  private likeToRegex(pattern: string): string {
+    return pattern
+      .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+      .replace(/%/g, '.*')
+      .replace(/_/g, '.')
+  }
+
+  // ── Guards ────────────────────────────────────────────────────────────────
+
+  private guardNoJoins(state: QueryState): void {
+    if (state.joins.length > 0) {
+      throw new DriverNotSupportedError('mongodb', 'joins (use relationships or native $lookup instead)')
+    }
+  }
+
+  private guardNoHavings(state: QueryState): void {
+    if (state.havings.length > 0) {
+      throw new DriverNotSupportedError('mongodb', 'having (use native aggregation pipeline instead)')
+    }
+  }
 }
 
+// ── LazyMongoCollection — deferred collection resolution ────────────────────
+
 class LazyMongoCollection implements MongoCollectionContract {
   private _col: any = null
 
@@ -232,7 +406,8 @@ class LazyMongoCollection implements MongoCollectionContract {
   }
 
   async findById(id: any): Promise<Record<string, any> | null> {
-    const { ObjectId } = await import('mongodb')
+    const mongoModule = 'mongodb'
+    const { ObjectId } = await import(/* webpackIgnore: true */ mongoModule)
     return (await this.col()).findOne({ _id: typeof id === 'string' ? new ObjectId(id) : id })
   }
 

package/src/drivers/MongoQueryBuilderImpl.ts

@@ -17,10 +17,10 @@ export class MongoQueryBuilderImpl implements MongoQueryBuilder {
     private readonly collectionName: string,
     private readonly executor: (opts: {
       filter: MongoFilter
-      projection?: MongoProjection
-      sort?: MongoSortDoc
-      limit?: number
-      skip?: number
+      projection?: MongoProjection | undefined
+      sort?: MongoSortDoc | undefined
+      limit?: number | undefined
+      skip?: number | undefined
     }) => Promise<Record<string, any>[]>,
     private readonly counter: (filter: MongoFilter) => Promise<number>,
   ) {}

package/src/drivers/MySQLConnection.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 { MySQLGrammar } from './MySQLGrammar.ts'
 import { SchemaBuilderImpl } from '../schema/SchemaBuilder.ts'
@@ -7,27 +8,28 @@ import { ConnectionError } from '../errors/ConnectionError.ts'
 import { QueryError } from '../errors/QueryError.ts'
 
 export interface MySQLConfig {
-  host?: string
-  port?: number
+  host?: string | undefined
+  port?: number | undefined
   database: string
-  user?: string
-  password?: string
-  pool?: { min?: number; max?: number }
+  user?: string | undefined
+  password?: string | undefined
+  pool?: { min?: number | undefined; max?: number | undefined } | undefined
 }
 
-export class MySQLConnection implements DatabaseConnection {
+export class MySQLConnection extends BaseSQLConnection {
   readonly _grammar = new MySQLGrammar()
   private pool: any = null
   private config: MySQLConfig
 
   constructor(config: MySQLConfig) {
+    super()
     this.config = config
   }
 
   private async getPool(): Promise<any> {
     if (!this.pool) {
       try {
-        const mysql = await import('mysql2/promise')
+        const mysql: any = await import('mysql2/promise')
         this.pool = await mysql.createPool({
           host: this.config.host ?? 'localhost',
           port: this.config.port ?? 3306,
@@ -79,18 +81,18 @@ export class MySQLConnection implements DatabaseConnection {
     const conn = await pool.getConnection()
     try {
       await conn.beginTransaction()
-      const txConn: DatabaseConnection = {
-        select: async (sql, b) => { const [rows] = await conn.query(sql, b); return rows as Record<string, any>[] },
-        statement: async (sql, b) => { const [r] = await conn.query(sql, b); return (r as any).affectedRows ?? 0 },
-        insertGetId: async (sql, b) => { const [r] = await conn.query(sql, b); return (r as any).insertId ?? 0 },
-        transaction: (cb) => cb(txConn),
-        table: (name) => new QueryBuilder(txConn, name),
+      const txConn: any = {
+        _grammar: this._grammar,
+        select: async (sql: string, b?: any[]) => { const [rows] = await conn.query(sql, b); return rows as Record<string, any>[] },
+        statement: async (sql: string, b?: any[]) => { const [r] = await conn.query(sql, b); return (r as any).affectedRows ?? 0 },
+        insertGetId: async (sql: string, b?: any[]) => { const [r] = await conn.query(sql, b); return (r as any).insertId ?? 0 },
+        transaction: (cb: any) => cb(txConn),
+        table: (name: string) => new QueryBuilder(txConn, name),
         schema: () => new SchemaBuilderImpl(txConn),
         getDriverName: () => 'mysql',
         getTablePrefix: () => '',
       }
-      // @ts-ignore — attach grammar
-      txConn._grammar = this._grammar
+      this.applyExecuteMethods(txConn)
       const result = await callback(txConn)
       await conn.commit()
       return result
@@ -102,10 +104,6 @@ export class MySQLConnection implements DatabaseConnection {
     }
   }
 
-  table(name: string): QueryBuilder {
-    return new QueryBuilder(this, name)
-  }
-
   schema(): SchemaBuilder {
     return new SchemaBuilderImpl(this)
   }
@@ -113,8 +111,4 @@ export class MySQLConnection implements DatabaseConnection {
   getDriverName(): string {
     return 'mysql'
   }
-
-  getTablePrefix(): string {
-    return ''
-  }
 }

package/src/drivers/PostgresConnection.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 { PostgresGrammar } from './PostgresGrammar.ts'
 import { SchemaBuilderImpl } from '../schema/SchemaBuilder.ts'
@@ -7,21 +8,22 @@ import { ConnectionError } from '../errors/ConnectionError.ts'
 import { QueryError } from '../errors/QueryError.ts'
 
 export interface PostgresConfig {
-  host?: string
-  port?: number
+  host?: string | undefined
+  port?: number | undefined
   database: string
-  user?: string
-  password?: string
-  ssl?: boolean
-  pool?: { min?: number; max?: number }
+  user?: string | undefined
+  password?: string | undefined
+  ssl?: boolean | undefined
+  pool?: { min?: number | undefined; max?: number | undefined } | undefined
 }
 
-export class PostgresConnection implements DatabaseConnection {
+export class PostgresConnection extends BaseSQLConnection {
   readonly _grammar = new PostgresGrammar()
   private client: any = null
   private config: PostgresConfig
 
   constructor(config: PostgresConfig) {
+    super()
     this.config = config
   }
 
@@ -83,19 +85,18 @@ export class PostgresConnection implements DatabaseConnection {
     const client = await pool.connect()
     try {
       await client.query('BEGIN')
-      // Create a transactional connection wrapper
-      const txConn: DatabaseConnection = {
-        select: async (sql, b) => { const r = await client.query(sql, b); return r.rows },
-        statement: async (sql, b) => { const r = await client.query(sql, b); return r.rowCount ?? 0 },
-        insertGetId: async (sql, b) => { const r = await client.query(sql, b); return r.rows[0]?.id ?? 0 },
-        transaction: (cb) => cb(txConn),
-        table: (name) => new QueryBuilder(txConn, name),
+      const txConn: any = {
+        _grammar: this._grammar,
+        select: async (sql: string, b?: any[]) => { const r = await client.query(sql, b); return r.rows },
+        statement: async (sql: string, b?: any[]) => { const r = await client.query(sql, b); return r.rowCount ?? 0 },
+        insertGetId: async (sql: string, b?: any[]) => { const r = await client.query(sql, b); return r.rows[0]?.id ?? 0 },
+        transaction: (cb: any) => cb(txConn),
+        table: (name: string) => new QueryBuilder(txConn, name),
         schema: () => new SchemaBuilderImpl(txConn),
         getDriverName: () => 'postgres',
         getTablePrefix: () => '',
       }
-      // @ts-ignore — attach grammar for the builder
-      txConn._grammar = this._grammar
+      this.applyExecuteMethods(txConn)
       const result = await callback(txConn)
       await client.query('COMMIT')
       return result
@@ -107,10 +108,6 @@ export class PostgresConnection implements DatabaseConnection {
     }
   }
 
-  table(name: string): QueryBuilder {
-    return new QueryBuilder(this, name)
-  }
-
   schema(): SchemaBuilder {
     return new SchemaBuilderImpl(this)
   }
@@ -118,8 +115,4 @@ export class PostgresConnection implements DatabaseConnection {
   getDriverName(): string {
     return 'postgres'
   }
-
-  getTablePrefix(): string {
-    return ''
-  }
 }