bun-query-builder 0.2.41 → 0.2.44

package/dist/bin/cli.js

@@ -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");
@@ -12856,7 +12856,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)
@@ -12866,7 +12869,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}`);
@@ -14487,11 +14490,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));
@@ -15788,6 +15793,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) => "?";
@@ -15796,9 +15826,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;
@@ -15852,6 +15886,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 () => {
@@ -15885,11 +15921,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) {
@@ -15904,12 +15944,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");
@@ -15918,6 +15962,8 @@ function createQueryBuilder(state) {
           return result;
         },
         returningAll() {
+          if (noRows)
+            return emptyReturningBuilder();
           const returningSql = `${sqlText} RETURNING *`;
           const q = _sql.unsafe(returningSql, params);
           const runFirst = async () => {
@@ -16024,8 +16070,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 });
@@ -16035,8 +16095,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";
@@ -16051,22 +16112,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() {
@@ -16105,17 +16184,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");
@@ -16180,8 +16259,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;
@@ -16192,8 +16285,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`;
@@ -16206,22 +16298,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() {
@@ -16265,17 +16383,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");
@@ -18939,11 +19057,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, '""')}"`;
@@ -18952,40 +19125,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);
@@ -25381,6 +25528,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 {
@@ -25391,7 +25546,7 @@ function getModelFromRegistry(name) {
       };
     }
   }
-  return _getModel(name);
+  return _getModel(name) ?? localModels.get(name);
 }
 function toPostgresPlaceholders(sql2) {
   const hit = pgPlaceholderCache.get(sql2);
@@ -25589,6 +25744,7 @@ function findAttributeDef(attrs, key) {
 class ModelInstance {
   _attributes;
   _original;
+  _forced = new Set;
   _definition;
   _hasSaved = false;
   _relations = {};
@@ -25722,7 +25878,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() {
@@ -25754,7 +25913,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) {
@@ -27152,7 +27311,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();
@@ -27169,12 +27331,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)
@@ -27240,12 +27399,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;
@@ -27290,6 +27450,7 @@ function hasModel(name) {
 }
 function clearModelRegistry() {
   modelRegistry.clear();
+  clearLocalModels();
 }
 function registerModel(name, model) {
   modelRegistry.set(name, model);
@@ -29065,7 +29226,7 @@ function detectTypeFromValidationRule(rule) {
   }
   return;
 }
-function normalizeAttributeType(value) {
+function normalizeAttributeType2(value) {
   if (typeof value !== "string")
     return;
   const type = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
@@ -29155,7 +29316,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)
@@ -32354,7 +32515,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.2.41";
+var version2 = "0.2.44";
 
 // bin/cli.ts
 init_actions();

package/dist/client.d.ts

@@ -2,7 +2,7 @@ import { config } from './config';
 import { resetConnection } from './db';
 import type { DatabaseSchema } from './schema';
 import type { DriverConnection } from './db';
-import type { QueryHooks } from './types';
+import type { QueryHooks, SupportedDialect } from './types';
 import type { SchemaMeta } from './meta';
 /**
  * # `raw`
@@ -31,6 +31,24 @@ import type { SchemaMeta } from './meta';
  * ```
  */
 export declare function raw(strings: TemplateStringsArray | string, ...values: unknown[]): RawExpression;
+/**
+ * Format a value for safe interpolation into a relationship-subquery
+ * fragment. Numbers / booleans / null pass through; everything else is
+ * rejected.
+ *
+ * **Strings are escaped for the configured dialect, not just for ANSI.**
+ * Doubling the single quote is correct on Postgres and SQLite and is not
+ * sufficient on the MySQL family, where a backslash is itself an escape
+ * character unless NO_BACKSLASH_ESCAPES is set. Doubling alone lets
+ * `x\'; DROP TABLE t; --` through: it becomes `'x\''; DROP TABLE t; --'`,
+ * MySQL reads `\'` as a literal quote inside the string, the next quote closes
+ * it, and the remainder executes as its own statement.
+ *
+ * So on a MySQL-like dialect the backslash is doubled first. Order matters:
+ * escaping quotes first and backslashes second would re-escape the backslash
+ * this function had just introduced.
+ */
+export declare function escapeStringLiteral(value: string, dialect?: SupportedDialect): string;
 // eslint-disable-next-line pickier/no-unused-vars
 export declare function createQueryBuilder<DB extends DatabaseSchema<any>>(state?: Partial<InternalState>): QueryBuilder<DB>;
 /**