bun-query-builder 0.2.25 → 0.2.26

package/dist/bin/cli.js

@@ -11645,6 +11645,29 @@ import process19 from "process";
 function isMysqlLike(dialect = config5.dialect) {
   return dialect === "mysql" || dialect === "singlestore" || dialect === "vitess";
 }
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function mergeObject(target, source, seen = new Set) {
+  const out = { ...target };
+  seen.add(source);
+  for (const key of Object.keys(source)) {
+    if (FORBIDDEN_MERGE_KEYS.has(key))
+      continue;
+    const next = source[key];
+    if (isPlainObject(next) && !seen.has(next)) {
+      const prev = out[key];
+      out[key] = mergeObject(isPlainObject(prev) ? prev : {}, next, seen);
+    } else {
+      out[key] = next;
+    }
+  }
+  seen.delete(source);
+  return out;
+}
 function resolveDialect(explicit) {
   if (explicit)
     return explicit;
@@ -11688,21 +11711,12 @@ async function getConfig() {
   return config5;
 }
 function applyConfig(userConfig) {
-  Object.assign(config5, userConfig);
-  if (userConfig.database) {
-    config5.database = { ...config5.database, ...userConfig.database };
-  }
-  if (userConfig.timestamps) {
-    config5.timestamps = { ...config5.timestamps, ...userConfig.timestamps };
-  }
-  if (userConfig.pagination) {
-    config5.pagination = { ...config5.pagination, ...userConfig.pagination };
-  }
-  if (userConfig.softDeletes) {
-    config5.softDeletes = { ...config5.softDeletes, ...userConfig.softDeletes };
-  }
-  if (userConfig.vitess) {
-    config5.vitess = { ...config5.vitess, ...userConfig.vitess };
+  const merged = mergeObject(config5, userConfig);
+  const target = config5;
+  for (const key of Object.keys(merged)) {
+    if (FORBIDDEN_MERGE_KEYS.has(key))
+      continue;
+    target[key] = merged[key];
   }
 }
 function setConfig(userConfig) {
@@ -11710,7 +11724,7 @@ function setConfig(userConfig) {
     const key = `${_lastConfiguredDialect}->${userConfig.dialect}`;
     if (!_warnedDialectConflicts.has(key)) {
       _warnedDialectConflicts.add(key);
-      console.warn(`[query-builder] setConfig({ dialect: '${userConfig.dialect}' }) overrides a previous ` + `setConfig({ dialect: '${_lastConfiguredDialect}' }). ` + `Config is process-wide; in-flight queries from the previous configuration may break. ` + `Run conflicting connections in separate processes \u2014 see stacksjs/stacks#1862 #18.`);
+      console.warn(`[query-builder] Configuring dialect '${userConfig.dialect}' overrides the previously ` + `configured dialect '${_lastConfiguredDialect}'. ` + `Config is process-wide (setConfig, db.configure and query-builder.config.ts all write it); ` + `in-flight queries from the previous configuration may break. ` + `Run conflicting connections in separate processes \u2014 see stacksjs/stacks#1862 #18.`);
     }
   }
   if (userConfig.dialect)
@@ -11719,7 +11733,10 @@ function setConfig(userConfig) {
     configState.explicit.add(key);
   applyConfig(userConfig);
 }
-var defaultConfig4, CONFIG_SINGLETON_KEY, config5, CONFIG_STATE_KEY, configState, _lastConfiguredDialect = null, _warnedDialectConflicts;
+function defineConfig(userConfig) {
+  return userConfig;
+}
+var defaultConfig4, FORBIDDEN_MERGE_KEYS, CONFIG_SINGLETON_KEY, config5, CONFIG_STATE_KEY, configState, _lastConfiguredDialect = null, _warnedDialectConflicts;
 var init_config = __esm(() => {
   init_dist();
   defaultConfig4 = {
@@ -11784,8 +11801,9 @@ var init_config = __esm(() => {
       defaultFilter: true
     }
   };
+  FORBIDDEN_MERGE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
   CONFIG_SINGLETON_KEY = Symbol.for("bun-query-builder.config");
-  config5 = globalThis[CONFIG_SINGLETON_KEY] ??= { ...defaultConfig4 };
+  config5 = globalThis[CONFIG_SINGLETON_KEY] ??= mergeObject({}, defaultConfig4);
   CONFIG_STATE_KEY = Symbol.for("bun-query-builder.config-state");
   configState = globalThis[CONFIG_STATE_KEY] ??= { explicit: new Set, fileLoaded: false };
   _warnedDialectConflicts = new Set;
@@ -12828,6 +12846,20 @@ function createQueryBuilder(state) {
   const _sql = state?.sql ?? getOrCreateBunSql();
   const meta = state?.meta;
   const schema = state?.schema;
+  function advisoryLockKey(key) {
+    if (typeof key === "number")
+      return key;
+    const s = String(key);
+    let hash = 7;
+    for (let i = 0;i < s.length; i++)
+      hash = hash * 31 + s.charCodeAt(i) | 0;
+    return Math.abs(hash);
+  }
+  function activeHooks() {
+    if (!state?.hooks)
+      return config5.hooks;
+    return { ...config5.hooks, ...state.hooks };
+  }
   const dynamicWhereColumnCache = new Map;
   function applyCondition(expr) {
     if (Array.isArray(expr)) {
@@ -12919,7 +12951,7 @@ function createQueryBuilder(state) {
     return;
   }
   function runWithHooks(q, kind, opts) {
-    const hooks = config5.hooks;
+    const hooks = activeHooks();
     const slowMs = hooks?.slowQueryThresholdMs;
     const slowEnabled = slowMs != null && slowMs >= 0;
     const hasSlowQuery = Boolean(hooks?.onSlowQuery || slowEnabled);
@@ -15001,7 +15033,7 @@ function createQueryBuilder(state) {
         return text;
       },
       async get() {
-        const hooks = config5.hooks;
+        const hooks = activeHooks();
         const hasQueryHooks = hooks && (hooks.onQueryStart || hooks.onQueryEnd || hooks.onQueryError || hooks.startSpan || hasSlowQueryHook(hooks));
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !hasQueryHooks) {
           const prepareFn = _sql._prepareStatement;
@@ -15054,7 +15086,7 @@ function createQueryBuilder(state) {
         return result;
       },
       async first() {
-        const fHooks = config5.hooks;
+        const fHooks = activeHooks();
         const fHasQueryHooks = fHooks && (fHooks.onQueryStart || fHooks.onQueryEnd || fHooks.onQueryError || fHooks.startSpan || hasSlowQueryHook(fHooks));
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !fHasQueryHooks) {
           const prepareFn = _sql._prepareStatement;
@@ -15136,7 +15168,7 @@ function createQueryBuilder(state) {
         } else {
           countText = `SELECT COUNT(*) as c FROM ${table}`;
         }
-        const cHooks = config5.hooks;
+        const cHooks = activeHooks();
         const cHasHooks = cHooks && (cHooks.onQueryStart || cHooks.onQueryEnd || cHooks.onQueryError || cHooks.startSpan || hasSlowQueryHook(cHooks));
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !cHasHooks) {
           const prepareFn = _sql._prepareStatement;
@@ -15154,7 +15186,7 @@ function createQueryBuilder(state) {
       async avg(column) {
         const fromIdx = text.indexOf(" FROM ");
         const avgText = fromIdx !== -1 ? `SELECT AVG(${column}) as a${text.substring(fromIdx)}` : `SELECT AVG(${column}) as a FROM ${table}`;
-        const aHooks = config5.hooks;
+        const aHooks = activeHooks();
         const aHasHooks = aHooks && (aHooks.onQueryStart || aHooks.onQueryEnd || aHooks.onQueryError || aHooks.startSpan || hasSlowQueryHook(aHooks));
         if (!config5.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !aHasHooks) {
           const prepareFn = _sql._prepareStatement;
@@ -15291,7 +15323,7 @@ function createQueryBuilder(state) {
   }
   return {
     configure(opts) {
-      Object.assign(config5, opts);
+      setConfig(opts);
       return this;
     },
     id(name) {
@@ -15668,7 +15700,7 @@ function createQueryBuilder(state) {
           return makeExecutableQuery(built, sqlText);
         },
         execute() {
-          const hooks = config5.hooks;
+          const hooks = activeHooks();
           const hasHooks = hooks && (hooks.onQueryStart || hooks.onQueryEnd || hooks.onQueryError || hooks.startSpan || hooks.beforeCreate || hooks.afterCreate || hasSlowQueryHook(hooks));
           if (!hasHooks) {
             const prepareFn = _sql._prepareStatement;
@@ -16022,13 +16054,13 @@ function createQueryBuilder(state) {
         },
         async execute() {
           try {
-            await config5.hooks?.beforeDelete?.({ table: String(table), where: whereCondition });
+            await activeHooks()?.beforeDelete?.({ table: String(table), where: whereCondition });
           } catch (err) {
             throw err;
           }
           const result = mutationCount(await runWithHooks(ensureDelBuilt(), "delete"));
           try {
-            await config5.hooks?.afterDelete?.({ table: String(table), where: whereCondition, result });
+            await activeHooks()?.afterDelete?.({ table: String(table), where: whereCondition, result });
           } catch {}
           return result;
         },
@@ -16092,18 +16124,14 @@ function createQueryBuilder(state) {
     },
     async advisoryLock(key) {
       if (config5.dialect === "postgres") {
-        const s = String(key);
-        let hash = 7;
-        for (let i = 0;i < s.length; i++)
-          hash = hash * 31 + s.charCodeAt(i) | 0;
-        const k = typeof key === "number" ? key : Math.abs(hash);
-        const q = bunSql`SELECT pg_advisory_lock(${k})`;
+        const k = advisoryLockKey(key);
+        const q = _sql`SELECT pg_advisory_lock(${k})`;
         await runWithHooks(q, "raw");
         return;
       }
       if (isMysqlLike(config5.dialect)) {
         const lockName = `bqb:${String(key)}`;
-        const q = bunSql`SELECT GET_LOCK(${lockName}, -1) AS ok`;
+        const q = _sql`SELECT GET_LOCK(${lockName}, -1) AS ok`;
         await runWithHooks(q, "raw");
         return;
       }
@@ -16111,18 +16139,29 @@ function createQueryBuilder(state) {
     },
     async tryAdvisoryLock(key) {
       if (config5.dialect === "postgres") {
-        const s = String(key);
-        let hash = 7;
-        for (let i = 0;i < s.length; i++)
-          hash = hash * 31 + s.charCodeAt(i) | 0;
-        const k = typeof key === "number" ? key : Math.abs(hash);
-        const q = bunSql`SELECT pg_try_advisory_lock(${k}) as ok`;
+        const k = advisoryLockKey(key);
+        const q = _sql`SELECT pg_try_advisory_lock(${k}) as ok`;
+        const rows = await runWithHooks(q, "raw");
+        return Boolean(rows?.[0]?.ok);
+      }
+      if (isMysqlLike(config5.dialect)) {
+        const lockName = `bqb:${String(key)}`;
+        const q = _sql`SELECT GET_LOCK(${lockName}, 0) AS ok`;
+        const rows = await runWithHooks(q, "raw");
+        return Number(rows?.[0]?.ok) === 1;
+      }
+      return false;
+    },
+    async advisoryUnlock(key) {
+      if (config5.dialect === "postgres") {
+        const k = advisoryLockKey(key);
+        const q = _sql`SELECT pg_advisory_unlock(${k}) as ok`;
         const rows = await runWithHooks(q, "raw");
         return Boolean(rows?.[0]?.ok);
       }
       if (isMysqlLike(config5.dialect)) {
         const lockName = `bqb:${String(key)}`;
-        const q = bunSql`SELECT GET_LOCK(${lockName}, 0) AS ok`;
+        const q = _sql`SELECT RELEASE_LOCK(${lockName}) AS ok`;
         const rows = await runWithHooks(q, "raw");
         return Number(rows?.[0]?.ok) === 1;
       }
@@ -16132,11 +16171,11 @@ function createQueryBuilder(state) {
       return _sql.unsafe(query, params);
     },
     file(path, params) {
-      return bunSql.file(path, params);
+      return _sql.file(path, params);
     },
     async reserve() {
       const reserved = await bunSql.reserve();
-      const qb = createQueryBuilder({ sql: reserved, meta, schema });
+      const qb = createQueryBuilder({ sql: reserved, meta, schema, hooks: state?.hooks });
       qb.release = () => reserved.release();
       return qb;
     },
@@ -16156,7 +16195,7 @@ function createQueryBuilder(state) {
     },
     async ping() {
       try {
-        const q = bunSql`SELECT 1`;
+        const q = _sql`SELECT 1`;
         await runWithHooks(q, "select");
         return true;
       } catch {
@@ -16183,7 +16222,7 @@ function createQueryBuilder(state) {
         opts.logger?.({ type: "start", attempt: attempt2 });
         const start = Date.now();
         return await txConn[txMethod](async (tx) => {
-          const qb = createQueryBuilder({ sql: tx, meta, schema, inTransaction: true });
+          const qb = createQueryBuilder({ sql: tx, meta, schema, hooks: state?.hooks, inTransaction: true });
           if (opts?.isolation && !nested) {
             const level = opts.isolation;
             const upper = level === "read committed" ? "READ COMMITTED" : level === "repeatable read" ? "REPEATABLE READ" : "SERIALIZABLE";
@@ -16246,14 +16285,14 @@ function createQueryBuilder(state) {
       if (!s || typeof s.savepoint !== "function")
         throw new Error("savepoint() is not supported by the active connection");
       return await s.savepoint(async (sp) => {
-        const qb = createQueryBuilder({ sql: sp, meta, schema, inTransaction: true });
+        const qb = createQueryBuilder({ sql: sp, meta, schema, hooks: state?.hooks, inTransaction: true });
         return await fn(qb);
       });
     },
     async beginDistributed(name, fn) {
       const txConn = state?.sql ?? bunSql;
       const res = await txConn.beginDistributed(name, async (tx) => {
-        const qb = createQueryBuilder({ sql: tx, meta, schema });
+        const qb = createQueryBuilder({ sql: tx, meta, schema, hooks: state?.hooks });
         return await fn(qb);
       });
       return res;
@@ -16279,24 +16318,24 @@ function createQueryBuilder(state) {
       const { colsSql, valuesSql, params } = buildInsertClause(rows);
       const tbl = quoteInsertIdent(String(table));
       const sqlText = isMysqlLike(config5.dialect) ? `INSERT IGNORE INTO ${tbl} (${colsSql}) VALUES ${valuesSql}` : `INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql} ON CONFLICT DO NOTHING`;
-      return bunSql.unsafe(sqlText, params).execute();
+      return _sql.unsafe(sqlText, params).execute();
     },
     async insertGetId(table, values, idColumn = "id") {
       const { colsSql, valuesSql, params } = buildInsertClause([values]);
       const tbl = quoteInsertIdent(String(table));
       if (isMysqlLike(config5.dialect)) {
-        await bunSql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
-        const [row2] = await bunSql.unsafe(`SELECT LAST_INSERT_ID() as id`).execute();
+        await _sql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
+        const [row2] = await _sql.unsafe(`SELECT LAST_INSERT_ID() as id`).execute();
         return row2?.id;
       }
       if (config5.dialect === "sqlite") {
-        const res = await bunSql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
+        const res = await _sql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
         if (res?.lastInsertRowid != null)
           return res.lastInsertRowid;
-        const [row2] = await bunSql.unsafe(`SELECT last_insert_rowid() as id`).execute();
+        const [row2] = await _sql.unsafe(`SELECT last_insert_rowid() as id`).execute();
         return row2?.id;
       }
-      const [row] = await bunSql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql} RETURNING ${quoteInsertIdent(String(idColumn))} as id`, params).execute();
+      const [row] = await _sql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql} RETURNING ${quoteInsertIdent(String(idColumn))} as id`, params).execute();
       return row?.id;
     },
     async updateOrInsert(table, match, values) {
@@ -16305,18 +16344,18 @@ function createQueryBuilder(state) {
       let idx = 1;
       const whereSql = matchKeys.map((k) => `${quoteInsertIdent(k)} = ${getPlaceholder(idx++)}`).join(" AND ");
       const whereParams = matchKeys.map((k) => match[k]);
-      const existsRows = await bunSql.unsafe(`SELECT 1 FROM ${tbl} WHERE ${whereSql} LIMIT 1`, whereParams).execute();
+      const existsRows = await _sql.unsafe(`SELECT 1 FROM ${tbl} WHERE ${whereSql} LIMIT 1`, whereParams).execute();
       if (existsRows.length) {
         const setKeys = Object.keys(values);
         let i = 1;
         const setSql = setKeys.map((k) => `${quoteInsertIdent(k)} = ${getPlaceholder(i++)}`).join(", ");
         const whereSql2 = matchKeys.map((k) => `${quoteInsertIdent(k)} = ${getPlaceholder(i++)}`).join(" AND ");
         const params2 = [...setKeys.map((k) => values[k]), ...matchKeys.map((k) => match[k])];
-        await bunSql.unsafe(`UPDATE ${tbl} SET ${setSql} WHERE ${whereSql2}`, params2).execute();
+        await _sql.unsafe(`UPDATE ${tbl} SET ${setSql} WHERE ${whereSql2}`, params2).execute();
         return true;
       }
       const { colsSql, valuesSql, params } = buildInsertClause([{ ...match, ...values }]);
-      await bunSql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
+      await _sql.unsafe(`INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
       return true;
     },
     async upsert(table, rows, conflictColumns, mergeColumns) {
@@ -16330,15 +16369,15 @@ function createQueryBuilder(state) {
       const insert = `INSERT INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`;
       if (isMysqlLike(config5.dialect)) {
         if (setCols.length === 0)
-          return bunSql.unsafe(`INSERT IGNORE INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
+          return _sql.unsafe(`INSERT IGNORE INTO ${tbl} (${colsSql}) VALUES ${valuesSql}`, params).execute();
         const updateList2 = setCols.map((c) => `${quoteInsertIdent(c)} = VALUES(${quoteInsertIdent(c)})`).join(", ");
-        return bunSql.unsafe(`${insert} ON DUPLICATE KEY UPDATE ${updateList2}`, params).execute();
+        return _sql.unsafe(`${insert} ON DUPLICATE KEY UPDATE ${updateList2}`, params).execute();
       }
       const targets = targetCols.map(quoteInsertIdent).join(", ");
       if (setCols.length === 0)
-        return bunSql.unsafe(`${insert} ON CONFLICT (${targets}) DO NOTHING`, params).execute();
+        return _sql.unsafe(`${insert} ON CONFLICT (${targets}) DO NOTHING`, params).execute();
       const updateList = setCols.map((c) => `${quoteInsertIdent(c)} = EXCLUDED.${quoteInsertIdent(c)}`).join(", ");
-      return bunSql.unsafe(`${insert} ON CONFLICT (${targets}) DO UPDATE SET ${updateList}`, params).execute();
+      return _sql.unsafe(`${insert} ON CONFLICT (${targets}) DO UPDATE SET ${updateList}`, params).execute();
     },
     async save(table, values) {
       const pk = meta?.primaryKeys[String(table)] ?? "id";
@@ -16381,26 +16420,25 @@ function createQueryBuilder(state) {
     async rawQuery(query) {
       const start = Date.now();
       try {
-        config5.hooks?.onQueryStart?.({ sql: query, kind: "raw" });
-        const res = await bunSql.unsafe(query);
-        config5.hooks?.onQueryEnd?.({ sql: query, durationMs: Date.now() - start, kind: "raw" });
+        activeHooks()?.onQueryStart?.({ sql: query, kind: "raw" });
+        const res = await _sql.unsafe(query);
+        activeHooks()?.onQueryEnd?.({ sql: query, durationMs: Date.now() - start, kind: "raw" });
         return res;
       } catch (err) {
-        config5.hooks?.onQueryError?.({ sql: query, error: err, durationMs: Date.now() - start, kind: "raw" });
+        activeHooks()?.onQueryError?.({ sql: query, error: err, durationMs: Date.now() - start, kind: "raw" });
         throw err;
       }
     },
     async create(table, values) {
       const pk = meta?.primaryKeys[String(table)] ?? "id";
       try {
-        await config5.hooks?.beforeCreate?.({ table: String(table), data: values });
+        await activeHooks()?.beforeCreate?.({ table: String(table), data: values });
       } catch (err) {
         throw err;
       }
       if (config5.dialect === "postgres") {
-        const q = bunSql`INSERT INTO ${bunSql(String(table))} ${bunSql(values)} RETURNING ${bunSql(String(pk))} as id`;
+        const q = _sql`INSERT INTO ${_sql(String(table))} ${_sql(values)} RETURNING ${_sql(String(pk))} as id`;
         const [result] = await q.execute();
-        console.log("resultId", result);
         if (!result?.id) {
           console.error(`create() failed to get insert ID for table ${String(table)}`);
           console.error("Inserted values:", values);
@@ -16413,7 +16451,7 @@ function createQueryBuilder(state) {
           throw new Error(`create() failed to retrieve inserted row for table ${String(table)} with id ${result.id}`);
         }
         try {
-          await config5.hooks?.afterCreate?.({ table: String(table), data: values, result: row });
+          await activeHooks()?.afterCreate?.({ table: String(table), data: values, result: row });
         } catch {}
         return row;
       } else {
@@ -16428,7 +16466,7 @@ function createQueryBuilder(state) {
           throw new Error(`create() failed to retrieve inserted row for table ${String(table)} with id ${id}`);
         }
         try {
-          await config5.hooks?.afterCreate?.({ table: String(table), data: values, result: row });
+          await activeHooks()?.afterCreate?.({ table: String(table), data: values, result: row });
         } catch {}
         return row;
       }
@@ -16568,28 +16606,28 @@ function createQueryBuilder(state) {
       return await this.create(table, { ...match, ...values });
     },
     async count(table, column) {
-      const col = column ? bunSql(String(column)) : bunSql`*`;
-      const q = bunSql`SELECT COUNT(${col}) as c FROM ${bunSql(String(table))}`;
+      const col = column ? _sql(String(column)) : _sql`*`;
+      const q = _sql`SELECT COUNT(${col}) as c FROM ${_sql(String(table))}`;
       const [row] = await q.execute();
       return Number(row?.c ?? 0);
     },
     async sum(table, column) {
-      const q = bunSql`SELECT SUM(${bunSql(String(column))}) as s FROM ${bunSql(String(table))}`;
+      const q = _sql`SELECT SUM(${_sql(String(column))}) as s FROM ${_sql(String(table))}`;
       const [row] = await q.execute();
       return Number(row?.s ?? 0);
     },
     async avg(table, column) {
-      const q = bunSql`SELECT AVG(${bunSql(String(column))}) as a FROM ${bunSql(String(table))}`;
+      const q = _sql`SELECT AVG(${_sql(String(column))}) as a FROM ${_sql(String(table))}`;
       const [row] = await q.execute();
       return Number(row?.a ?? 0);
     },
     async min(table, column) {
-      const q = bunSql`SELECT MIN(${bunSql(String(column))}) as m FROM ${bunSql(String(table))}`;
+      const q = _sql`SELECT MIN(${_sql(String(column))}) as m FROM ${_sql(String(table))}`;
       const [row] = await q.execute();
       return row?.m;
     },
     async max(table, column) {
-      const q = bunSql`SELECT MAX(${bunSql(String(column))}) as m FROM ${bunSql(String(table))}`;
+      const q = _sql`SELECT MAX(${_sql(String(column))}) as m FROM ${_sql(String(table))}`;
       const [row] = await q.execute();
       return row?.m;
     },
@@ -19114,6 +19152,33 @@ async function generateMigration(dir, opts = {}) {
     savePlanSnapshot(workspaceRoot, dialect, plan);
   return { sql, sqlStatements, hasChanges, plan, operations };
 }
+function supportsTransactionalDdl(dialect) {
+  return dialect === "postgres" || dialect === "sqlite";
+}
+async function withMigrationLock(dialect, fn) {
+  if (dialect === "sqlite")
+    return await fn();
+  const qb = createQueryBuilder();
+  let reserved;
+  try {
+    reserved = await qb.reserve();
+  } catch {
+    return await fn();
+  }
+  let held = false;
+  try {
+    await reserved.advisoryLock(MIGRATION_LOCK_KEY);
+    held = true;
+    return await fn();
+  } finally {
+    try {
+      if (held)
+        await reserved.advisoryUnlock(MIGRATION_LOCK_KEY);
+    } finally {
+      reserved.release?.();
+    }
+  }
+}
 async function executeMigration(dir) {
   await getConfig();
   const workspaceRoot = getWorkspaceRoot();
@@ -19129,31 +19194,46 @@ async function executeMigration(dir) {
   try {
     const qb = createQueryBuilder();
     await createMigrationsTable(qb, dialect);
-    const executedMigrations = await getExecutedMigrations(qb, dialect);
-    const pending = scriptFiles.filter((file2) => !executedMigrations.includes(file2));
-    if (pending.length === 0) {
-      info("-- No pending migrations to execute");
-      return true;
-    }
-    info(`-- Executing ${pending.length} migration${pending.length === 1 ? "" : "s"}`);
-    for (const file2 of pending) {
-      const filePath = join10(sqlDir, file2);
-      info(`-- Executing: ${file2}`);
-      try {
-        await qb.file(filePath);
-        await recordMigration(qb, file2, dialect);
-        info(`-- \u2713 Migration ${file2} executed and recorded`);
-      } catch (err) {
-        if (isGeneratedMigration(sqlDir, file2) && isAlreadyAppliedError(err)) {
-          await recordMigration(qb, file2, dialect);
-          info(`-- \u2713 Migration ${file2} was already applied; recorded it (${err instanceof Error ? err.message : String(err)})`);
-          continue;
+    return await withMigrationLock(dialect, async () => {
+      const executedMigrations = await getExecutedMigrations(qb, dialect);
+      const pending = scriptFiles.filter((file2) => !executedMigrations.includes(file2));
+      if (pending.length === 0) {
+        info("-- No pending migrations to execute");
+        return true;
+      }
+      info(`-- Executing ${pending.length} migration${pending.length === 1 ? "" : "s"}`);
+      for (const file2 of pending) {
+        const filePath = join10(sqlDir, file2);
+        info(`-- Executing: ${file2}`);
+        try {
+          const wrappable = supportsTransactionalDdl(dialect) && !NON_TRANSACTIONAL_SQL.test(readFileSync3(filePath, "utf-8"));
+          if (wrappable) {
+            await qb.transaction(async (tx) => {
+              await tx.file(filePath);
+              await recordMigration(tx, file2, dialect);
+            });
+          } else {
+            await qb.file(filePath);
+            await recordMigration(qb, file2, dialect);
+            if (!supportsTransactionalDdl(dialect))
+              info(`--   (${dialect} commits DDL implicitly, so ${file2} was not applied atomically)`);
+            else
+              info(`--   (${file2} contains a statement that cannot run in a transaction, so it was not applied atomically)`);
+          }
+          info(`-- \u2713 Migration ${file2} executed and recorded`);
+        } catch (err) {
+          if (isGeneratedMigration(sqlDir, file2) && isAlreadyAppliedError(err)) {
+            await recordMigration(qb, file2, dialect);
+            info(`-- \u2713 Migration ${file2} was already applied; recorded it (${err instanceof Error ? err.message : String(err)})`);
+            continue;
+          }
+          console.error(`-- \u2717 Migration ${file2} failed:`, err);
+          throw err;
         }
-        console.error(`-- \u2717 Migration ${file2} failed:`, err);
-        throw err;
       }
-    }
-    info("-- All migrations executed successfully");
+      info("-- All migrations executed successfully");
+      return true;
+    });
   } catch (err) {
     console.error("-- Migration execution failed:", err);
     throw err;
@@ -19344,6 +19424,7 @@ async function recordMigration(qb, migrationFile, dialect) {
     throw err;
   }
 }
+var MIGRATION_LOCK_KEY = "bun-query-builder:migrate", NON_TRANSACTIONAL_SQL;
 var init_migrate = __esm(() => {
   init_config();
   init_db();
@@ -19351,6 +19432,7 @@ var init_migrate = __esm(() => {
   init_src2();
   init_introspect_db();
   init_workspace();
+  NON_TRANSACTIONAL_SQL = /\bCONCURRENTLY\b|^\s*VACUUM\b/im;
 });
 
 // src/actions/migrate-generate.ts
@@ -25432,6 +25514,28 @@ function toTableName2(modelName) {
   tableNameCache.set(modelName, cached);
   return cached;
 }
+function relationNamesFor(definition, kind) {
+  const rel = definition[kind];
+  if (!rel)
+    return [];
+  if (Array.isArray(rel))
+    return rel.map((item) => typeof item === "string" ? item : String(item?.model ?? "")).filter(Boolean);
+  if (typeof rel === "object")
+    return Object.keys(rel);
+  if (typeof rel === "string")
+    return [rel];
+  return [];
+}
+function unresolvedRelationMessage(definition, relationName) {
+  const model = definition.name ?? definition.table ?? "model";
+  const declaredUnder = DECLARABLE_RELATION_KINDS.filter((kind) => relationNamesFor(definition, kind).some((n2) => n2.toLowerCase() === relationName.toLowerCase()));
+  const unsupported = declaredUnder.filter((k2) => !RESOLVABLE_RELATION_KINDS.includes(k2));
+  if (unsupported.length > 0) {
+    return `[orm] '${model}' declares '${relationName}' as ${unsupported.join("/")}, which eager loading does not support yet. ` + `Supported kinds: ${RESOLVABLE_RELATION_KINDS.join(", ")}. ` + `Load it with a manual query for now \u2014 see stacksjs/bun-query-builder#1068.`;
+  }
+  const available = RESOLVABLE_RELATION_KINDS.flatMap((kind) => relationNamesFor(definition, kind));
+  return available.length > 0 ? `[orm] '${model}' has no relation '${relationName}'. Available: ${available.join(", ")}.` : `[orm] '${model}' has no relation '${relationName}' \u2014 it declares no relations at all.`;
+}
 function resolveRelation(definition, relationName) {
   const parentName = definition.name;
   const parentTable = definition.table;
@@ -26166,7 +26270,7 @@ class ModelQueryBuilder {
       relationCache.set(cacheKey, rel);
     }
     if (!rel)
-      return;
+      throw new Error(unresolvedRelationMessage(this._definition, relationName));
     if (rel.type === "hasMany" || rel.type === "hasOne") {
       const parentIds = distinctParentIds(instances, pk);
       if (parentIds.length === 0)
@@ -26758,7 +26862,7 @@ async function seedModel(definition, count, faker) {
     await exec.run(`INSERT INTO ${definition.table} (${columns.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`, Object.values(data));
   }
 }
-var SAFE_SQL_IDENTIFIER, _getModel = null, pgPlaceholderCache, PG_PLACEHOLDER_CACHE_MAX = 500, globalDb = null, _executor = null, _executorForDb = null, _executorDialect = null, _executorDatabase = null, SOFT_DELETE_COLUMN = "deleted_at", BTM_RELATED_ALIAS = "__btm_rel__", btmKeysCache, snakeCaseCache, tableNameCache, relationCache, RELATION_CACHE_MAX = 1000;
+var SAFE_SQL_IDENTIFIER, _getModel = null, pgPlaceholderCache, PG_PLACEHOLDER_CACHE_MAX = 500, globalDb = null, _executor = null, _executorForDb = null, _executorDialect = null, _executorDatabase = null, SOFT_DELETE_COLUMN = "deleted_at", BTM_RELATED_ALIAS = "__btm_rel__", btmKeysCache, snakeCaseCache, tableNameCache, relationCache, RELATION_CACHE_MAX = 1000, RESOLVABLE_RELATION_KINDS, DECLARABLE_RELATION_KINDS;
 var init_orm = __esm(() => {
   init_config();
   init_db();
@@ -26769,6 +26873,17 @@ var init_orm = __esm(() => {
   snakeCaseCache = new Map;
   tableNameCache = new Map;
   relationCache = new Map;
+  RESOLVABLE_RELATION_KINDS = ["hasMany", "hasOne", "belongsTo", "belongsToMany"];
+  DECLARABLE_RELATION_KINDS = [
+    ...RESOLVABLE_RELATION_KINDS,
+    "hasOneThrough",
+    "hasManyThrough",
+    "morphOne",
+    "morphMany",
+    "morphTo",
+    "morphToMany",
+    "morphedByMany"
+  ];
 });
 
 // src/model.ts
@@ -31690,7 +31805,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.2.25";
+var version2 = "0.2.26";
 
 // bin/cli.ts
 init_actions();

package/dist/client.d.ts

@@ -1,6 +1,7 @@
 import { config } from './config';
 import { resetConnection } from './db';
 import type { DatabaseSchema } from './schema';
+import type { QueryHooks } from './types';
 import type { SchemaMeta } from './meta';
 /**
  * # `raw`
@@ -380,6 +381,7 @@ export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
   ids?: (...names: string[]) => any
   advisoryLock?: (key: number | string) => Promise<void>
   tryAdvisoryLock?: (key: number | string) => Promise<boolean>
+  advisoryUnlock?: (key: number | string) => Promise<boolean>
   getRelationships?: (table: string) => Record<string, any>
   hasRelationship?: (table: string, relationName: string) => boolean
   getRelationshipType?: (table: string, relationName: string) => string | null
@@ -390,6 +392,7 @@ declare interface InternalState {
   meta?: SchemaMeta
   schema?: any
   txDefaults?: TransactionOptions
+  hooks?: QueryHooks
   inTransaction?: boolean
 }
 declare interface TxBackoff { baseMs?: number, maxMs?: number, factor?: number, jitter?: boolean }