@mantiq/database 0.1.4 → 0.3.0-rc.1

package/src/drivers/SQLiteConnection.ts

@@ -1,6 +1,7 @@
-import type { DatabaseConnection } from '../contracts/Connection.ts'
 import type { SchemaBuilder } from '../schema/SchemaBuilder.ts'
 import type { EventDispatcher } from '@mantiq/core'
+import type { DatabaseConnection } from '../contracts/Connection.ts'
+import { BaseSQLConnection } from './BaseSQLConnection.ts'
 import { QueryBuilder } from '../query/Builder.ts'
 import { SQLiteGrammar } from './SQLiteGrammar.ts'
 import { SchemaBuilderImpl } from '../schema/SchemaBuilder.ts'
@@ -12,7 +13,7 @@ export interface SQLiteConfig {
   database: string  // ':memory:' or file path
 }
 
-export class SQLiteConnection implements DatabaseConnection {
+export class SQLiteConnection extends BaseSQLConnection {
   readonly _grammar = new SQLiteGrammar()
   private db: import('bun:sqlite').Database | null = null
   private config: SQLiteConfig
@@ -21,6 +22,7 @@ export class SQLiteConnection implements DatabaseConnection {
   static _dispatcher: EventDispatcher | null = null
 
   constructor(config: SQLiteConfig) {
+    super()
     this.config = config
   }
 
@@ -102,10 +104,6 @@ export class SQLiteConnection implements DatabaseConnection {
     await SQLiteConnection._dispatcher?.emit(new QueryExecuted(sql, bindings, time, 'sqlite'))
   }
 
-  table(name: string): QueryBuilder {
-    return new QueryBuilder(this, name)
-  }
-
   schema(): SchemaBuilder {
     return new SchemaBuilderImpl(this)
   }
@@ -114,10 +112,6 @@ export class SQLiteConnection implements DatabaseConnection {
     return 'sqlite'
   }
 
-  getTablePrefix(): string {
-    return ''
-  }
-
   close(): void {
     this.db?.close()
     this.db = null

package/src/errors/ConnectionError.ts

@@ -1,10 +1,10 @@
-import { MantiqError } from '@mantiq/core'
-
-export class ConnectionError extends MantiqError {
+export class ConnectionError extends Error {
   constructor(
+    message: string,
     public readonly driver: string,
-    originalError: Error,
+    originalError?: Error,
   ) {
-    super(`Failed to connect to ${driver} database: ${originalError.message}`)
+    super(originalError ? `${message}: ${originalError.message}` : message)
+    this.name = 'ConnectionError'
   }
 }

package/src/errors/DriverNotSupportedError.ts

@@ -0,0 +1,6 @@
+export class DriverNotSupportedError extends Error {
+  constructor(driver: string, feature: string) {
+    super(`"${feature}" is not supported by the ${driver} driver.`)
+    this.name = 'DriverNotSupportedError'
+  }
+}

package/src/index.ts

@@ -21,6 +21,7 @@ export type {
 export { QueryError } from './errors/QueryError.ts'
 export { ModelNotFoundError } from './errors/ModelNotFoundError.ts'
 export { ConnectionError } from './errors/ConnectionError.ts'
+export { DriverNotSupportedError } from './errors/DriverNotSupportedError.ts'
 
 // ── Query Builder ─────────────────────────────────────────────────────────────
 export { QueryBuilder } from './query/Builder.ts'
@@ -34,6 +35,9 @@ export { PostgresGrammar } from './drivers/PostgresGrammar.ts'
 export { MySQLGrammar } from './drivers/MySQLGrammar.ts'
 export { MSSQLGrammar } from './drivers/MSSQLGrammar.ts'
 
+// ── Base Connection ──────────────────────────────────────────────────────────
+export { BaseSQLConnection } from './drivers/BaseSQLConnection.ts'
+
 // ── SQL Connections ───────────────────────────────────────────────────────────
 export { SQLiteConnection } from './drivers/SQLiteConnection.ts'
 export type { SQLiteConfig } from './drivers/SQLiteConnection.ts'
@@ -76,7 +80,8 @@ export type { ModelStatic } from './orm/Model.ts'
 export { ModelQueryBuilder } from './orm/ModelQueryBuilder.ts'
 export { Collection } from './orm/Collection.ts'
 
-// ── MongoDB Document ORM ──────────────────────────────────────────────────────
+// ── MongoDB Document ORM (deprecated — use Model with MongoDB connection) ────
+/** @deprecated Use Model with a MongoDB connection instead */
 export { Document } from './orm/Document.ts'
 
 // ── Seeders & Factories ───────────────────────────────────────────────────────

package/src/orm/Document.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck — deprecated, replaced by Model with MongoDB connection
 import type { MongoDatabaseConnection, MongoFilter, MongoUpdateDoc, MongoPipelineStage } from '../contracts/MongoConnection.ts'
 import { ModelNotFoundError } from '../errors/ModelNotFoundError.ts'
 
@@ -27,34 +28,34 @@ export abstract class Document {
 
   // ── Static query API ───────────────────────────────────────────────────────
 
-  static col<T extends Document>(this: new () => T): import('../contracts/MongoConnection.ts').MongoCollectionContract {
+  static col<T extends Document>(this: { new(): T } & typeof Document): import('../contracts/MongoConnection.ts').MongoCollectionContract {
     const ctor = this as unknown as typeof Document
     if (!ctor.connection) throw new Error(`No connection set on Document ${ctor.collection}`)
     return ctor.connection.collection(ctor.collection)
   }
 
-  static async find<T extends Document>(this: new () => T, filter: MongoFilter = {}): Promise<T[]> {
+  static async find<T extends Document>(this: { new(): T } & typeof Document, filter: MongoFilter = {}): Promise<T[]> {
     const rows = await (this as unknown as typeof Document).col<T>().find(filter).get()
     return rows.map((r) => (this as unknown as typeof Document).hydrate<T>(this, r))
   }
 
-  static async findOne<T extends Document>(this: new () => T, filter: MongoFilter = {}): Promise<T | null> {
+  static async findOne<T extends Document>(this: { new(): T } & typeof Document, filter: MongoFilter = {}): Promise<T | null> {
     const row = await (this as unknown as typeof Document).col<T>().findOne(filter)
     return row ? (this as unknown as typeof Document).hydrate<T>(this, row) : null
   }
 
-  static async findById<T extends Document>(this: new () => T, id: any): Promise<T | null> {
+  static async findById<T extends Document>(this: { new(): T } & typeof Document, id: any): Promise<T | null> {
     const row = await (this as unknown as typeof Document).col<T>().findById(id)
     return row ? (this as unknown as typeof Document).hydrate<T>(this, row) : null
   }
 
-  static async findByIdOrFail<T extends Document>(this: new () => T, id: any): Promise<T> {
+  static async findByIdOrFail<T extends Document>(this: { new(): T } & typeof Document, id: any): Promise<T> {
     const doc = await (this as unknown as typeof Document).findById<T>(id)
     if (!doc) throw new ModelNotFoundError((this as unknown as typeof Document).collection)
     return doc
   }
 
-  static async create<T extends Document>(this: new () => T, data: Record<string, any>): Promise<T> {
+  static async create<T extends Document>(this: { new(): T } & typeof Document, data: Record<string, any>): Promise<T> {
     const col = (this as unknown as typeof Document).col<T>()
     const now = new Date()
     const doc = { ...data, createdAt: now, updatedAt: now }
@@ -63,7 +64,7 @@ export abstract class Document {
   }
 
   static async insertMany<T extends Document>(
-    this: new () => T,
+    this: { new(): T } & typeof Document,
     docs: Record<string, any>[],
   ): Promise<T[]> {
     const col = (this as unknown as typeof Document).col<T>()
@@ -76,7 +77,7 @@ export abstract class Document {
   }
 
   static async updateOne<T extends Document>(
-    this: new () => T,
+    this: { new(): T } & typeof Document,
     filter: MongoFilter,
     update: MongoUpdateDoc,
   ) {
@@ -88,7 +89,7 @@ export abstract class Document {
   }
 
   static async updateMany<T extends Document>(
-    this: new () => T,
+    this: { new(): T } & typeof Document,
     filter: MongoFilter,
     update: MongoUpdateDoc,
   ) {
@@ -99,22 +100,22 @@ export abstract class Document {
     return (this as unknown as typeof Document).col<T>().updateMany(filter, merged)
   }
 
-  static async deleteOne<T extends Document>(this: new () => T, filter: MongoFilter) {
+  static async deleteOne<T extends Document>(this: { new(): T } & typeof Document, filter: MongoFilter) {
     return (this as unknown as typeof Document).col<T>().deleteOne(filter)
   }
 
-  static async deleteMany<T extends Document>(this: new () => T, filter: MongoFilter) {
+  static async deleteMany<T extends Document>(this: { new(): T } & typeof Document, filter: MongoFilter) {
     return (this as unknown as typeof Document).col<T>().deleteMany(filter)
   }
 
   static async aggregate<T extends Document>(
-    this: new () => T,
+    this: { new(): T } & typeof Document,
     pipeline: MongoPipelineStage[],
   ): Promise<Record<string, any>[]> {
     return (this as unknown as typeof Document).col<T>().aggregate(pipeline)
   }
 
-  static async count<T extends Document>(this: new () => T, filter: MongoFilter = {}): Promise<number> {
+  static async count<T extends Document>(this: { new(): T } & typeof Document, filter: MongoFilter = {}): Promise<number> {
     return (this as unknown as typeof Document).col<T>().count(filter)
   }
 

package/src/orm/Model.ts

@@ -12,6 +12,8 @@ export interface ModelStatic<T extends Model> {
   connection: DatabaseConnection | null
   table: string
   primaryKey: string
+  incrementing: boolean
+  keyType: 'int' | 'string'
   fillable: string[]
   guarded: string[]
   hidden: string[]
@@ -56,6 +58,8 @@ export abstract class Model {
   static connection: DatabaseConnection | null = null
   static table: string = ''
   static primaryKey: string = 'id'
+  static incrementing = true
+  static keyType: 'int' | 'string' = 'int'
   static fillable: string[] = []
   static guarded: string[] = ['id']
   static hidden: string[] = []
@@ -469,8 +473,13 @@ export abstract class Model {
         if (!this._attributes['updated_at']) this._attributes['updated_at'] = now
       }
 
-      const id = await ctor.connection.table(table).insertGetId(this._attributes)
-      this._attributes[ctor.primaryKey] = Number(id)
+      if (ctor.incrementing) {
+        const id = await ctor.connection.table(table).insertGetId(this._attributes)
+        this._attributes[ctor.primaryKey] = Number(id)
+      } else {
+        // Non-incrementing (UUID) — id is already set in attributes
+        await ctor.connection.table(table).insert(this._attributes)
+      }
       this._original = { ...this._attributes }
       this._exists = true
 

package/src/orm/ModelQueryBuilder.ts

@@ -3,6 +3,7 @@ import { ModelNotFoundError } from '../errors/ModelNotFoundError.ts'
 import { eagerLoadRelations, type EagerLoadSpec, normalizeEagerLoads } from './eagerLoad.ts'
 import type { Model } from './Model.ts'
 import type { DatabaseConnection } from '../contracts/Connection.ts'
+import type { PaginationResult } from '../contracts/Paginator.ts'
 
 export class ModelQueryBuilder<T> extends QueryBuilder {
   private _eagerLoads: string[] = []
@@ -131,7 +132,7 @@ export class ModelQueryBuilder<T> extends QueryBuilder {
 
   // ── Hydrating read methods ─────────────────────────────────────────────────
 
-  override async get(): Promise<T[]> {
+  override async get(): Promise<any[]> {
     this.applyGlobalScopes()
     const rows = await this.raw().get()
     const models = rows.map(this._hydrate)
@@ -148,7 +149,7 @@ export class ModelQueryBuilder<T> extends QueryBuilder {
     return models
   }
 
-  override async first(): Promise<T | null> {
+  override async first(): Promise<any> {
     this.applyGlobalScopes()
     const row = await this.raw().first()
     if (!row) return null
@@ -166,13 +167,13 @@ export class ModelQueryBuilder<T> extends QueryBuilder {
     return model
   }
 
-  async firstOrFail(): Promise<T> {
+  override async firstOrFail(): Promise<any> {
     const result = await this.first()
     if (!result) throw new ModelNotFoundError(this.state.table)
     return result
   }
 
-  override async find(id: number | string): Promise<T | null> {
+  override async find(id: number | string): Promise<any> {
     this.applyGlobalScopes()
     const row = await this.raw().where('id', id).first()
     if (!row) return null
@@ -190,7 +191,7 @@ export class ModelQueryBuilder<T> extends QueryBuilder {
     return model
   }
 
-  async findOrFail(id: number | string): Promise<T> {
+  async findOrFail(id: number | string): Promise<any> {
     const result = await this.find(id)
     if (!result) throw new ModelNotFoundError(this.state.table)
     return result
@@ -198,7 +199,7 @@ export class ModelQueryBuilder<T> extends QueryBuilder {
 
   // ── Pagination (hydrated) ─────────────────────────────────────────────────
 
-  override async paginate(page = 1, perPage = 15) {
+  override async paginate(page = 1, perPage = 15): Promise<PaginationResult> {
     const total = await this.count()
     const lastPage = Math.max(1, Math.ceil(total / perPage))
     const currentPage = Math.min(page, lastPage)
@@ -381,7 +382,7 @@ export class ModelQueryBuilder<T> extends QueryBuilder {
    * @example
    *   const user = await User.where('email', 'admin@example.com').sole()
    */
-  async sole(): Promise<T> {
+  override async sole(): Promise<any> {
     this.applyGlobalScopes()
     const originalLimit = this.state.limitValue
     this.state.limitValue = 2

package/src/query/Builder.ts

@@ -9,15 +9,15 @@ export type Operator = '=' | '!=' | '<>' | '<' | '>' | '<=' | '>=' | 'like' | 'n
 export interface WhereClause {
   type: 'basic' | 'in' | 'notIn' | 'null' | 'notNull' | 'between' | 'raw' | 'nested' | 'column'
   boolean: 'and' | 'or'
-  column?: string
-  operator?: string
+  column?: string | undefined
+  operator?: string | undefined
   value?: any
-  values?: any[]
-  range?: [any, any]
-  sql?: string
-  bindings?: any[]
-  nested?: WhereClause[]
-  secondColumn?: string
+  values?: any[] | undefined
+  range?: [any, any] | undefined
+  sql?: string | undefined
+  bindings?: any[] | undefined
+  nested?: WhereClause[] | undefined
+  secondColumn?: string | undefined
 }
 
 export interface JoinClause {
@@ -92,11 +92,10 @@ export class QueryBuilder {
     return this
   }
 
-  // ── Where conditions ─────────────────────────────────────────────────────
+  // ── Where conditions ───────────────────────────────────────────────────────
 
   where(column: string | ((q: QueryBuilder) => void), operatorOrValue?: any, value?: any): this {
     if (typeof column === 'function') {
-      const nested: WhereClause[] = []
       const sub = new QueryBuilder(this._connection, this.state.table)
       column(sub)
       this.state.wheres.push({ type: 'nested', boolean: 'and', nested: sub.state.wheres })
@@ -224,7 +223,7 @@ export class QueryBuilder {
     return this.whereRaw(`strftime('%H:%M:%S', ${column}) ${op} ?`, [val])
   }
 
-  // ── Joins ─────────────────────────────────────────────────────────────────
+  // ── Joins ───────────────────────────────────────────────────────────────────
 
   join(table: string, first: string, operator: string, second: string): this {
     this.state.joins.push({ type: 'inner', table, first, operator, second })
@@ -241,7 +240,7 @@ export class QueryBuilder {
     return this
   }
 
-  // ── Ordering / Grouping ───────────────────────────────────────────────────
+  // ── Ordering / Grouping ─────────────────────────────────────────────────────
 
   orderBy(column: string | Expression, direction: 'asc' | 'desc' = 'asc'): this {
     this.state.orders.push({ column, direction })
@@ -267,7 +266,7 @@ export class QueryBuilder {
     return this
   }
 
-  // ── Pagination ────────────────────────────────────────────────────────────
+  // ── Pagination ──────────────────────────────────────────────────────────────
 
   limit(value: number): this {
     this.state.limitValue = value
@@ -282,11 +281,10 @@ export class QueryBuilder {
   take = this.limit
   skip = this.offset
 
-  // ── Execution ─────────────────────────────────────────────────────────────
+  // ── Execution ───────────────────────────────────────────────────────────────
 
   async get(): Promise<Record<string, any>[]> {
-    const { sql, bindings } = this.grammar().compileSelect(this.state)
-    return this._connection.select(sql, bindings)
+    return this._connection.executeSelect(this.state)
   }
 
   async first(): Promise<Record<string, any> | null> {
@@ -315,8 +313,7 @@ export class QueryBuilder {
   }
 
   async exists(): Promise<boolean> {
-    const row = await this.selectRaw('1 as exists_check').limit(1).first()
-    return row !== null
+    return this._connection.executeExists(this.state)
   }
 
   async doesntExist(): Promise<boolean> {
@@ -333,52 +330,43 @@ export class QueryBuilder {
     return results[0]!
   }
 
-  // ── Aggregates ────────────────────────────────────────────────────────────
+  // ── Aggregates ──────────────────────────────────────────────────────────────
 
   async count(column = '*'): Promise<number> {
-    const row = await this.selectRaw(`COUNT(${column}) as aggregate`).first()
-    return Number(row?.['aggregate'] ?? 0)
+    return this._connection.executeAggregate(this.state, 'count', column)
   }
 
   async sum(column: string): Promise<number> {
-    const row = await this.selectRaw(`SUM(${column}) as aggregate`).first()
-    return Number(row?.['aggregate'] ?? 0)
+    return this._connection.executeAggregate(this.state, 'sum', column)
   }
 
   async avg(column: string): Promise<number> {
-    const row = await this.selectRaw(`AVG(${column}) as aggregate`).first()
-    return Number(row?.['aggregate'] ?? 0)
+    return this._connection.executeAggregate(this.state, 'avg', column)
   }
 
   async min(column: string): Promise<any> {
-    const row = await this.selectRaw(`MIN(${column}) as aggregate`).first()
-    return row?.['aggregate']
+    return this._connection.executeAggregate(this.state, 'min', column)
   }
 
   async max(column: string): Promise<any> {
-    const row = await this.selectRaw(`MAX(${column}) as aggregate`).first()
-    return row?.['aggregate']
+    return this._connection.executeAggregate(this.state, 'max', column)
   }
 
-  // ── Writes ────────────────────────────────────────────────────────────────
+  // ── Writes ──────────────────────────────────────────────────────────────────
 
   async insert(data: Record<string, any> | Record<string, any>[]): Promise<void> {
     const rows = Array.isArray(data) ? data : [data]
     for (const row of rows) {
-      const { sql, bindings } = this.grammar().compileInsert(this.state.table, row)
-      await this._connection.statement(sql, bindings)
+      await this._connection.executeInsert(this.state.table, row)
     }
   }
 
-  async insertGetId(data: Record<string, any>): Promise<number> {
-    const { sql, bindings } = this.grammar().compileInsertGetId(this.state.table, data)
-    const id = await this._connection.insertGetId(sql, bindings)
-    return Number(id)
+  async insertGetId(data: Record<string, any>): Promise<number | string> {
+    return this._connection.executeInsertGetId(this.state.table, data)
   }
 
   async update(data: Record<string, any>): Promise<number> {
-    const { sql, bindings } = this.grammar().compileUpdate(this.state.table, this.state, data)
-    return this._connection.statement(sql, bindings)
+    return this._connection.executeUpdate(this.state.table, this.state, data)
   }
 
   async updateOrInsert(
@@ -396,19 +384,19 @@ export class QueryBuilder {
   }
 
   async delete(): Promise<number> {
-    const { sql, bindings } = this.grammar().compileDelete(this.state.table, this.state)
-    return this._connection.statement(sql, bindings)
+    return this._connection.executeDelete(this.state.table, this.state)
   }
 
   async truncate(): Promise<void> {
-    const sql = this.grammar().compileTruncate(this.state.table)
-    await this._connection.statement(sql, [])
+    return this._connection.executeTruncate(this.state.table)
   }
 
-  // ── Pagination ────────────────────────────────────────────────────────────
+  // ── Pagination ──────────────────────────────────────────────────────────────
 
   async paginate(page = 1, perPage = 15): Promise<PaginationResult> {
-    const total = await this.clone().count()
+    const countQuery = this.clone()
+    countQuery.state.orders = []
+    const total = await countQuery.count()
     const lastPage = Math.max(1, Math.ceil(total / perPage))
     const currentPage = Math.min(page, lastPage)
     const data = await this.clone().limit(perPage).offset((currentPage - 1) * perPage).get()
@@ -417,14 +405,20 @@ export class QueryBuilder {
     return { data, total, perPage, currentPage, lastPage, from, to, hasMore: currentPage < lastPage }
   }
 
-  // ── Utilities ─────────────────────────────────────────────────────────────
+  // ── Utilities ───────────────────────────────────────────────────────────────
 
+  /** Returns the SQL for this query. Only works on SQL connections. */
   toSql(): string {
-    return this.grammar().compileSelect(this.state).sql
+    const grammar = this.getGrammar()
+    if (!grammar) throw new Error('toSql() is only available on SQL connections')
+    return grammar.compileSelect(this.state).sql
   }
 
+  /** Returns the bindings for this query. Only works on SQL connections. */
   getBindings(): any[] {
-    return this.grammar().compileSelect(this.state).bindings
+    const grammar = this.getGrammar()
+    if (!grammar) throw new Error('getBindings() is only available on SQL connections')
+    return grammar.compileSelect(this.state).bindings
   }
 
   clone(): QueryBuilder {
@@ -445,10 +439,9 @@ export class QueryBuilder {
     return this.state
   }
 
-  // ── Grammar (driver-specific SQL) ─────────────────────────────────────────
-
-  protected grammar() {
-    return (this._connection as any)._grammar as import('../contracts/Grammar.ts').Grammar
+  /** Returns the Grammar if this is a SQL connection, null otherwise. */
+  protected getGrammar(): import('../contracts/Grammar.ts').Grammar | null {
+    return (this._connection as any)._grammar ?? null
   }
 }
 

package/src/schema/Blueprint.ts

@@ -3,15 +3,15 @@ import { ColumnDefinition } from './ColumnDefinition.ts'
 export interface IndexDefinition {
   type: 'index' | 'unique' | 'primary'
   columns: string[]
-  name?: string
+  name?: string | undefined
 }
 
 export interface ForeignKeyDefinition {
   column: string
   references: string
   on: string
-  onDelete?: string
-  onUpdate?: string
+  onDelete?: string | undefined
+  onUpdate?: string | undefined
 }
 
 export class Blueprint {

package/src/schema/ColumnDefinition.ts

@@ -6,16 +6,16 @@ export class ColumnDefinition {
   private _index = false
   private _unsigned = false
   private _primary = false
-  private _references: { table: string; column: string; onDelete?: string; onUpdate?: string } | null = null
+  private _references: { table: string; column: string; onDelete?: string | undefined; onUpdate?: string | undefined } | null = null
   private _comment: string | null = null
   private _after: string | null = null
 
   constructor(
     public readonly name: string,
     public readonly type: string,
-    public readonly length?: number,
-    public readonly precision?: number,
-    public readonly scale?: number,
+    public readonly length?: number | undefined,
+    public readonly precision?: number | undefined,
+    public readonly scale?: number | undefined,
   ) {}
 
   nullable(): this {
@@ -49,7 +49,7 @@ export class ColumnDefinition {
     return this
   }
 
-  references(column: string): this & { on(table: string): this } {
+  references(column: string): ColumnDefinition & { on(table: string): ColumnDefinition } {
     this._references = { table: '', column }
     const self = this as any
     self.on = (table: string) => {

package/src/schema/SchemaBuilder.ts

@@ -210,9 +210,12 @@ export class SchemaBuilderImpl implements SchemaBuilder {
 
     let def = `${this.quoteCol(col.name)} ${typeSql}`
 
+    const isIntegerType = ['integer', 'bigInteger', 'tinyInteger', 'smallInteger', 'mediumInteger'].includes(col.type)
     if (isAutoIncrement || col.isPrimary()) {
-      if (driver === 'sqlite') {
+      if (driver === 'sqlite' && (isAutoIncrement || isIntegerType)) {
         def += ' PRIMARY KEY AUTOINCREMENT'
+      } else if (driver === 'sqlite') {
+        def += ' PRIMARY KEY'
       } else if (driver === 'postgres') {
         // SERIAL/BIGSERIAL already implies sequence; just mark PRIMARY KEY
         def += ' PRIMARY KEY'
@@ -252,7 +255,7 @@ export class SchemaBuilderImpl implements SchemaBuilder {
     return def
   }
 
-  private compileIndex(table: string, idx: { type: 'index' | 'unique' | 'primary'; columns: string[]; name?: string }): string {
+  private compileIndex(table: string, idx: { type: 'index' | 'unique' | 'primary'; columns: string[]; name?: string | undefined }): string {
     const cols = idx.columns.map((c) => this.quoteCol(c)).join(', ')
     const idxName = idx.name ?? `${table}_${idx.columns.join('_')}_${idx.type}`
 

package/src/types.d.ts

@@ -0,0 +1,21 @@
+// Optional peer dependencies — ambient module declarations for dynamic imports
+declare module 'pg' {
+  const pg: any
+  export default pg
+}
+
+declare module 'mysql2/promise' {
+  const mysql: any
+  export default mysql
+  export function createPool(config: any): any
+}
+
+declare module 'mssql' {
+  const mssql: any
+  export default mssql
+}
+
+declare module 'mongodb' {
+  export const MongoClient: any
+  export const ObjectId: any
+}