bun-query-builder 0.2.43 → 0.2.45

package/dist/bin/cli.js

@@ -140,7 +140,7 @@ class BrowserQueryBuilder {
     return this;
   }
   andWhere(column, operatorOrValue, value) {
-    return this.where(column, operatorOrValue, value);
+    return value === undefined ? this.where(column, operatorOrValue) : this.where(column, operatorOrValue, value);
   }
   whereNull(column) {
     return this.where(column, "is", null);
@@ -476,7 +476,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");
@@ -11862,6 +11862,12 @@ import { Database } from "bun:sqlite";
 import { mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname5 } from "path";
 import process21 from "process";
+function toBindings(params) {
+  return params;
+}
+function asEmbeddedValue(value) {
+  return value !== null && typeof value === "object" ? value : null;
+}
 function bindNumberedPlaceholders(sql, params) {
   if (params.length === 0 || !/\$\d/.test(sql))
     return { sql, params };
@@ -12050,11 +12056,13 @@ function createSQLiteSQL(filename) {
     const params = [];
     for (let i = 0;i < values.length; i++) {
       const value = values[i];
-      if (value && typeof value === "object" && typeof value.sql === "string" && Array.isArray(value.values)) {
-        sql += value.sql + (strings[i + 1] || "");
-        params.push(...value.values);
-      } else if (value && typeof value === "object" && (value.__raw || value.raw)) {
-        const rawValue = value.__raw ? value.value : typeof value.raw === "string" ? value.raw : value.raw();
+      const embedded = asEmbeddedValue(value);
+      if (embedded && typeof embedded.sql === "string" && Array.isArray(embedded.values)) {
+        sql += embedded.sql + (strings[i + 1] || "");
+        params.push(...embedded.values);
+      } else if (embedded && (embedded.__raw || embedded.raw)) {
+        const raw = embedded.raw;
+        const rawValue = embedded.__raw ? embedded.value : typeof raw === "string" ? raw : raw();
         sql += rawValue + (strings[i + 1] || "");
       } else if (Array.isArray(value)) {
         const placeholders = value.map(() => "?").join(", ");
@@ -12072,10 +12080,10 @@ function createSQLiteSQL(filename) {
         try {
           const trimmed = sql.trim().toUpperCase();
           if (trimmed.startsWith("SELECT") || trimmed.startsWith("PRAGMA") || /\bRETURNING\b/.test(trimmed)) {
-            const result = wrapper.query(sql, params);
+            const result = wrapper.query(sql, toBindings(params));
             return Promise.resolve(result);
           } else {
-            const result = wrapper.run(sql, params);
+            const result = wrapper.run(sql, toBindings(params));
             return Promise.resolve(result);
           }
         } catch (error) {
@@ -12102,10 +12110,10 @@ function createSQLiteSQL(filename) {
       try {
         const trimmed = sql.trim().toUpperCase();
         if (trimmed.startsWith("SELECT") || trimmed.startsWith("PRAGMA") || /\bRETURNING\b/.test(trimmed)) {
-          const result = wrapper.query(sql, params);
+          const result = wrapper.query(sql, toBindings(params));
           return Promise.resolve(result);
         } else {
-          const result = wrapper.run(sql, params);
+          const result = wrapper.run(sql, toBindings(params));
           return Promise.resolve(result);
         }
       } catch (error) {
@@ -12128,7 +12136,7 @@ function createSQLiteSQL(filename) {
   };
   sqlFunction.query = (sql, params) => {
     try {
-      const result = wrapper.query(sql, params || []);
+      const result = wrapper.query(sql, toBindings(params || []));
       return Promise.resolve(result);
     } catch (error) {
       return Promise.reject(error);
@@ -15793,6 +15801,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) => "?";
@@ -15801,9 +15834,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;
@@ -15857,6 +15894,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 () => {
@@ -15890,11 +15929,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) {
@@ -15909,12 +15952,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");
@@ -15923,6 +15970,8 @@ function createQueryBuilder(state) {
           return result;
         },
         returningAll() {
+          if (noRows)
+            return emptyReturningBuilder();
           const returningSql = `${sqlText} RETURNING *`;
           const q = _sql.unsafe(returningSql, params);
           const runFirst = async () => {
@@ -16029,8 +16078,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 });
@@ -16040,8 +16103,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";
@@ -16056,22 +16120,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() {
@@ -16110,17 +16192,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");
@@ -16185,8 +16267,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;
@@ -16197,8 +16293,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`;
@@ -16211,22 +16306,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() {
@@ -16270,17 +16391,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");
@@ -18944,11 +19065,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, '""')}"`;
@@ -18957,40 +19133,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);
@@ -25386,6 +25536,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 {
@@ -25396,7 +25554,7 @@ function getModelFromRegistry(name) {
       };
     }
   }
-  return _getModel(name);
+  return _getModel(name) ?? localModels.get(name);
 }
 function toPostgresPlaceholders(sql2) {
   const hit = pgPlaceholderCache.get(sql2);
@@ -25594,6 +25752,7 @@ function findAttributeDef(attrs, key) {
 class ModelInstance {
   _attributes;
   _original;
+  _forced = new Set;
   _definition;
   _hasSaved = false;
   _relations = {};
@@ -25727,7 +25886,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() {
@@ -25759,7 +25921,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) {
@@ -27157,7 +27319,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();
@@ -27174,12 +27339,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)
@@ -27245,12 +27407,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;
@@ -27295,6 +27458,7 @@ function hasModel(name) {
 }
 function clearModelRegistry() {
   modelRegistry.clear();
+  clearLocalModels();
 }
 function registerModel(name, model) {
   modelRegistry.set(name, model);
@@ -29070,7 +29234,7 @@ function detectTypeFromValidationRule(rule) {
   }
   return;
 }
-function normalizeAttributeType(value) {
+function normalizeAttributeType2(value) {
   if (typeof value !== "string")
     return;
   const type = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
@@ -29160,7 +29324,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)
@@ -32359,7 +32523,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.2.43";
+var version2 = "0.2.45";
 
 // bin/cli.ts
 init_actions();