bun-query-builder 0.1.24 → 0.1.25

package/dist/src/index.js

@@ -12010,18 +12010,11 @@ function getBunSql() {
     }
     return sql;
   } catch (error) {
-    if (config5.verbose) {
-      console.warn(`[query-builder] Failed to create connection: ${error.message}`);
-    }
-    try {
+    console.error(`[query-builder] Failed to create database connection for dialect '${dialect}': ${error.message}`);
+    if (dialect === "sqlite") {
       return createSQLiteSQL(":memory:");
-    } catch {
-      return {
-        query: () => Promise.resolve([]),
-        execute: () => Promise.resolve([]),
-        close: () => Promise.resolve()
-      };
     }
+    throw error;
   }
 }
 function getOrCreateBunSql(forceNew = false) {
@@ -23273,6 +23266,10 @@ var init_src = __esm(() => {
 
 // src/orm.ts
 import { Database as Database2 } from "bun:sqlite";
+function formatNow() {
+  const iso = new Date().toISOString();
+  return config5.dialect === "mysql" ? iso.slice(0, 19).replace("T", " ") : iso;
+}
 function assertValidIdentifier(name, context) {
   if (typeof name !== "string" || name.length === 0)
     throw new TypeError(`[bun-query-builder] ${context}: identifier must be a non-empty string, got ${typeof name}`);
@@ -23293,19 +23290,130 @@ function getModelFromRegistry(name) {
   }
   return _getModel(name);
 }
+function toPostgresPlaceholders(sql2) {
+  let i2 = 0;
+  return sql2.replace(/\?/g, () => `$${++i2}`);
+}
+function extractChanges(res) {
+  if (res == null)
+    return 0;
+  if (typeof res.affectedRows === "number")
+    return res.affectedRows;
+  if (typeof res.count === "number")
+    return res.count;
+  if (Array.isArray(res))
+    return res.length;
+  return 0;
+}
+function extractInsertId(res) {
+  if (res == null || typeof res !== "object")
+    return null;
+  if ("insertId" in res && res.insertId != null)
+    return res.insertId;
+  if ("lastInsertRowid" in res && res.lastInsertRowid != null)
+    return res.lastInsertRowid;
+  return null;
+}
+
+class SqliteExecutor {
+  sqliteDb;
+  dialect = "sqlite";
+  constructor(sqliteDb) {
+    this.sqliteDb = sqliteDb;
+  }
+  all(sql2, params) {
+    return Promise.resolve(this.sqliteDb.query(sql2).all(...params));
+  }
+  get(sql2, params) {
+    return Promise.resolve(this.sqliteDb.query(sql2).get(...params) ?? undefined);
+  }
+  run(sql2, params) {
+    const r2 = this.sqliteDb.run(sql2, params);
+    return Promise.resolve({ changes: r2.changes, lastInsertId: r2.lastInsertRowid });
+  }
+  insert(sql2, params) {
+    return this.run(sql2, params);
+  }
+}
+
+class DriverExecutor {
+  dialect;
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  conn() {
+    return getOrCreateBunSql();
+  }
+  text(sql2) {
+    return this.dialect === "postgres" ? toPostgresPlaceholders(sql2) : sql2;
+  }
+  async all(sql2, params) {
+    const rows = await this.conn().unsafe(this.text(sql2), params);
+    return Array.isArray(rows) ? rows : [];
+  }
+  async get(sql2, params) {
+    const rows = await this.conn().unsafe(this.text(sql2), params);
+    if (Array.isArray(rows))
+      return rows[0] ?? undefined;
+    return rows ?? undefined;
+  }
+  async run(sql2, params) {
+    const res = await this.conn().unsafe(this.text(sql2), params);
+    return { changes: extractChanges(res), lastInsertId: extractInsertId(res) };
+  }
+  async insert(sql2, params, primaryKey) {
+    if (this.dialect === "postgres") {
+      const rows = await this.conn().unsafe(`${toPostgresPlaceholders(sql2)} RETURNING ${primaryKey}`, params);
+      const row = Array.isArray(rows) ? rows[0] : rows;
+      return { changes: 1, lastInsertId: row ? row[primaryKey] ?? null : null };
+    }
+    const res = await this.conn().unsafe(sql2, params);
+    let id = extractInsertId(res);
+    if (id == null) {
+      const rows = await this.conn().unsafe("SELECT LAST_INSERT_ID() as id", []);
+      const row = Array.isArray(rows) ? rows[0] : rows;
+      id = row?.id ?? null;
+    }
+    return { changes: extractChanges(res) || 1, lastInsertId: id };
+  }
+}
 function configureOrm(options) {
   if (options.database instanceof Database2) {
     globalDb = options.database;
   } else {
     globalDb = new Database2(options.database || ":memory:", { create: true });
   }
-  preparedStatementCache.clear();
+  _executor = null;
+  _executorForDb = null;
 }
-function getDatabase() {
-  if (!globalDb) {
-    globalDb = new Database2(":memory:", { create: true });
+function getExecutor() {
+  if (globalDb) {
+    if (!_executor || _executorForDb !== globalDb) {
+      _executor = new SqliteExecutor(globalDb);
+      _executorForDb = globalDb;
+      _executorDialect = "sqlite";
+      _executorDatabase = null;
+    }
+    return _executor;
   }
-  return globalDb;
+  const dialect = config5.dialect;
+  const database = config5.database?.database ?? null;
+  if (_executor && _executorForDb === null && _executorDialect === dialect && _executorDatabase === database)
+    return _executor;
+  _executorForDb = null;
+  _executorDialect = dialect;
+  _executorDatabase = database;
+  if (dialect === "sqlite")
+    _executor = new SqliteExecutor(new Database2(database || ":memory:", { create: true }));
+  else
+    _executor = new DriverExecutor(dialect);
+  return _executor;
+}
+function getDatabase() {
+  const exec = getExecutor();
+  if (exec.sqliteDb)
+    return exec.sqliteDb;
+  throw new Error(`[bun-query-builder] getDatabase() is only available for the sqlite dialect; ` + `the configured dialect is '${exec.dialect}'. Use the async model API instead.`);
 }
 function collectBelongsToManyKeys(definition) {
   const keys = new Set;
@@ -23459,8 +23567,8 @@ class ModelInstance {
     Object.assign(this._attributes, data);
     return this;
   }
-  save() {
-    const db = getDatabase();
+  async save() {
+    const exec = getExecutor();
     const pk = this._definition.primaryKey || "id";
     const hooks = this._definition.hooks;
     const setters = this._definition.set || {};
@@ -23470,20 +23578,20 @@ class ModelInstance {
       }
     }
     if (this._attributes[pk]) {
-      hooks?.beforeUpdate?.(this, this.getChanges());
+      await hooks?.beforeUpdate?.(this, this.getChanges());
       const changes = this.getChanges();
       const changeKeys = Object.keys(changes);
       if (changeKeys.length > 0) {
         const sets = changeKeys.map((k2) => `${k2} = ?`).join(", ");
         const values = [...Object.values(changes), this._attributes[pk]];
         if (this._definition.traits?.useTimestamps) {
-          const now = new Date().toISOString();
-          db.run(`UPDATE ${this._definition.table} SET ${sets}, updated_at = ? WHERE ${pk} = ?`, [...Object.values(changes), now, this._attributes[pk]]);
+          const now = formatNow();
+          await exec.run(`UPDATE ${this._definition.table} SET ${sets}, updated_at = ? WHERE ${pk} = ?`, [...Object.values(changes), now, this._attributes[pk]]);
         } else {
-          db.run(`UPDATE ${this._definition.table} SET ${sets} WHERE ${pk} = ?`, values);
+          await exec.run(`UPDATE ${this._definition.table} SET ${sets} WHERE ${pk} = ?`, values);
         }
       }
-      hooks?.afterUpdate?.(this);
+      await hooks?.afterUpdate?.(this);
     } else {
       const attrs = this._definition.attributes;
       const data = {};
@@ -23493,65 +23601,66 @@ class ModelInstance {
         }
       }
       if (this._definition.traits?.useTimestamps) {
-        const now = new Date().toISOString();
+        const now = formatNow();
         data.created_at = now;
         data.updated_at = now;
       }
       if (this._definition.traits?.useUuid && !data.uuid) {
         data.uuid = crypto.randomUUID();
       }
-      hooks?.beforeCreate?.(data);
+      await hooks?.beforeCreate?.(data);
       const columns = Object.keys(data);
       const placeholders = columns.map(() => "?").join(", ");
-      const result = db.run(`INSERT INTO ${this._definition.table} (${columns.join(", ")}) VALUES (${placeholders})`, Object.values(data));
+      const result = await exec.insert(`INSERT INTO ${this._definition.table} (${columns.join(", ")}) VALUES (${placeholders})`, Object.values(data), pk);
       for (const [key, value] of Object.entries(data)) {
         this._attributes[key] = value;
       }
-      this._attributes[pk] = result.lastInsertRowid;
-      hooks?.afterCreate?.(this);
+      if (result.lastInsertId != null)
+        this._attributes[pk] = result.lastInsertId;
+      await hooks?.afterCreate?.(this);
     }
     this._original = { ...this._attributes };
     this._hasSaved = true;
     return this;
   }
-  update(data) {
+  async update(data) {
     this.fill(data);
     return this.save();
   }
-  fresh() {
-    const db = getDatabase();
+  async fresh() {
+    const exec = getExecutor();
     const pk = this._definition.primaryKey || "id";
     const id = this._attributes[pk];
     if (id == null)
       return null;
-    const row = db.query(`SELECT * FROM ${this._definition.table} WHERE ${pk} = ?`).get(id);
+    const row = await exec.get(`SELECT * FROM ${this._definition.table} WHERE ${pk} = ?`, [id]);
     if (!row)
       return null;
     return new ModelInstance(this._definition, row);
   }
-  delete() {
-    const db = getDatabase();
+  async delete() {
+    const exec = getExecutor();
     const pk = this._definition.primaryKey || "id";
     const pkValue = this._attributes[pk];
     const hooks = this._definition.hooks;
     if (!pkValue)
       throw new Error("Cannot delete a model without a primary key");
-    hooks?.beforeDelete?.(this);
+    await hooks?.beforeDelete?.(this);
     if (this._definition.traits?.useSoftDeletes) {
-      db.run(`UPDATE ${this._definition.table} SET deleted_at = ? WHERE ${pk} = ?`, [new Date().toISOString(), pkValue]);
+      await exec.run(`UPDATE ${this._definition.table} SET deleted_at = ? WHERE ${pk} = ?`, [formatNow(), pkValue]);
     } else {
-      db.run(`DELETE FROM ${this._definition.table} WHERE ${pk} = ?`, [pkValue]);
+      await exec.run(`DELETE FROM ${this._definition.table} WHERE ${pk} = ?`, [pkValue]);
     }
-    hooks?.afterDelete?.(this);
+    await hooks?.afterDelete?.(this);
     return true;
   }
-  refresh() {
-    const db = getDatabase();
+  async refresh() {
+    const exec = getExecutor();
     const pk = this._definition.primaryKey || "id";
     const pkValue = this._attributes[pk];
     if (!pkValue)
       throw new Error("Cannot refresh a model without a primary key");
-    const row = db.query(`SELECT * FROM ${this._definition.table} WHERE ${pk} = ?`).get(pkValue);
+    const row = await exec.get(`SELECT * FROM ${this._definition.table} WHERE ${pk} = ?`, [pkValue]);
     if (!row)
       return null;
     this._attributes = row;
@@ -23896,34 +24005,35 @@ class BelongsToManyRelationBuilder {
       return inst;
     });
   }
-  get() {
-    const db = getDatabase();
+  async get() {
+    const exec = getExecutor();
     const { sql: sql2, params } = this.buildSelect();
-    const rows = db.query(sql2).all(...params);
+    const rows = await exec.all(sql2, params);
     return this.hydrateRows(rows);
   }
-  first() {
+  async first() {
     this._limit = 1;
-    return this.get()[0];
+    return (await this.get())[0];
   }
-  count() {
-    const db = getDatabase();
+  async count() {
+    const exec = getExecutor();
     let sql2 = `SELECT COUNT(*) as count FROM ${this.pivotTable} WHERE ${this.fkParent} = ?`;
     const params = [this.parentId];
     for (const w of this._pivotWheres) {
       sql2 += ` AND ${w.sql}`;
       params.push(...w.params);
     }
-    return db.query(sql2).get(...params).count;
+    const row = await exec.get(sql2, params);
+    return Number(row?.count ?? 0);
   }
-  exists() {
-    return this.count() > 0;
+  async exists() {
+    return await this.count() > 0;
   }
   now() {
-    return new Date().toISOString();
+    return formatNow();
   }
-  attach(idOrIds, extras = {}) {
-    const db = getDatabase();
+  async attach(idOrIds, extras = {}) {
+    const exec = getExecutor();
     const ids = Array.isArray(idOrIds) ? idOrIds : [idOrIds];
     if (ids.length === 0)
       return 0;
@@ -23945,13 +24055,13 @@ class BelongsToManyRelationBuilder {
       const placeholders = cols.map(() => "?").join(", ");
       const sql2 = `INSERT INTO ${this.pivotTable} (${cols.join(", ")}) VALUES (${placeholders})`;
       const params = cols.map((c2) => row[c2]);
-      db.run(sql2, params);
+      await exec.run(sql2, params);
       inserted++;
     }
     return inserted;
   }
-  detach(idOrIds) {
-    const db = getDatabase();
+  async detach(idOrIds) {
+    const exec = getExecutor();
     let sql2 = `DELETE FROM ${this.pivotTable} WHERE ${this.fkParent} = ?`;
     const params = [this.parentId];
     if (idOrIds !== undefined && idOrIds !== null) {
@@ -23962,10 +24072,10 @@ class BelongsToManyRelationBuilder {
       sql2 += ` AND ${this.fkRelated} IN (${placeholders})`;
       params.push(...ids);
     }
-    return db.run(sql2, params).changes;
+    return (await exec.run(sql2, params)).changes;
   }
-  updateExistingPivot(relatedId, extras) {
-    const db = getDatabase();
+  async updateExistingPivot(relatedId, extras) {
+    const exec = getExecutor();
     const updates = { ...extras };
     if (this._resolved.pivotTimestamps && updates.updated_at === undefined) {
       updates.updated_at = this.now();
@@ -23976,10 +24086,10 @@ class BelongsToManyRelationBuilder {
     const setClause = cols.map((c2) => `${c2} = ?`).join(", ");
     const sql2 = `UPDATE ${this.pivotTable} SET ${setClause} WHERE ${this.fkParent} = ? AND ${this.fkRelated} = ?`;
     const params = [...cols.map((c2) => updates[c2]), this.parentId, relatedId];
-    return db.run(sql2, params).changes;
+    return (await exec.run(sql2, params)).changes;
   }
-  sync(items) {
-    const db = getDatabase();
+  async sync(items) {
+    const exec = getExecutor();
     const desired = new Map;
     for (const item of items) {
       if (item != null && typeof item === "object" && "id" in item) {
@@ -23989,41 +24099,41 @@ class BelongsToManyRelationBuilder {
         desired.set(item, {});
       }
     }
-    const current = db.query(`SELECT * FROM ${this.pivotTable} WHERE ${this.fkParent} = ?`).all(this.parentId);
+    const current = await exec.all(`SELECT * FROM ${this.pivotTable} WHERE ${this.fkParent} = ?`, [this.parentId]);
     const currentIds = new Set(current.map((r2) => r2[this.fkRelated]));
     const attached = [];
     const detached = [];
     const updated = [];
     const toDetach = [...currentIds].filter((id) => !desired.has(id));
     if (toDetach.length > 0) {
-      this.detach(toDetach);
+      await this.detach(toDetach);
       detached.push(...toDetach);
     }
     for (const [id, extras] of desired) {
       if (!currentIds.has(id)) {
-        this.attach(id, extras);
+        await this.attach(id, extras);
         attached.push(id);
       } else if (Object.keys(extras).length > 0) {
-        this.updateExistingPivot(id, extras);
+        await this.updateExistingPivot(id, extras);
         updated.push(id);
       }
     }
     return { attached, detached, updated };
   }
-  toggle(idOrIds) {
-    const db = getDatabase();
+  async toggle(idOrIds) {
+    const exec = getExecutor();
     const ids = Array.isArray(idOrIds) ? idOrIds : [idOrIds];
     if (ids.length === 0)
       return { attached: [], detached: [] };
     const placeholders = ids.map(() => "?").join(", ");
-    const present = db.query(`SELECT ${this.fkRelated} FROM ${this.pivotTable} WHERE ${this.fkParent} = ? AND ${this.fkRelated} IN (${placeholders})`).all(this.parentId, ...ids);
+    const present = await exec.all(`SELECT ${this.fkRelated} FROM ${this.pivotTable} WHERE ${this.fkParent} = ? AND ${this.fkRelated} IN (${placeholders})`, [this.parentId, ...ids]);
     const presentIds = new Set(present.map((r2) => r2[this.fkRelated]));
     const toAttach = ids.filter((id) => !presentIds.has(id));
     const toDetach = ids.filter((id) => presentIds.has(id));
     if (toAttach.length > 0)
-      this.attach(toAttach);
+      await this.attach(toAttach);
     if (toDetach.length > 0)
-      this.detach(toDetach);
+      await this.detach(toDetach);
     return { attached: toAttach, detached: toDetach };
   }
 }
@@ -24234,10 +24344,10 @@ class ModelQueryBuilder {
   toSql() {
     return this.buildQuery();
   }
-  eagerLoadRelations(instances) {
+  async eagerLoadRelations(instances) {
     if (instances.length === 0 || this._withRelations.length === 0)
       return;
-    const db = getDatabase();
+    const exec = getExecutor();
     const pk = this._definition.primaryKey || "id";
     for (const relationName of this._withRelations) {
       const cacheKey = `${this._definition.name}:${relationName}`;
@@ -24253,7 +24363,7 @@ class ModelQueryBuilder {
         if (parentIds.length === 0)
           continue;
         const placeholders = parentIds.map(() => "?").join(", ");
-        const rows = db.query(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.foreignKey} IN (${placeholders})`).all(...parentIds);
+        const rows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.foreignKey} IN (${placeholders})`, parentIds);
         const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
         const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
         if (rel.type === "hasMany") {
@@ -24285,7 +24395,7 @@ class ModelQueryBuilder {
         if (uniqueFkValues.length === 0)
           continue;
         const placeholders = uniqueFkValues.map(() => "?").join(", ");
-        const rows = db.query(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.localKey} IN (${placeholders})`).all(...uniqueFkValues);
+        const rows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.localKey} IN (${placeholders})`, uniqueFkValues);
         const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
         const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
         const byPk = new Map;
@@ -24305,7 +24415,7 @@ class ModelQueryBuilder {
         if (!rel.pivotTable || !rel.pivotFkParent || !rel.pivotFkRelated)
           continue;
         const pivotPlaceholders = parentIds.map(() => "?").join(", ");
-        const pivotRows = db.query(`SELECT * FROM ${rel.pivotTable} WHERE ${rel.pivotFkParent} IN (${pivotPlaceholders})`).all(...parentIds);
+        const pivotRows = await exec.all(`SELECT * FROM ${rel.pivotTable} WHERE ${rel.pivotFkParent} IN (${pivotPlaceholders})`, parentIds);
         if (pivotRows.length === 0) {
           for (const instance of instances)
             instance.setRelation(relationName, []);
@@ -24318,7 +24428,7 @@ class ModelQueryBuilder {
         let relatedRows = [];
         if (relatedIds.length > 0) {
           const relPlaceholders = relatedIds.map(() => "?").join(", ");
-          relatedRows = db.query(`SELECT * FROM ${rel.relatedTable} WHERE ${relatedPk} IN (${relPlaceholders})`).all(...relatedIds);
+          relatedRows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${relatedPk} IN (${relPlaceholders})`, relatedIds);
         }
         const relatedByPk = new Map;
         for (const r2 of relatedRows)
@@ -24352,75 +24462,76 @@ class ModelQueryBuilder {
       }
     }
   }
-  get() {
-    const db = getDatabase();
+  async get() {
+    const exec = getExecutor();
     const { sql: sql2, params } = this.buildQuery();
-    const rows = db.query(sql2).all(...params);
+    const rows = await exec.all(sql2, params);
     const instances = rows.map((row) => new ModelInstance(this._definition, row));
     if (this._withRelations.length > 0) {
-      this.eagerLoadRelations(instances);
+      await this.eagerLoadRelations(instances);
     }
     return instances;
   }
-  first() {
+  async first() {
     this._limit = 1;
-    return this.get()[0];
+    return (await this.get())[0];
   }
-  firstOrFail() {
-    const result = this.first();
+  async firstOrFail() {
+    const result = await this.first();
     if (!result)
       throw new Error(`No ${this._definition.name} found`);
     return result;
   }
-  last() {
+  async last() {
     const pk = this._definition.primaryKey || "id";
     this._orderBy = [{ column: pk, direction: "desc" }];
     this._limit = 1;
-    return this.get()[0];
+    return (await this.get())[0];
   }
-  count() {
-    const db = getDatabase();
+  async count() {
+    const exec = getExecutor();
     const params = [];
     let sql2 = `SELECT COUNT(*) as count FROM ${this._definition.table}`;
     if (this._wheres.length > 0) {
       sql2 += ` WHERE ${this.buildWhereClauses(params)}`;
     }
-    return db.query(sql2).get(...params).count;
+    const row = await exec.get(sql2, params);
+    return Number(row?.count ?? 0);
   }
-  exists() {
-    return this.count() > 0;
+  async exists() {
+    return await this.count() > 0;
   }
-  doesntExist() {
-    return this.count() === 0;
+  async doesntExist() {
+    return await this.count() === 0;
   }
-  sole() {
+  async sole() {
     this._limit = 2;
-    const results = this.get();
+    const results = await this.get();
     if (results.length === 0)
       throw new Error(`No ${this._definition.name} found`);
     if (results.length > 1)
       throw new Error(`Expected one ${this._definition.name}, found multiple`);
     return results[0];
   }
-  increment(column, amount = 1) {
+  async increment(column, amount = 1) {
     assertValidIdentifier(column, "increment(column)");
-    const db = getDatabase();
+    const exec = getExecutor();
     const params = [amount];
     let sql2 = `UPDATE ${this._definition.table} SET ${column} = ${column} + ?`;
     if (this._definition.traits?.useTimestamps) {
       sql2 += `, updated_at = ?`;
-      params.push(new Date().toISOString());
+      params.push(formatNow());
     }
     if (this._wheres.length > 0) {
       const clauses = this.buildWhereClauses(params);
       sql2 += ` WHERE ${clauses}`;
     }
-    return db.run(sql2, params).changes;
+    return (await exec.run(sql2, params)).changes;
   }
   decrement(column, amount = 1) {
     return this.increment(column, -amount);
   }
-  chunk(size, callback) {
+  async chunk(size, callback) {
     let page = 0;
     while (true) {
       const builder = new ModelQueryBuilder(this._definition);
@@ -24430,10 +24541,10 @@ class ModelQueryBuilder {
       builder._withRelations = [...this._withRelations];
       builder._limit = size;
       builder._offset = page * size;
-      const results = builder.get();
+      const results = await builder.get();
       if (results.length === 0)
         break;
-      const result = callback(results);
+      const result = await callback(results);
       if (result === false)
         break;
       if (results.length < size)
@@ -24441,12 +24552,12 @@ class ModelQueryBuilder {
       page++;
     }
   }
-  paginate(page = 1, perPage = 15) {
-    const total = this.count();
+  async paginate(page = 1, perPage = 15) {
+    const total = await this.count();
     const lastPage = Math.ceil(total / perPage);
     this._limit = perPage;
     this._offset = (page - 1) * perPage;
-    const data = this.get();
+    const data = await this.get();
     return {
       data,
       total,
@@ -24459,9 +24570,9 @@ class ModelQueryBuilder {
       to: data.length > 0 ? (page - 1) * perPage + data.length : null
     };
   }
-  pluck(column) {
+  async pluck(column) {
     assertValidIdentifier(column, "pluck(column)");
-    const db = getDatabase();
+    const exec = getExecutor();
     const params = [];
     let sql2 = `SELECT ${column} FROM ${this._definition.table}`;
     if (this._wheres.length > 0) {
@@ -24474,19 +24585,19 @@ class ModelQueryBuilder {
       sql2 += ` LIMIT ${this._limit}`;
     if (this._offset !== undefined)
       sql2 += ` OFFSET ${this._offset}`;
-    const rows = db.query(sql2).all(...params);
+    const rows = await exec.all(sql2, params);
     return rows.map((r2) => r2[column]);
   }
-  aggregate(fn, column) {
+  async aggregate(fn, column) {
     assertValidIdentifier(column, `${fn}(column)`);
-    const db = getDatabase();
+    const exec = getExecutor();
     const params = [];
     let sql2 = `SELECT ${fn}(${column}) as v FROM ${this._definition.table}`;
     if (this._wheres.length > 0) {
       sql2 += ` WHERE ${this.buildWhereClauses(params)}`;
     }
-    const row = db.query(sql2).get(...params);
-    return row?.v ?? null;
+    const row = await exec.get(sql2, params);
+    return row?.v == null ? null : Number(row.v);
   }
   max(column) {
     return this.aggregate("MAX", column);
@@ -24494,34 +24605,34 @@ class ModelQueryBuilder {
   min(column) {
     return this.aggregate("MIN", column);
   }
-  avg(column) {
-    return this.aggregate("AVG", column) || 0;
+  async avg(column) {
+    return await this.aggregate("AVG", column) || 0;
   }
-  sum(column) {
-    return this.aggregate("SUM", column) || 0;
+  async sum(column) {
+    return await this.aggregate("SUM", column) || 0;
   }
-  delete() {
-    const db = getDatabase();
+  async delete() {
+    const exec = getExecutor();
     const params = [];
     let sql2 = `DELETE FROM ${this._definition.table}`;
     if (this._wheres.length > 0) {
       sql2 += ` WHERE ${this.buildWhereClauses(params)}`;
     }
-    return db.run(sql2, params).changes;
+    return (await exec.run(sql2, params)).changes;
   }
-  update(data) {
-    const db = getDatabase();
+  async update(data) {
+    const exec = getExecutor();
     const entries = Object.entries(data);
     const sets = entries.map(([k2]) => `${k2} = ?`).join(", ");
     const params = entries.map(([, v2]) => v2);
     if (this._definition.traits?.useTimestamps) {
-      params.push(new Date().toISOString());
+      params.push(formatNow());
     }
     let sql2 = `UPDATE ${this._definition.table} SET ${sets}${this._definition.traits?.useTimestamps ? ", updated_at = ?" : ""}`;
     if (this._wheres.length > 0) {
       sql2 += ` WHERE ${this.buildWhereClauses(params)}`;
     }
-    return db.run(sql2, params).changes;
+    return (await exec.run(sql2, params)).changes;
   }
 }
 function createModel(definition) {
@@ -24563,28 +24674,22 @@ function createModel(definition) {
     limit: (count) => new ModelQueryBuilder(definition).limit(count),
     take: (count) => new ModelQueryBuilder(definition).take(count),
     skip: (count) => new ModelQueryBuilder(definition).skip(count),
-    find(id) {
-      const db = getDatabase();
+    async find(id) {
+      const exec = getExecutor();
       const pk = definition.primaryKey || "id";
-      const sql2 = `SELECT * FROM ${definition.table} WHERE ${pk} = ?`;
-      let stmt = preparedStatementCache.get(sql2);
-      if (!stmt) {
-        stmt = db.prepare(sql2);
-        preparedStatementCache.set(sql2, stmt);
-      }
-      const row = stmt.get(id);
+      const row = await exec.get(`SELECT * FROM ${definition.table} WHERE ${pk} = ?`, [id]);
       return row ? new ModelInstance(definition, row) : undefined;
     },
-    findOrFail(id) {
-      const result = model.find(id);
+    async findOrFail(id) {
+      const result = await model.find(id);
       if (!result)
         throw new Error(`${definition.name} with id ${id} not found`);
       return result;
     },
-    findMany(ids) {
-      const db = getDatabase();
+    async findMany(ids) {
+      const exec = getExecutor();
       const pk = definition.primaryKey || "id";
-      const rows = db.query(`SELECT * FROM ${definition.table} WHERE ${pk} IN (${ids.map(() => "?").join(", ")})`).all(...ids);
+      const rows = await exec.all(`SELECT * FROM ${definition.table} WHERE ${pk} IN (${ids.map(() => "?").join(", ")})`, ids);
       return rows.map((row) => new ModelInstance(definition, row));
     },
     all: () => new ModelQueryBuilder(definition).get(),
@@ -24601,44 +24706,47 @@ function createModel(definition) {
     whereNotBetween(column, range) {
       return new ModelQueryBuilder(definition).whereNotBetween(column, range);
     },
-    create(data) {
+    async create(data) {
       const instance = new ModelInstance(definition, data);
-      instance.save();
+      await instance.save();
       return instance;
     },
-    createMany(items) {
-      return items.map((data) => this.create(data));
+    async createMany(items) {
+      const out = [];
+      for (const data of items)
+        out.push(await this.create(data));
+      return out;
     },
-    updateOrCreate(search, data) {
+    async updateOrCreate(search, data) {
       let query = new ModelQueryBuilder(definition);
       for (const [key, value] of Object.entries(search)) {
         query = query.where(key, value);
       }
-      const existing = query.first();
+      const existing = await query.first();
       if (existing) {
-        existing.update(data);
+        await existing.update(data);
         return existing;
       }
       return this.create({ ...search, ...data });
     },
-    firstOrCreate(search, data) {
+    async firstOrCreate(search, data) {
       let query = new ModelQueryBuilder(definition);
       for (const [key, value] of Object.entries(search)) {
         query = query.where(key, value);
       }
-      const existing = query.first();
+      const existing = await query.first();
       return existing || this.create({ ...search, ...data });
     },
-    destroy(id) {
-      const db = getDatabase();
+    async destroy(id) {
+      const exec = getExecutor();
       const pk = definition.primaryKey || "id";
-      return db.run(`DELETE FROM ${definition.table} WHERE ${pk} = ?`, [id]).changes > 0;
+      return (await exec.run(`DELETE FROM ${definition.table} WHERE ${pk} = ?`, [id])).changes > 0;
     },
     remove(id) {
       return this.destroy(id);
     },
-    truncate() {
-      getDatabase().run(`DELETE FROM ${definition.table}`);
+    async truncate() {
+      await getExecutor().run(`DELETE FROM ${definition.table}`, []);
     },
     getDefinition: () => definition,
     getTable: () => definition.table,
@@ -24668,8 +24776,8 @@ function createModel(definition) {
     }
   });
 }
-function createTableFromModel(definition) {
-  const db = getDatabase();
+async function createTableFromModel(definition) {
+  const exec = getExecutor();
   const pk = definition.primaryKey || "id";
   const columns = [];
   columns.push(definition.autoIncrement !== false ? `${pk} INTEGER PRIMARY KEY AUTOINCREMENT` : `${pk} INTEGER PRIMARY KEY`);
@@ -24702,7 +24810,7 @@ function createTableFromModel(definition) {
   if (definition.traits?.useSoftDeletes) {
     columns.push("deleted_at TEXT");
   }
-  db.run(`CREATE TABLE IF NOT EXISTS ${definition.table} (${columns.join(", ")})`);
+  await exec.run(`CREATE TABLE IF NOT EXISTS ${definition.table} (${columns.join(", ")})`, []);
 }
 function createFakerCompatLayer(underlying) {
   return new Proxy(underlying, {
@@ -24726,7 +24834,7 @@ function createFakerCompatLayer(underlying) {
   });
 }
 async function seedModel(definition, count, faker) {
-  const db = getDatabase();
+  const exec = getExecutor();
   const seeder = definition.traits?.useSeeder;
   const seedCount = count ?? (typeof seeder === "object" && seeder ? seeder.count : 10);
   if (!faker) {
@@ -24745,23 +24853,24 @@ async function seedModel(definition, count, faker) {
         data[name] = attr.factory(faker);
     }
     if (definition.traits?.useTimestamps) {
-      const now = new Date().toISOString();
+      const now = formatNow();
       data.created_at = now;
       data.updated_at = now;
     }
     if (definition.traits?.useUuid)
       data.uuid = crypto.randomUUID();
     const columns = Object.keys(data);
-    db.run(`INSERT INTO ${definition.table} (${columns.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`, Object.values(data));
+    await exec.run(`INSERT INTO ${definition.table} (${columns.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`, Object.values(data));
   }
 }
-var SAFE_SQL_IDENTIFIER, _getModel = null, globalDb = null, snakeCaseCache, tableNameCache, relationCache, preparedStatementCache;
+var SAFE_SQL_IDENTIFIER, _getModel = null, globalDb = null, _executor = null, _executorForDb = null, _executorDialect = null, _executorDatabase = null, snakeCaseCache, tableNameCache, relationCache;
 var init_orm = __esm(() => {
+  init_config();
+  init_db();
   SAFE_SQL_IDENTIFIER = /^[A-Z_][A-Z0-9_]*$/i;
   snakeCaseCache = new Map;
   tableNameCache = new Map;
   relationCache = new Map;
-  preparedStatementCache = new Map;
 });
 
 // src/model.ts