bun-query-builder 0.2.41 → 0.2.44

package/dist/src/index.js

@@ -475,7 +475,7 @@ class BrowserModelQueryBuilder {
     for (const where of this._wheres) {
       if (where.operator === "=") {
         params.append(where.column, String(where.value));
-      } else if ((where.operator === "in" || where.operator === "not in") && Array.isArray(where.value)) {
+      } else if (where.operator === "in" && Array.isArray(where.value)) {
         params.append(`${where.column}[]`, where.value.join(","));
       } else if (where.operator === "is" && where.value === null) {
         params.append(`filter[${where.column}][is]`, "null");
@@ -12855,7 +12855,10 @@ function warnOnceBareSqlFragment(context) {
   if (warnedSqlFragmentContexts.has(context))
     return;
   warnedSqlFragmentContexts.add(context);
-  console.warn(`[query-builder] ${context}: bare string passed to a *Raw method. ` + `Prefer \`sql\`...\`\` tagged-template fragments so values are parameterised ` + `instead of concatenated \u2014 concatenating request input into SQL is an ` + `injection vector. This will become a hard error in a future release.`);
+  console.warn(`[query-builder] ${context}: bare string passed to a *Raw method. ` + `Prefer the \`raw\`...\`\` tagged template, which escapes interpolated ` + `values for the configured dialect \u2014 concatenating request input into SQL ` + `is an injection vector. This will become a hard error in a future release.`);
+}
+function escapeStringLiteral(value, dialect = config5.dialect) {
+  return isMysqlLike(dialect) ? value.replace(/\\/g, "\\\\").replace(/'/g, "''") : value.replace(/'/g, "''");
 }
 function formatSubqueryValue(val) {
   if (val === null)
@@ -12865,7 +12868,7 @@ function formatSubqueryValue(val) {
   if (typeof val === "boolean")
     return val ? "1" : "0";
   if (typeof val === "string")
-    return `'${val.replace(/'/g, "''")}'`;
+    return `'${escapeStringLiteral(val)}'`;
   if (val instanceof Date)
     return `'${val.toISOString()}'`;
   throw new TypeError(`[query-builder] subquery condition: refusing to interpolate value of type ${typeof val}`);
@@ -14486,11 +14489,13 @@ function createQueryBuilder(state) {
         const dialect = config5.dialect;
         const idx = whereParams.length + 1;
         if (dialect === "postgres") {
+          const needsJsonbLift = typeof json === "number" || typeof json === "boolean";
+          const operand = needsJsonbLift ? `to_jsonb(${getPlaceholder(idx)})` : getPlaceholder(idx);
           if (config5.sql?.jsonContainsMode === "function")
-            pushWhere("AND", `jsonb_contains(${column}, ${getPlaceholder(idx)})`);
+            pushWhere("AND", `jsonb_contains(${column}, ${operand})`);
           else
-            pushWhere("AND", `${column} @> ${getPlaceholder(idx)}`);
-          whereParams.push(JSON.stringify(json));
+            pushWhere("AND", `${column} @> ${operand}`);
+          whereParams.push(json);
         } else if (isMysqlLike(dialect)) {
           pushWhere("AND", `JSON_CONTAINS(${column}, ${getPlaceholder(idx)})`);
           whereParams.push(JSON.stringify(json));
@@ -15787,6 +15792,31 @@ function createQueryBuilder(state) {
       let built;
       let sqlText = "";
       const params = [];
+      let noRows = false;
+      const emptyInsertResult = () => isPostgres ? [] : { changes: 0, lastInsertRowid: 0 };
+      const emptyReturningBuilder = () => {
+        const noRow = async () => {
+          return;
+        };
+        const noRowOrFail = async () => {
+          throw new Error("Insert with RETURNING returned no rows");
+        };
+        return {
+          where: () => emptyReturningBuilder(),
+          andWhere: () => emptyReturningBuilder(),
+          orWhere: () => emptyReturningBuilder(),
+          orderBy: () => emptyReturningBuilder(),
+          limit: () => emptyReturningBuilder(),
+          offset: () => emptyReturningBuilder(),
+          toSQL: () => makeExecutableQuery(null, ""),
+          execute: async () => [],
+          get: async () => [],
+          first: noRow,
+          executeTakeFirst: noRow,
+          firstOrFail: noRowOrFail,
+          executeTakeFirstOrThrow: noRowOrFail
+        };
+      };
       const isPostgres = config5.dialect === "postgres";
       const quoteId = isPostgres ? (id) => `"${String(id).replace(/"/g, '""')}"` : isMysqlLike(config5.dialect) ? (id) => `\`${String(id).replace(/`/g, "``")}\`` : (id) => `"${String(id).replace(/"/g, '""')}"`;
       const getPlaceholder2 = isPostgres ? (index) => `$${index + 1}` : (_index) => "?";
@@ -15795,9 +15825,13 @@ function createQueryBuilder(state) {
           const rows = Array.isArray(data) ? data : [data];
           const rowCount = rows.length;
           if (rowCount === 0) {
-            built = _sql.unsafe("SELECT 1");
+            noRows = true;
+            built = null;
+            sqlText = "";
+            params.length = 0;
             return this;
           }
+          noRows = false;
           const firstRow = rows[0];
           const keys = Object.keys(firstRow);
           const colCount = keys.length;
@@ -15851,6 +15885,8 @@ function createQueryBuilder(state) {
           return this;
         },
         returning(...cols) {
+          if (noRows)
+            return emptyReturningBuilder();
           const returningSql = `${sqlText} RETURNING ${cols.join(", ")}`;
           const q = _sql.unsafe(returningSql, params);
           const runFirst = async () => {
@@ -15884,11 +15920,15 @@ function createQueryBuilder(state) {
           };
         },
         toSQL() {
+          if (noRows)
+            return makeExecutableQuery(null, "");
           if (!built)
             built = _sql.unsafe(sqlText, params);
           return makeExecutableQuery(built, sqlText);
         },
         execute() {
+          if (noRows)
+            return Promise.resolve(emptyInsertResult());
           const hooks = activeHooks();
           const hasHooks = hooks && (hooks.onQueryStart || hooks.onQueryEnd || hooks.onQueryError || hooks.startSpan || hooks.beforeCreate || hooks.afterCreate || hasSlowQueryHook(hooks));
           if (!hasHooks) {
@@ -15903,12 +15943,16 @@ function createQueryBuilder(state) {
           return runWithHooks(built, "insert");
         },
         async executeTakeFirst() {
+          if (noRows)
+            return emptyInsertResult();
           if (!built)
             built = _sql.unsafe(sqlText, params);
           const result = await runWithHooks(built, "insert");
           return result;
         },
         async executeTakeFirstOrThrow() {
+          if (noRows)
+            throw new Error("Insert failed");
           if (!built)
             built = _sql.unsafe(sqlText, params);
           const result = await runWithHooks(built, "insert");
@@ -15917,6 +15961,8 @@ function createQueryBuilder(state) {
           return result;
         },
         returningAll() {
+          if (noRows)
+            return emptyReturningBuilder();
           const returningSql = `${sqlText} RETURNING *`;
           const q = _sql.unsafe(returningSql, params);
           const runFirst = async () => {
@@ -16023,8 +16069,22 @@ function createQueryBuilder(state) {
             built = _sql.unsafe(sqlText, params);
             return this;
           }
-          if (expr && typeof expr === "object" && !("raw" in expr)) {
+          if (isRawExpression(expr)) {
+            sqlText = `${sqlText} ${getWhereKeyword()} ${expr.raw}`;
+            built = _sql.unsafe(sqlText, params);
+            return this;
+          }
+          if (isBoundSqlExpression(expr)) {
+            const rendered = renderBoundSqlExpression(expr, params.length + 1);
+            sqlText = `${sqlText} ${getWhereKeyword()} ${rendered.text}`;
+            params.push(...rendered.parameters);
+            built = _sql.unsafe(sqlText, params);
+            return this;
+          }
+          if (expr && typeof expr === "object") {
             const keys = Object.keys(expr);
+            if (keys.length === 0)
+              throw new TypeError("[query-builder] updateTable.where({}): an empty object is not a filter. Pass a condition, or drop the where() call if updating every row is intended.");
             const len = keys.length;
             const baseIdx = params.length;
             const conditions = Array.from({ length: len });
@@ -16034,8 +16094,9 @@ function createQueryBuilder(state) {
             }
             sqlText = `${sqlText} ${getWhereKeyword()} ${conditions.join(" AND ")}`;
             built = _sql.unsafe(sqlText, params);
+            return this;
           }
-          return this;
+          throw new TypeError(`[query-builder] updateTable.where(): expected a condition, got ${expr === null ? "null" : typeof expr}. Refusing to run an UPDATE with no WHERE \u2014 drop the where() call if updating every row is intended.`);
         },
         whereNull(column) {
           const keyword = SQL_PATTERNS.WHERE.test(sqlText) ? "AND" : "WHERE";
@@ -16050,22 +16111,40 @@ function createQueryBuilder(state) {
           return this;
         },
         returning(...cols) {
-          const retText = `${sqlText} RETURNING ${cols.join(", ")}`;
-          const q = params.length > 0 ? _sql.unsafe(retText, params) : _sql.unsafe(retText);
+          const parent = this;
+          const retText = () => `${sqlText} RETURNING ${cols.join(", ")}`;
+          const build = () => params.length > 0 ? _sql.unsafe(retText(), params) : _sql.unsafe(retText());
           const runFirst = async () => {
-            const rows = await runWithHooks(q, "update");
+            const rows = await runWithHooks(build(), "update");
             return Array.isArray(rows) ? rows[0] : rows;
           };
+          const unsupported = (name) => () => {
+            throw new TypeError(`[query-builder] updateTable.returning(...).${name}() is not supported \u2014 an UPDATE cannot be ordered or limited through this builder. Apply the filter with where() instead.`);
+          };
           const obj = {
-            where: () => obj,
-            andWhere: () => obj,
-            orWhere: () => obj,
-            orderBy: () => obj,
-            limit: () => obj,
-            offset: () => obj,
-            toSQL: () => makeExecutableQuery(q, retText),
-            execute: () => runWithHooks(q, "update"),
-            get: () => runWithHooks(q, "update"),
+            where: (...args) => {
+              parent.where(...args);
+              return obj;
+            },
+            andWhere: (...args) => {
+              parent.where(...args);
+              return obj;
+            },
+            whereNull: (...args) => {
+              parent.whereNull(...args);
+              return obj;
+            },
+            whereNotNull: (...args) => {
+              parent.whereNotNull(...args);
+              return obj;
+            },
+            orWhere: unsupported("orWhere"),
+            orderBy: unsupported("orderBy"),
+            limit: unsupported("limit"),
+            offset: unsupported("offset"),
+            toSQL: () => makeExecutableQuery(build(), retText()),
+            execute: () => runWithHooks(build(), "update"),
+            get: () => runWithHooks(build(), "update"),
             first: runFirst,
             executeTakeFirst: runFirst,
             async firstOrFail() {
@@ -16104,17 +16183,17 @@ function createQueryBuilder(state) {
           return { numUpdatedRows: result };
         },
         returningAll() {
-          const retAllText = `${sqlText} RETURNING *`;
-          const q = params.length > 0 ? _sql.unsafe(retAllText, params) : _sql.unsafe(retAllText);
+          const retAllText = () => `${sqlText} RETURNING *`;
+          const build = () => params.length > 0 ? _sql.unsafe(retAllText(), params) : _sql.unsafe(retAllText());
           return {
-            toSQL: () => makeExecutableQuery(q, retAllText),
-            execute: () => runWithHooks(q, "update"),
+            toSQL: () => makeExecutableQuery(build(), retAllText()),
+            execute: () => runWithHooks(build(), "update"),
             async executeTakeFirst() {
-              const result = await runWithHooks(q, "update");
+              const result = await runWithHooks(build(), "update");
               return Array.isArray(result) ? result[0] : result;
             },
             async executeTakeFirstOrThrow() {
-              const result = await runWithHooks(q, "update");
+              const result = await runWithHooks(build(), "update");
               const first = Array.isArray(result) ? result[0] : result;
               if (!first)
                 throw new Error("Update with RETURNING failed");
@@ -16179,8 +16258,22 @@ function createQueryBuilder(state) {
             built = null;
             return this;
           }
-          if (expr && typeof expr === "object" && !("raw" in expr)) {
+          if (isRawExpression(expr)) {
+            sqlText += ` ${getWhereKeyword()} ${expr.raw}`;
+            built = null;
+            return this;
+          }
+          if (isBoundSqlExpression(expr)) {
+            const rendered = renderBoundSqlExpression(expr, delParams.length + 1);
+            sqlText += ` ${getWhereKeyword()} ${rendered.text}`;
+            delParams.push(...rendered.parameters);
+            built = null;
+            return this;
+          }
+          if (expr && typeof expr === "object") {
             const keys = Object.keys(expr);
+            if (keys.length === 0)
+              throw new TypeError("[query-builder] deleteFrom.where({}): an empty object is not a filter. Pass a condition, or drop the where() call if deleting every row is intended.");
             const conditions = [];
             for (const key of keys) {
               const paramIndex = delParams.length + 1;
@@ -16191,8 +16284,7 @@ function createQueryBuilder(state) {
             built = null;
             return this;
           }
-          built = applyWhere({}, ensureDelBuilt(), expr);
-          return this;
+          throw new TypeError(`[query-builder] deleteFrom.where(): expected a condition, got ${expr === null ? "null" : typeof expr}. Refusing to run a DELETE with no WHERE \u2014 drop the where() call if deleting every row is intended.`);
         },
         whereNull(column) {
           sqlText += ` ${getWhereKeyword()} ${quoteId(String(column))} IS NULL`;
@@ -16205,22 +16297,48 @@ function createQueryBuilder(state) {
           return this;
         },
         returning(...cols) {
-          const retText = `${sqlText} RETURNING ${cols.join(", ")}`;
-          const q = delParams.length > 0 ? _sql.unsafe(retText, delParams) : _sql.unsafe(retText);
+          const parent = this;
+          const retText = () => `${sqlText} RETURNING ${cols.join(", ")}`;
+          const build = () => delParams.length > 0 ? _sql.unsafe(retText(), delParams) : _sql.unsafe(retText());
+          const runDelete = async () => {
+            await activeHooks()?.beforeDelete?.({ table: String(table), where: whereCondition });
+            const rows = await runWithHooks(build(), "delete");
+            try {
+              await activeHooks()?.afterDelete?.({ table: String(table), where: whereCondition, result: rows });
+            } catch {}
+            return rows;
+          };
           const runFirst = async () => {
-            const rows = await runWithHooks(q, "delete");
+            const rows = await runDelete();
             return Array.isArray(rows) ? rows[0] : rows;
           };
+          const unsupported = (name) => () => {
+            throw new TypeError(`[query-builder] deleteFrom.returning(...).${name}() is not supported \u2014 a DELETE cannot be ordered or limited through this builder. Narrow it with where() instead.`);
+          };
           const obj = {
-            where: () => obj,
-            andWhere: () => obj,
-            orWhere: () => obj,
-            orderBy: () => obj,
-            limit: () => obj,
-            offset: () => obj,
-            toSQL: () => makeExecutableQuery(q, retText),
-            execute: () => runWithHooks(q, "delete"),
-            get: () => runWithHooks(q, "delete"),
+            where: (...args) => {
+              parent.where(...args);
+              return obj;
+            },
+            andWhere: (...args) => {
+              parent.where(...args);
+              return obj;
+            },
+            whereNull: (...args) => {
+              parent.whereNull(...args);
+              return obj;
+            },
+            whereNotNull: (...args) => {
+              parent.whereNotNull(...args);
+              return obj;
+            },
+            orWhere: unsupported("orWhere"),
+            orderBy: unsupported("orderBy"),
+            limit: unsupported("limit"),
+            offset: unsupported("offset"),
+            toSQL: () => makeExecutableQuery(build(), retText()),
+            execute: () => runDelete(),
+            get: () => runDelete(),
             first: runFirst,
             executeTakeFirst: runFirst,
             async firstOrFail() {
@@ -16264,17 +16382,17 @@ function createQueryBuilder(state) {
           return { numDeletedRows: result };
         },
         returningAll() {
-          const retAllText = `${sqlText} RETURNING *`;
-          const q = delParams.length > 0 ? _sql.unsafe(retAllText, delParams) : _sql.unsafe(retAllText);
+          const retAllText = () => `${sqlText} RETURNING *`;
+          const build = () => delParams.length > 0 ? _sql.unsafe(retAllText(), delParams) : _sql.unsafe(retAllText());
           return {
-            toSQL: () => makeExecutableQuery(q, retAllText),
-            execute: () => runWithHooks(q, "delete"),
+            toSQL: () => makeExecutableQuery(build(), retAllText()),
+            execute: () => runWithHooks(build(), "delete"),
             async executeTakeFirst() {
-              const result = await runWithHooks(q, "delete");
+              const result = await runWithHooks(build(), "delete");
               return Array.isArray(result) ? result[0] : result;
             },
             async executeTakeFirstOrThrow() {
-              const result = await runWithHooks(q, "delete");
+              const result = await runWithHooks(build(), "delete");
               const first = Array.isArray(result) ? result[0] : result;
               if (!first)
                 throw new Error("Delete with RETURNING failed");
@@ -18938,11 +19056,66 @@ var init_vitess = __esm(() => {
   };
 });
 
-// src/drivers/sqlite.ts
+// src/column-types.ts
 function isNumericPlanType(type) {
   return type === "integer" || type === "bigint" || type === "float" || type === "double" || type === "decimal";
 }
+function normalizeAttributeType(raw2) {
+  if (typeof raw2 !== "string")
+    return;
+  switch (raw2.toLowerCase()) {
+    case "string":
+      return "string";
+    case "text":
+      return "text";
+    case "integer":
+    case "int":
+      return "integer";
+    case "number":
+      return "integer";
+    case "bigint":
+      return "bigint";
+    case "float":
+      return "float";
+    case "double":
+      return "double";
+    case "decimal":
+      return "decimal";
+    case "boolean":
+    case "bool":
+      return "boolean";
+    case "date":
+      return "date";
+    case "datetime":
+    case "timestamp":
+      return "datetime";
+    case "timestamptz":
+    case "timestamp_tz":
+      return "timestamptz";
+    case "json":
+      return "json";
+    case "enum":
+      return "enum";
+    default:
+      return;
+  }
+}
+function sqliteAffinityFor(type) {
+  switch (type) {
+    case "boolean":
+    case "integer":
+    case "bigint":
+      return "INTEGER";
+    case "float":
+    case "double":
+    case "decimal":
+      return "REAL";
+    default:
+      return "TEXT";
+  }
+}
 
+// src/drivers/sqlite.ts
 class SQLiteDriver {
   quoteIdentifier(id) {
     return `"${id.replace(/"/g, '""')}"`;
@@ -18951,40 +19124,14 @@ class SQLiteDriver {
     if (column.name.endsWith("_id") && isNumericPlanType(column.type)) {
       return "INTEGER";
     }
-    switch (column.type) {
-      case "string":
-        return "TEXT";
-      case "text":
-        return "TEXT";
-      case "boolean":
-        return "INTEGER";
-      case "integer":
-        return "INTEGER";
-      case "bigint":
-        return "INTEGER";
-      case "float":
-        return "REAL";
-      case "double":
-        return "REAL";
-      case "decimal":
-        return "REAL";
-      case "date":
-        return "TEXT";
-      case "datetime":
-        return "TEXT";
-      case "timestamptz":
-        return "TEXT";
-      case "json":
-        return "TEXT";
-      case "enum":
-        if (column.enumValues && column.enumValues.length > 0) {
-          const enumValues = column.enumValues.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
-          return `TEXT CHECK (${this.quoteIdentifier(column.name)} IN (${enumValues}))`;
-        }
-        return "TEXT";
-      default:
-        return "TEXT";
+    if (column.type === "enum") {
+      if (column.enumValues && column.enumValues.length > 0) {
+        const enumValues = column.enumValues.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
+        return `TEXT CHECK (${this.quoteIdentifier(column.name)} IN (${enumValues}))`;
+      }
+      return "TEXT";
     }
+    return sqliteAffinityFor(column.type);
   }
   getPrimaryKeyType(column) {
     return this.getColumnType(column);
@@ -25380,6 +25527,14 @@ function assertValidOrderByColumn(name, context) {
   if (parts.length > 2 || parts.some((p2) => p2.length === 0 || p2.length > 64 || !SAFE_SQL_IDENTIFIER.test(p2)))
     throw new TypeError(`[bun-query-builder] ${context}: invalid ORDER BY column '${name}' \u2014 expected 'column' or 'table.column' of [A-Za-z0-9_] \u2014 refusing to interpolate into SQL`);
 }
+function registerLocalModel(name, model) {
+  localModels.set(name, model);
+  relationCache.clear();
+}
+function clearLocalModels() {
+  localModels.clear();
+  relationCache.clear();
+}
 function getModelFromRegistry(name) {
   if (!_getModel) {
     try {
@@ -25390,7 +25545,7 @@ function getModelFromRegistry(name) {
       };
     }
   }
-  return _getModel(name);
+  return _getModel(name) ?? localModels.get(name);
 }
 function toPostgresPlaceholders(sql2) {
   const hit = pgPlaceholderCache.get(sql2);
@@ -25588,6 +25743,7 @@ function findAttributeDef(attrs, key) {
 class ModelInstance {
   _attributes;
   _original;
+  _forced = new Set;
   _definition;
   _hasSaved = false;
   _relations = {};
@@ -25721,7 +25877,10 @@ class ModelInstance {
   forceFill(data) {
     if (this._original === null)
       this._original = { ...this._attributes };
-    Object.assign(this._attributes, normalizeAttributeKeys(data));
+    const normalized = normalizeAttributeKeys(data);
+    Object.assign(this._attributes, normalized);
+    for (const col of Object.keys(normalized))
+      this._forced.add(col);
     return this;
   }
   async save() {
@@ -25753,7 +25912,7 @@ class ModelInstance {
       const attrs = this._definition.attributes;
       const data = {};
       for (const [key, attr] of Object.entries(attrs)) {
-        if (attr.guarded)
+        if (attr.guarded && !this._forced.has(toSnakeCase(key)))
           continue;
         const col = toSnakeCase(key);
         if (this._attributes[col] !== undefined) {
@@ -27151,7 +27310,10 @@ function createModelInternal(definition) {
   });
 }
 function createModel(definition) {
-  return createModelInternal(definition);
+  const model = createModelInternal(definition);
+  if (definition?.name)
+    registerLocalModel(definition.name, model);
+  return model;
 }
 async function createTableFromModel(definition) {
   const exec = getExecutor();
@@ -27168,12 +27330,9 @@ async function createTableFromModel(definition) {
     if (emitted.has(name))
       continue;
     emitted.add(name);
-    let colType = "TEXT";
-    if (attr.type === "number")
-      colType = "INTEGER";
-    else if (attr.type === "boolean")
-      colType = "INTEGER";
-    if (name.endsWith("_id"))
+    const declaredType = normalizeAttributeType(attr.type);
+    let colType = sqliteAffinityFor(declaredType);
+    if (name.endsWith("_id") && (declaredType === undefined || isNumericPlanType(declaredType)))
       colType = "INTEGER";
     let colDef = `${name} ${colType}`;
     if (attr.unique)
@@ -27239,12 +27398,13 @@ 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, RESOLVABLE_RELATION_KINDS, DECLARABLE_RELATION_KINDS;
+var SAFE_SQL_IDENTIFIER, _getModel = null, localModels, 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();
   init_sqlite_pragmas();
   SAFE_SQL_IDENTIFIER = /^[A-Z_][A-Z0-9_]*$/i;
+  localModels = new Map;
   pgPlaceholderCache = new Map;
   btmKeysCache = new WeakMap;
   snakeCaseCache = new Map;
@@ -27289,6 +27449,7 @@ function hasModel(name) {
 }
 function clearModelRegistry() {
   modelRegistry.clear();
+  clearLocalModels();
 }
 function registerModel(name, model) {
   modelRegistry.set(name, model);
@@ -29064,7 +29225,7 @@ function detectTypeFromValidationRule(rule) {
   }
   return;
 }
-function normalizeAttributeType(value) {
+function normalizeAttributeType2(value) {
   if (typeof value !== "string")
     return;
   const type = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
@@ -29154,7 +29315,7 @@ function buildMigrationPlan2(models, options) {
       let inferred;
       let enumValues;
       const isPk = attrName === primaryKey;
-      inferred = normalizeAttributeType(attr.type) ?? detectTypeFromValidationRule(attr.validation?.rule);
+      inferred = normalizeAttributeType2(attr.type) ?? detectTypeFromValidationRule(attr.validation?.rule);
       if (inferred === "string") {
         const maxLength = extractMaxFromRules(attr.validation?.rule);
         if (maxLength && maxLength > MAX_BOUNDED_VARCHAR_LENGTH)
@@ -30380,6 +30541,7 @@ export {
   queryExplainAll as explainAllQueries,
   explain,
   executeMigration,
+  escapeStringLiteral,
   dynamo,
   dumpDatabase,
   defineSeeder,
@@ -30414,6 +30576,7 @@ export {
   config5 as config,
   clearQueryCache,
   clearModelRegistry,
+  clearLocalModels,
   checkSchema,
   canonicalizeDefault,
   canonicalStorageType,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-query-builder",
   "type": "module",
-  "version": "0.2.41",
+  "version": "0.2.44",
   "description": "A simple yet performant query builder for TypeScript. Built with Bun.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",