prisma-sql 1.45.0 → 1.46.0

package/dist/generator.cjs

@@ -56,7 +56,7 @@ var require_package = __commonJS({
   "package.json"(exports$1, module) {
     module.exports = {
       name: "prisma-sql",
-      version: "1.45.0",
+      version: "1.46.0",
       description: "Convert Prisma queries to optimized SQL with type safety. 2-7x faster than Prisma Client.",
       main: "dist/index.cjs",
       module: "dist/index.js",
@@ -644,20 +644,21 @@ function isEmptyWhere(where) {
   if (!isNotNullish(where)) return true;
   return Object.keys(where).length === 0;
 }
+function sqlPreview(sql) {
+  const s = String(sql);
+  if (s.length <= 160) return s;
+  return `${s.slice(0, 160)}...`;
+}
 function validateSelectQuery(sql) {
   if (!hasValidContent(sql)) {
     throw new Error("CRITICAL: Generated empty SQL query");
   }
   if (!hasRequiredKeywords(sql)) {
-    throw new Error(
-      `CRITICAL: Invalid SQL structure. SQL: ${sql.substring(0, 100)}...`
-    );
+    throw new Error(`CRITICAL: Invalid SQL structure. SQL: ${sqlPreview(sql)}`);
   }
 }
-function sqlPreview(sql) {
-  return `${sql.substring(0, 100)}...`;
-}
-function parseDollarNumber(sql, start, n) {
+function parseDollarNumber(sql, start) {
+  const n = sql.length;
   let i = start;
   let num = 0;
   let hasDigit = false;
@@ -668,14 +669,14 @@ function parseDollarNumber(sql, start, n) {
     num = num * 10 + (c - 48);
     i++;
   }
-  if (!hasDigit || num <= 0) return { next: i, num: 0, ok: false };
-  return { next: i, num, ok: true };
+  if (!hasDigit || num <= 0) return { next: i, num: 0 };
+  return { next: i, num };
 }
 function scanDollarPlaceholders(sql, markUpTo) {
   const seen = new Uint8Array(markUpTo + 1);
-  let count = 0;
   let min = Number.POSITIVE_INFINITY;
   let max = 0;
+  let sawAny = false;
   const n = sql.length;
   let i = 0;
   while (i < n) {
@@ -683,15 +684,19 @@ function scanDollarPlaceholders(sql, markUpTo) {
       i++;
       continue;
     }
-    const { next, num, ok } = parseDollarNumber(sql, i + 1, n);
-    i = next;
-    if (!ok) continue;
-    count++;
+    const parsed = parseDollarNumber(sql, i + 1);
+    i = parsed.next;
+    const num = parsed.num;
+    if (num === 0) continue;
+    sawAny = true;
     if (num < min) min = num;
     if (num > max) max = num;
     if (num <= markUpTo) seen[num] = 1;
   }
-  return { count, min, max, seen };
+  if (!sawAny) {
+    return { min: 0, max: 0, seen, sawAny: false };
+  }
+  return { min, max, seen, sawAny: true };
 }
 function assertNoGapsDollar(scan, rangeMin, rangeMax, sql) {
   for (let k = rangeMin; k <= rangeMax; k++) {
@@ -704,124 +709,70 @@ function assertNoGapsDollar(scan, rangeMin, rangeMax, sql) {
 }
 function validateParamConsistency(sql, params) {
   const paramLen = params.length;
-  if (paramLen === 0) {
-    if (sql.indexOf("$") === -1) return;
-  }
   const scan = scanDollarPlaceholders(sql, paramLen);
-  if (scan.count === 0) {
-    if (paramLen !== 0) {
+  if (paramLen === 0) {
+    if (scan.sawAny) {
       throw new Error(
-        `CRITICAL: Parameter mismatch - SQL has no placeholders but ${paramLen} params provided.`
+        `CRITICAL: SQL contains placeholders but params is empty. SQL: ${sqlPreview(sql)}`
       );
     }
     return;
   }
-  if (scan.max !== paramLen) {
+  if (!scan.sawAny) {
     throw new Error(
-      `CRITICAL: Parameter mismatch - SQL max placeholder is $${scan.max} but ${paramLen} params provided. This will cause SQL execution to fail. SQL: ${sqlPreview(sql)}`
+      `CRITICAL: SQL is missing placeholders ($1..$${paramLen}) but params has length ${paramLen}. SQL: ${sqlPreview(sql)}`
     );
   }
-  assertNoGapsDollar(scan, 1, scan.max, sql);
-}
-function needsQuoting(id) {
-  if (!isNonEmptyString(id)) return true;
-  const isKeyword = SQL_KEYWORDS.has(id.toLowerCase());
-  if (isKeyword) return true;
-  const isValidIdentifier = REGEX_CACHE.VALID_IDENTIFIER.test(id);
-  return !isValidIdentifier;
-}
-function validateParamConsistencyFragment(sql, params) {
-  const paramLen = params.length;
-  const scan = scanDollarPlaceholders(sql, paramLen);
-  if (scan.max === 0) return;
-  if (scan.max > paramLen) {
+  if (scan.min !== 1) {
     throw new Error(
-      `CRITICAL: Parameter mismatch - SQL references $${scan.max} but only ${paramLen} params provided. SQL: ${sqlPreview(sql)}`
+      `CRITICAL: Placeholder range must start at $1, got min=$${scan.min}. SQL: ${sqlPreview(sql)}`
     );
   }
-  assertNoGapsDollar(scan, scan.min, scan.max, sql);
-}
-function assertOrThrow(condition, message) {
-  if (!condition) throw new Error(message);
-}
-function parseSqlitePlaceholderIndices(sql) {
-  const re = /\?(?:(\d+))?/g;
-  const indices = [];
-  let anonCount = 0;
-  let sawNumbered = false;
-  let sawAnonymous = false;
-  for (const m of sql.matchAll(re)) {
-    const n = m[1];
-    if (n) {
-      sawNumbered = true;
-      indices.push(parseInt(n, 10));
-    } else {
-      sawAnonymous = true;
-      anonCount += 1;
-      indices.push(anonCount);
-    }
+  if (scan.max !== paramLen) {
+    throw new Error(
+      `CRITICAL: Placeholder max must match params length. max=$${scan.max}, params=${paramLen}. SQL: ${sqlPreview(sql)}`
+    );
   }
-  return { indices, sawNumbered, sawAnonymous };
+  assertNoGapsDollar(scan, 1, paramLen, sql);
 }
-function maxIndex(indices) {
-  return indices.length > 0 ? Math.max(...indices) : 0;
+function countQuestionMarkPlaceholders(sql) {
+  const s = String(sql);
+  let count = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s.charCodeAt(i) === 63) count++;
+  }
+  return count;
 }
-function ensureSequentialIndices(seen, max, prefix) {
-  for (let i = 1; i <= max; i++) {
-    assertOrThrow(
-      seen.has(i),
-      `CRITICAL: Missing SQL placeholder ${prefix}${i} - placeholders must be sequential 1..${max}.`
+function validateQuestionMarkConsistency(sql, params) {
+  const expected = params.length;
+  const found = countQuestionMarkPlaceholders(sql);
+  if (expected !== found) {
+    throw new Error(
+      `CRITICAL: Parameter mismatch - expected ${expected} '?' placeholders, found ${found}. SQL: ${sqlPreview(sql)}`
     );
   }
 }
-function validateSqlitePlaceholders(sql, params) {
-  const paramLen = params.length;
-  const { indices, sawNumbered, sawAnonymous } = parseSqlitePlaceholderIndices(sql);
-  if (indices.length === 0) {
-    if (paramLen !== 0) {
-      throw new Error(
-        `CRITICAL: Parameter mismatch - SQL has no sqlite placeholders but ${paramLen} params provided. SQL: ${sqlPreview(sql)}`
-      );
-    }
+function validateParamConsistencyByDialect(sql, params, dialect) {
+  if (dialect === "postgres") {
+    validateParamConsistency(sql, params);
     return;
   }
-  assertOrThrow(
-    !(sawNumbered && sawAnonymous),
-    `CRITICAL: Mixed sqlite placeholders ('?' and '?NNN') are not supported.`
-  );
-  const max = maxIndex(indices);
-  assertOrThrow(
-    max === paramLen,
-    `CRITICAL: SQL placeholder max mismatch - max is ?${max}, but params length is ${paramLen}. SQL: ${sqlPreview(sql)}`
-  );
-  const set = new Set(indices);
-  ensureSequentialIndices(set, max, "?");
-}
-function validateDollarPlaceholders(sql, params) {
-  validateParamConsistency(sql, params);
-}
-function detectPlaceholderStyle(sql) {
-  const hasDollar = /\$\d+/.test(sql);
-  const hasSqliteQ = /\?(?:\d+)?/.test(sql);
-  return { hasDollar, hasSqliteQ };
-}
-function validateParamConsistencyByDialect(sql, params, dialect) {
-  const { hasDollar, hasSqliteQ } = detectPlaceholderStyle(sql);
-  if (dialect !== "sqlite") {
-    if (hasSqliteQ && !hasDollar) {
-      throw new Error(
-        `CRITICAL: Non-sqlite dialect query contains sqlite '?' placeholders. SQL: ${sqlPreview(sql)}`
-      );
-    }
-    return validateDollarPlaceholders(sql, params);
+  if (dialect === "sqlite") {
+    validateQuestionMarkConsistency(sql, params);
+    return;
   }
-  if (hasDollar && hasSqliteQ) {
-    throw new Error(
-      `CRITICAL: Mixed placeholder styles ($N and ?/ ?NNN) are not supported. SQL: ${sqlPreview(sql)}`
-    );
+  if (dialect === "mysql" || dialect === "mariadb") {
+    validateQuestionMarkConsistency(sql, params);
+    return;
   }
-  if (hasSqliteQ) return validateSqlitePlaceholders(sql, params);
-  return validateDollarPlaceholders(sql, params);
+  validateParamConsistency(sql, params);
+}
+function needsQuoting(identifier) {
+  const s = String(identifier);
+  if (!REGEX_CACHE.VALID_IDENTIFIER.test(s)) return true;
+  const lowered = s.toLowerCase();
+  if (SQL_KEYWORDS.has(lowered)) return true;
+  return false;
 }
 
 // src/builder/shared/sql-utils.ts
@@ -1320,6 +1271,40 @@ function ensureDeterministicOrderByInput(args) {
   return addIdTiebreaker(orderBy);
 }
 
+// src/builder/shared/validators/field-assertions.ts
+var NUMERIC_TYPES = /* @__PURE__ */ new Set(["Int", "Float", "Decimal", "BigInt"]);
+function assertScalarField(model, fieldName, context) {
+  const field = getFieldInfo(model, fieldName);
+  if (!field) {
+    throw createError(
+      `${context} references unknown field '${fieldName}' on model ${model.name}`,
+      {
+        field: fieldName,
+        modelName: model.name,
+        availableFields: model.fields.map((f) => f.name)
+      }
+    );
+  }
+  if (field.isRelation) {
+    throw createError(
+      `${context} does not support relation field '${fieldName}'`,
+      { field: fieldName, modelName: model.name }
+    );
+  }
+  return field;
+}
+function assertNumericField(model, fieldName, context) {
+  const field = assertScalarField(model, fieldName, context);
+  const baseType = field.type.replace(/\[\]|\?/g, "");
+  if (!NUMERIC_TYPES.has(baseType)) {
+    throw createError(
+      `${context} requires numeric field, got '${field.type}'`,
+      { field: fieldName, modelName: model.name }
+    );
+  }
+  return field;
+}
+
 // src/builder/pagination.ts
 var MAX_LIMIT_OFFSET = 2147483647;
 function parseDirectionRaw(raw, errorLabel) {
@@ -1360,38 +1345,31 @@ function parseOrderByValue(v, fieldName) {
   assertAllowedOrderByKeys(obj, fieldName);
   return { direction, nulls };
 }
-function normalizeFiniteInteger(name, v) {
-  if (typeof v !== "number" || !Number.isFinite(v) || !Number.isInteger(v)) {
-    throw new Error(`${name} must be an integer`);
-  }
-  return v;
-}
 function normalizeNonNegativeInt(name, v) {
   if (schemaParser.isDynamicParameter(v)) return v;
-  const n = normalizeFiniteInteger(name, v);
-  if (n < 0) {
-    throw new Error(`${name} must be >= 0`);
-  }
-  if (n > MAX_LIMIT_OFFSET) {
-    throw new Error(`${name} must be <= ${MAX_LIMIT_OFFSET}`);
-  }
-  return n;
-}
-function hasNonNullishProp(v, key) {
-  return isPlainObject(v) && key in v && isNotNullish(v[key]);
+  const result = normalizeIntLike(name, v, {
+    min: 0,
+    max: MAX_LIMIT_OFFSET,
+    allowZero: true
+  });
+  if (result === void 0)
+    throw new Error(`${name} normalization returned undefined`);
+  return result;
 }
-function normalizeIntegerOrDynamic(name, v) {
+function normalizeIntAllowNegative(name, v) {
   if (schemaParser.isDynamicParameter(v)) return v;
   const result = normalizeIntLike(name, v, {
     min: Number.MIN_SAFE_INTEGER,
     max: MAX_LIMIT_OFFSET,
     allowZero: true
   });
-  if (result === void 0) {
+  if (result === void 0)
     throw new Error(`${name} normalization returned undefined`);
-  }
   return result;
 }
+function hasNonNullishProp(v, key) {
+  return isPlainObject(v) && key in v && isNotNullish(v[key]);
+}
 function readSkipTake(relArgs) {
   const hasSkip = hasNonNullishProp(relArgs, "skip");
   const hasTake = hasNonNullishProp(relArgs, "take");
@@ -1405,7 +1383,7 @@ function readSkipTake(relArgs) {
   }
   const obj = relArgs;
   const skipVal = hasSkip ? normalizeNonNegativeInt("skip", obj.skip) : void 0;
-  const takeVal = hasTake ? normalizeIntegerOrDynamic("take", obj.take) : void 0;
+  const takeVal = hasTake ? normalizeIntAllowNegative("take", obj.take) : void 0;
   return { hasSkip, hasTake, skipVal, takeVal };
 }
 function buildOrderByFragment(entries, alias, dialect, model) {
@@ -1431,9 +1409,7 @@ function buildOrderByFragment(entries, alias, dialect, model) {
   return out.join(SQL_SEPARATORS.ORDER_BY);
 }
 function defaultNullsFor(dialect, direction) {
-  if (dialect === "postgres") {
-    return direction === "asc" ? "last" : "first";
-  }
+  if (dialect === "postgres") return direction === "asc" ? "last" : "first";
   return direction === "asc" ? "first" : "last";
 }
 function ensureCursorFieldsInOrder(orderEntries, cursorEntries) {
@@ -1450,9 +1426,8 @@ function ensureCursorFieldsInOrder(orderEntries, cursorEntries) {
 }
 function buildCursorFilterParts(cursor, cursorAlias, params, model) {
   const entries = Object.entries(cursor);
-  if (entries.length === 0) {
+  if (entries.length === 0)
     throw new Error("cursor must have at least one field");
-  }
   const placeholdersByField = /* @__PURE__ */ new Map();
   const parts = [];
   for (const [field, value] of entries) {
@@ -1506,25 +1481,29 @@ function buildOrderEntries(orderBy) {
       if (typeof value === "string") {
         entries.push({ field, direction: value });
       } else {
-        entries.push({
-          field,
-          direction: value.direction,
-          nulls: value.nulls
-        });
+        entries.push({ field, direction: value.direction, nulls: value.nulls });
       }
     }
   }
   return entries;
 }
 function buildCursorCteSelectList(cursorEntries, orderEntries, model) {
-  const set = /* @__PURE__ */ new Set();
-  for (const [f] of cursorEntries) set.add(f);
-  for (const e of orderEntries) set.add(e.field);
-  const cols = [...set].map((f) => quoteColumn(model, f));
-  if (cols.length === 0) {
-    throw new Error("cursor cte select list is empty");
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [];
+  for (const [f] of cursorEntries) {
+    if (!seen.has(f)) {
+      seen.add(f);
+      ordered.push(f);
+    }
   }
-  return cols.join(SQL_SEPARATORS.FIELD_LIST);
+  for (const e of orderEntries) {
+    if (!seen.has(e.field)) {
+      seen.add(e.field);
+      ordered.push(e.field);
+    }
+  }
+  if (ordered.length === 0) throw new Error("cursor cte select list is empty");
+  return ordered.map((f) => quoteColumn(model, f)).join(SQL_SEPARATORS.FIELD_LIST);
 }
 function truncateIdent(name, maxLen) {
   const s = String(name);
@@ -1544,19 +1523,22 @@ function buildCursorNames(outerAlias) {
   }
   return { cteName, srcAlias };
 }
+function assertCursorAndOrderFieldsScalar(model, cursor, orderEntries) {
+  if (!model) return;
+  for (const k of Object.keys(cursor)) assertScalarField(model, k, "cursor");
+  for (const e of orderEntries) assertScalarField(model, e.field, "orderBy");
+}
 function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect, model) {
   var _a;
   assertSafeTableRef(tableName);
   assertSafeAlias(alias);
   const d = dialect != null ? dialect : getGlobalDialect();
   const cursorEntries = Object.entries(cursor);
-  if (cursorEntries.length === 0) {
+  if (cursorEntries.length === 0)
     throw new Error("cursor must have at least one field");
-  }
   const { cteName, srcAlias } = buildCursorNames(alias);
   assertSafeAlias(cteName);
   assertSafeAlias(srcAlias);
-  const { whereSql: cursorWhereSql, placeholdersByField } = buildCursorFilterParts(cursor, srcAlias, params, model);
   const deterministicOrderBy = ensureDeterministicOrderByInput({
     orderBy,
     model,
@@ -1571,6 +1553,8 @@ function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect
   } else {
     orderEntries = ensureCursorFieldsInOrder(orderEntries, cursorEntries);
   }
+  assertCursorAndOrderFieldsScalar(model, cursor, orderEntries);
+  const { whereSql: cursorWhereSql, placeholdersByField } = buildCursorFilterParts(cursor, srcAlias, params, model);
   const cursorOrderBy = orderEntries.map(
     (e) => `${srcAlias}.${quoteColumn(model, e.field)} ${e.direction.toUpperCase()}`
   ).join(", ");
@@ -1593,9 +1577,7 @@ function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect
     params,
     model
   );
-  const getValueExpr = (field) => {
-    return `(SELECT ${quoteColumn(model, field)} FROM ${cteName})`;
-  };
+  const getValueExpr = (field) => `(SELECT ${quoteColumn(model, field)} FROM ${cteName})`;
   const orClauses = [];
   for (let level = 0; level < orderEntries.length; level++) {
     const andParts = [];
@@ -1639,9 +1621,7 @@ function normalizeTakeLike(v) {
     max: MAX_LIMIT_OFFSET,
     allowZero: true
   });
-  if (typeof n === "number") {
-    if (n === 0) return 0;
-  }
+  if (typeof n === "number" && n === 0) return 0;
   return n;
 }
 function normalizeSkipLike(v) {
@@ -2820,22 +2800,6 @@ function buildWhereClause(where, options) {
   };
   const result = whereBuilderInstance.build(where, ctx);
   const publicResult = toPublicResult(result.clause, result.joins, params);
-  if (!options.isSubquery) {
-    const nums = [...publicResult.clause.matchAll(/\$(\d+)/g)].map(
-      (m) => parseInt(m[1], 10)
-    );
-    if (nums.length > 0) {
-      const min = Math.min(...nums);
-      if (min === 1) {
-        validateParamConsistency(publicResult.clause, publicResult.params);
-      } else {
-        validateParamConsistencyFragment(
-          publicResult.clause,
-          publicResult.params
-        );
-      }
-    }
-  }
   return publicResult;
 }
 
@@ -3031,9 +2995,8 @@ function validateOrderByForModel(model, orderBy) {
       throw new Error("orderBy array entries must have exactly one field");
     }
     const fieldName = String(entries[0][0]).trim();
-    if (fieldName.length === 0) {
+    if (fieldName.length === 0)
       throw new Error("orderBy field name cannot be empty");
-    }
     if (!scalarSet.has(fieldName)) {
       throw new Error(
         `orderBy references unknown or non-scalar field '${fieldName}' on model ${model.name}`
@@ -3092,33 +3055,22 @@ function extractRelationPaginationConfig(relArgs) {
 function maybeReverseNegativeTake(takeVal, hasOrderBy, orderByInput) {
   if (typeof takeVal !== "number") return { takeVal, orderByInput };
   if (takeVal >= 0) return { takeVal, orderByInput };
-  if (!hasOrderBy) {
+  if (!hasOrderBy)
     throw new Error("Negative take requires orderBy for deterministic results");
-  }
   return {
     takeVal: Math.abs(takeVal),
     orderByInput: reverseOrderByInput(orderByInput)
   };
 }
-function ensureDeterministicOrderByForInclude(args) {
+function finalizeOrderByForInclude(args) {
+  if (args.hasOrderBy && isNotNullish(args.orderByInput)) {
+    validateOrderByForModel(args.relModel, args.orderByInput);
+  }
   if (!args.hasPagination) {
-    if (args.hasOrderBy && isNotNullish(args.orderByInput)) {
-      validateOrderByForModel(args.relModel, args.orderByInput);
-    }
     return args.orderByInput;
   }
-  if (!args.hasOrderBy) {
-    return ensureDeterministicOrderByInput({
-      orderBy: void 0,
-      model: args.relModel,
-      parseValue: parseOrderByValue
-    });
-  }
-  if (isNotNullish(args.orderByInput)) {
-    validateOrderByForModel(args.relModel, args.orderByInput);
-  }
   return ensureDeterministicOrderByInput({
-    orderBy: args.orderByInput,
+    orderBy: args.hasOrderBy ? args.orderByInput : void 0,
     model: args.relModel,
     parseValue: parseOrderByValue
   });
@@ -3222,11 +3174,7 @@ function buildListIncludeSpec(args) {
       joinPredicate: args.joinPredicate,
       whereClause: args.whereClause
     });
-    return Object.freeze({
-      name: args.relName,
-      sql: sql2,
-      isOneToOne: false
-    });
+    return Object.freeze({ name: args.relName, sql: sql2, isOneToOne: false });
   }
   const rowAlias = args.ctx.aliasGen.next(`${args.relName}_row`);
   let base = buildBaseSql({
@@ -3237,9 +3185,7 @@ function buildListIncludeSpec(args) {
     joinPredicate: args.joinPredicate,
     whereClause: args.whereClause
   });
-  if (args.orderBySql) {
-    base += ` ${SQL_TEMPLATES.ORDER_BY} ${args.orderBySql}`;
-  }
+  if (args.orderBySql) base += ` ${SQL_TEMPLATES.ORDER_BY} ${args.orderBySql}`;
   base = appendLimitOffset(
     base,
     args.ctx.dialect,
@@ -3250,11 +3196,7 @@ function buildListIncludeSpec(args) {
   );
   const selectExpr = jsonAgg("row", args.ctx.dialect);
   const sql = `${SQL_TEMPLATES.SELECT} ${selectExpr} ${SQL_TEMPLATES.FROM} (${base}) ${rowAlias}`;
-  return Object.freeze({
-    name: args.relName,
-    sql,
-    isOneToOne: false
-  });
+  return Object.freeze({ name: args.relName, sql, isOneToOne: false });
 }
 function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
   const relTable = getRelationTableReference(relModel, ctx.dialect);
@@ -3285,7 +3227,7 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
     paginationConfig.orderBy
   );
   const hasPagination = paginationConfig.hasSkip || paginationConfig.hasTake;
-  const finalOrderByInput = ensureDeterministicOrderByForInclude({
+  const finalOrderByInput = finalizeOrderByForInclude({
     relModel,
     hasOrderBy: paginationConfig.hasOrderBy,
     orderByInput: adjusted.orderByInput,
@@ -3311,11 +3253,7 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
       skipVal: paginationConfig.skipVal,
       ctx
     });
-    return Object.freeze({
-      name: relName,
-      sql,
-      isOneToOne: true
-    });
+    return Object.freeze({ name: relName, sql, isOneToOne: true });
   }
   return buildListIncludeSpec({
     relName,
@@ -3332,9 +3270,7 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
   });
 }
 function buildIncludeSqlInternal(args, model, schemas, parentAlias, aliasGen, params, dialect, visitPath = [], depth = 0, stats) {
-  if (!stats) {
-    stats = { totalIncludes: 0, totalSubqueries: 0, maxDepth: 0 };
-  }
+  if (!stats) stats = { totalIncludes: 0, totalSubqueries: 0, maxDepth: 0 };
   if (depth > MAX_INCLUDE_DEPTH) {
     throw new Error(
       `Maximum include depth of ${MAX_INCLUDE_DEPTH} exceeded. Path: ${visitPath.join(" -> ")}. Deep includes cause exponential SQL complexity and performance issues.`
@@ -3373,12 +3309,8 @@ function buildIncludeSqlInternal(args, model, schemas, parentAlias, aliasGen, pa
         `Include too deeply nested: model '${resolved.relModel.name}' appears ${modelOccurrences} times in path: ${currentPath.join(" -> ")}`
       );
     }
-    const include = buildSingleInclude(
-      relName,
-      relArgs,
-      resolved.field,
-      resolved.relModel,
-      {
+    includes.push(
+      buildSingleInclude(relName, relArgs, resolved.field, resolved.relModel, {
         model,
         schemas,
         parentAlias,
@@ -3388,9 +3320,8 @@ function buildIncludeSqlInternal(args, model, schemas, parentAlias, aliasGen, pa
         visitPath: currentPath,
         depth: depth + 1,
         stats
-      }
+      })
     );
-    includes.push(include);
   }
   return includes;
 }
@@ -3422,11 +3353,10 @@ function resolveCountRelationOrThrow(relName, model, schemas) {
     );
   }
   const field = model.fields.find((f) => f.name === relName);
-  if (!field) {
+  if (!field)
     throw new Error(
       `_count.${relName} references unknown relation on model ${model.name}`
     );
-  }
   if (!isValidRelationField(field)) {
     throw new Error(
       `_count.${relName} has invalid relation metadata on model ${model.name}`
@@ -3448,9 +3378,8 @@ function defaultReferencesForCount(fkCount) {
 }
 function resolveCountKeyPairs(field) {
   const fkFields = normalizeKeyList(field.foreignKey);
-  if (fkFields.length === 0) {
+  if (fkFields.length === 0)
     throw new Error("Relation count requires foreignKey");
-  }
   const refsRaw = field.references;
   const refs = normalizeKeyList(refsRaw);
   const refFields = refs.length > 0 ? refs : defaultReferencesForCount(fkFields.length);
@@ -3482,9 +3411,7 @@ function leftJoinOnForCount(args) {
 }
 function nextAliasAvoiding(aliasGen, base, forbidden) {
   let a = aliasGen.next(base);
-  while (forbidden.has(a)) {
-    a = aliasGen.next(base);
-  }
+  while (forbidden.has(a)) a = aliasGen.next(base);
   return a;
 }
 function buildCountJoinAndPair(args) {
@@ -3539,10 +3466,7 @@ function buildRelationCountSql(countSelect, model, schemas, parentAlias, _params
     joins.push(built.joinSql);
     pairs.push(built.pairSql);
   }
-  return {
-    joins,
-    jsonPairs: pairs.join(SQL_SEPARATORS.FIELD_LIST)
-  };
+  return { joins, jsonPairs: pairs.join(SQL_SEPARATORS.FIELD_LIST) };
 }
 
 // src/builder/select/assembly.ts
@@ -3578,7 +3502,11 @@ function buildSelectList(baseSelect, extraCols) {
 function finalizeSql(sql, params, dialect) {
   const snapshot = params.snapshot();
   validateSelectQuery(sql);
-  validateParamConsistencyByDialect(sql, snapshot.params, dialect);
+  validateParamConsistencyByDialect(
+    sql,
+    snapshot.params,
+    dialect === "sqlite" ? "postgres" : dialect
+  );
   return Object.freeze({
     sql,
     params: snapshot.params,
@@ -3872,40 +3800,6 @@ function constructFinalSql(spec) {
   return finalizeSql(sql, params, dialect);
 }
 
-// src/builder/shared/validators/field-assertions.ts
-var NUMERIC_TYPES = /* @__PURE__ */ new Set(["Int", "Float", "Decimal", "BigInt"]);
-function assertScalarField(model, fieldName, context) {
-  const field = getFieldInfo(model, fieldName);
-  if (!field) {
-    throw createError(
-      `${context} references unknown field '${fieldName}' on model ${model.name}`,
-      {
-        field: fieldName,
-        modelName: model.name,
-        availableFields: model.fields.map((f) => f.name)
-      }
-    );
-  }
-  if (field.isRelation) {
-    throw createError(
-      `${context} does not support relation field '${fieldName}'`,
-      { field: fieldName, modelName: model.name }
-    );
-  }
-  return field;
-}
-function assertNumericField(model, fieldName, context) {
-  const field = assertScalarField(model, fieldName, context);
-  const baseType = field.type.replace(/\[\]|\?/g, "");
-  if (!NUMERIC_TYPES.has(baseType)) {
-    throw createError(
-      `${context} requires numeric field, got '${field.type}'`,
-      { field: fieldName, modelName: model.name }
-    );
-  }
-  return field;
-}
-
 // src/builder/select.ts
 function normalizeOrderByInput2(orderBy) {
   return normalizeOrderByInput(orderBy, parseOrderByValue);
@@ -4159,6 +4053,19 @@ var HAVING_ALLOWED_OPS = /* @__PURE__ */ new Set([
 function isTruthySelection(v) {
   return v === true;
 }
+function isLogicalKey(key) {
+  return key === LogicalOps.AND || key === LogicalOps.OR || key === LogicalOps.NOT;
+}
+function isAggregateKey(key) {
+  return key === "_count" || key === "_sum" || key === "_avg" || key === "_min" || key === "_max";
+}
+function assertHavingOp(op) {
+  if (!HAVING_ALLOWED_OPS.has(op)) {
+    throw new Error(
+      `Unsupported HAVING operator '${op}'. Allowed: ${[...HAVING_ALLOWED_OPS].join(", ")}`
+    );
+  }
+}
 function aggExprForField(aggKey, field, alias, model) {
   if (aggKey === "_count") {
     return field === "_all" ? `COUNT(*)` : `COUNT(${col(alias, field, model)})`;
@@ -4192,18 +4099,9 @@ function normalizeLogicalValue2(operator, value) {
     }
     return out;
   }
-  if (isPlainObject(value)) {
-    return [value];
-  }
+  if (isPlainObject(value)) return [value];
   throw new Error(`${operator} must be an object or array of objects in HAVING`);
 }
-function assertHavingOp(op) {
-  if (!HAVING_ALLOWED_OPS.has(op)) {
-    throw new Error(
-      `Unsupported HAVING operator '${op}'. Allowed: ${[...HAVING_ALLOWED_OPS].join(", ")}`
-    );
-  }
-}
 function buildNullComparison(expr, op) {
   if (op === Ops.EQUALS) return `${expr} ${SQL_TEMPLATES.IS_NULL}`;
   if (op === Ops.NOT) return `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
@@ -4247,12 +4145,6 @@ function buildSimpleComparison(expr, op, val, params, dialect) {
   }
   return buildBinaryComparison(expr, op, val, params);
 }
-function isLogicalKey(key) {
-  return key === LogicalOps.AND || key === LogicalOps.OR || key === LogicalOps.NOT;
-}
-function isAggregateKey(key) {
-  return key === "_count" || key === "_sum" || key === "_avg" || key === "_min" || key === "_max";
-}
 function negateClauses(subClauses) {
   if (subClauses.length === 1) return `${SQL_TEMPLATES.NOT} ${subClauses[0]}`;
   return `${SQL_TEMPLATES.NOT} (${subClauses.join(SQL_SEPARATORS.CONDITION_AND)})`;
@@ -4261,50 +4153,10 @@ function combineLogical(key, subClauses) {
   if (key === LogicalOps.NOT) return negateClauses(subClauses);
   return subClauses.join(` ${key} `);
 }
-function buildLogicalClause2(key, value, alias, params, dialect, model) {
-  const items = normalizeLogicalValue2(key, value);
-  const subClauses = [];
-  for (const it of items) {
-    const c = buildHavingNode(it, alias, params, dialect, model);
-    if (c && c !== "") subClauses.push(`(${c})`);
-  }
-  if (subClauses.length === 0) return "";
-  return combineLogical(key, subClauses);
-}
-function buildHavingEntry(key, value, alias, params, dialect, model) {
-  if (isLogicalKey(key)) {
-    const logical = buildLogicalClause2(
-      key,
-      value,
-      alias,
-      params,
-      dialect,
-      model
-    );
-    return logical ? [logical] : [];
-  }
-  if (isAggregateKey(key)) {
-    return buildHavingForAggregateFirstShape(
-      key,
-      value,
-      alias,
-      params,
-      dialect,
-      model
-    );
-  }
-  return buildHavingForFieldFirstShape(
-    key,
-    value,
-    alias,
-    params,
-    dialect,
-    model
-  );
-}
 function buildHavingNode(node, alias, params, dialect, model) {
   const clauses = [];
-  for (const [key, value] of Object.entries(node)) {
+  const entries = Object.entries(node);
+  for (const [key, value] of entries) {
     const built = buildHavingEntry(key, value, alias, params, dialect, model);
     for (const c of built) {
       if (c && c.trim().length > 0) clauses.push(c);
@@ -4312,11 +4164,20 @@ function buildHavingNode(node, alias, params, dialect, model) {
   }
   return clauses.join(SQL_SEPARATORS.CONDITION_AND);
 }
+function buildLogicalClause2(key, value, alias, params, dialect, model) {
+  const items = normalizeLogicalValue2(key, value);
+  const subClauses = [];
+  for (const it of items) {
+    const c = buildHavingNode(it, alias, params, dialect, model);
+    if (c && c.trim().length > 0) subClauses.push(`(${c})`);
+  }
+  if (subClauses.length === 0) return "";
+  return combineLogical(key, subClauses);
+}
 function assertHavingAggTarget(aggKey, field, model) {
   if (field === "_all") {
-    if (aggKey !== "_count") {
+    if (aggKey !== "_count")
       throw new Error(`HAVING '${aggKey}' does not support '_all'`);
-    }
     return;
   }
   if (aggKey === "_sum" || aggKey === "_avg") {
@@ -4352,29 +4213,50 @@ function buildHavingForFieldFirstShape(fieldName, target, alias, params, dialect
   for (const aggKey of keys) {
     const aggFilter = obj[aggKey];
     if (!isPlainObject(aggFilter)) continue;
+    if (Object.keys(aggFilter).length === 0) continue;
     if (aggKey === "_sum" || aggKey === "_avg") {
       assertNumericField(model, fieldName, "HAVING");
     }
-    const entries = Object.entries(aggFilter);
-    if (entries.length === 0) continue;
     const expr = aggExprForField(aggKey, fieldName, alias, model);
-    const clauses = buildComparisons(
-      expr,
-      aggFilter,
+    out.push(...buildHavingOpsForExpr(expr, aggFilter, params, dialect));
+  }
+  return out;
+}
+function buildHavingEntry(key, value, alias, params, dialect, model) {
+  if (isLogicalKey(key)) {
+    const logical = buildLogicalClause2(
+      key,
+      value,
+      alias,
       params,
       dialect,
-      buildSimpleComparison
+      model
     );
-    out.push(...clauses);
+    return logical ? [logical] : [];
   }
-  return out;
+  if (isAggregateKey(key)) {
+    return buildHavingForAggregateFirstShape(
+      key,
+      value,
+      alias,
+      params,
+      dialect,
+      model
+    );
+  }
+  return buildHavingForFieldFirstShape(
+    key,
+    value,
+    alias,
+    params,
+    dialect,
+    model
+  );
 }
 function buildHavingClause(having, alias, params, model, dialect) {
   if (!isNotNullish(having)) return "";
   const d = dialect != null ? dialect : getGlobalDialect();
-  if (!isPlainObject(having)) {
-    throw new Error("having must be an object");
-  }
+  if (!isPlainObject(having)) throw new Error("having must be an object");
   return buildHavingNode(having, alias, params, d, model);
 }
 function normalizeCountArg(v) {
@@ -4388,9 +4270,6 @@ function pushCountAllField(fields) {
     `${SQL_TEMPLATES.COUNT_ALL} ${SQL_TEMPLATES.AS} ${quote("_count._all")}`
   );
 }
-function assertCountableScalarField(model, fieldName) {
-  assertScalarField(model, fieldName, "_count");
-}
 function pushCountField(fields, alias, fieldName, model) {
   const outAlias = `_count.${fieldName}`;
   fields.push(
@@ -4411,7 +4290,7 @@ function addCountFields(fields, countArg, alias, model) {
     ([f, v]) => f !== "_all" && isTruthySelection(v)
   );
   for (const [f] of selected) {
-    assertCountableScalarField(model, f);
+    assertScalarField(model, f, "_count");
     pushCountField(fields, alias, f, model);
   }
 }
@@ -4501,9 +4380,7 @@ function buildGroupBySelectParts(args, alias, model, byFields) {
 }
 function buildGroupByHaving(args, alias, params, model, dialect) {
   if (!isNotNullish(args.having)) return "";
-  if (!isPlainObject(args.having)) {
-    throw new Error("having must be an object");
-  }
+  if (!isPlainObject(args.having)) throw new Error("having must be an object");
   const h = buildHavingClause(args.having, alias, params, model, dialect);
   if (!h || h.trim().length === 0) return "";
   return `${SQL_TEMPLATES.HAVING} ${h}`;
@@ -4536,10 +4413,9 @@ function buildGroupBySql(args, whereResult, tableName, alias, model, dialect) {
   const snapshot = params.snapshot();
   validateSelectQuery(sql);
   validateParamConsistency(sql, [...whereResult.params, ...snapshot.params]);
-  const mergedParams = [...whereResult.params, ...snapshot.params];
   return Object.freeze({
     sql,
-    params: Object.freeze(mergedParams),
+    params: Object.freeze([...whereResult.params, ...snapshot.params]),
     paramMappings: Object.freeze([
       ...whereResult.paramMappings,
       ...snapshot.mappings
@@ -5081,34 +4957,39 @@ function normalizeQuery(args: any): string {
 
 function extractDynamicParams(args: any, dynamicKeys: string[]): unknown[] {
   const params: unknown[] = []
-  
+
   for (const key of dynamicKeys) {
     const parts = key.split(':')
     const lookupKey = parts.length === 2 ? parts[1] : key
-    const value = args[lookupKey]
-    
+
+    const value =
+      lookupKey.includes('.') ? getByPath(args, lookupKey) : args?.[lookupKey]
+
     if (value === undefined) {
       throw new Error(\`Missing required parameter: \${key}\`)
     }
-    
+
     params.push(normalizeValue(value))
   }
-  
+
   return params
 }
 
+
 async function executeQuery(client: any, sql: string, params: unknown[]): Promise<unknown[]> {
+  const normalizedParams = normalizeParams(params)
+
   if (DIALECT === 'postgres') {
-    return await client.unsafe(sql, params)
+    return await client.unsafe(sql, normalizedParams)
   }
-  
+
   const stmt = client.prepare(sql)
-  
+
   if (sql.toUpperCase().includes('COUNT(*) AS')) {
-    return [stmt.get(...params)]
+    return [stmt.get(...normalizedParams)]
   }
-  
-  return stmt.all(...params)
+
+  return stmt.all(...normalizedParams)
 }
 
 export function speedExtension(config: {
@@ -5153,18 +5034,21 @@ export function speedExtension(config: {
 
       if (prebakedQuery) {
         sql = prebakedQuery.sql
-        params = [...prebakedQuery.params, ...extractDynamicParams(transformedArgs, prebakedQuery.dynamicKeys)]
+        params = normalizeParams([
+          ...prebakedQuery.params,
+          ...extractDynamicParams(transformedArgs, prebakedQuery.dynamicKeys),
+        ])
         prebaked = true
       } else {
         const model = MODELS.find((m) => m.name === modelName)
-        
+
         if (!model) {
           return this.$parent[modelName][method](args)
         }
 
         const result = buildSQL(model, MODELS, method, transformedArgs, DIALECT)
         sql = result.sql
-        params = result.params
+        params = normalizeParams(result.params as unknown[])
       }
 
       if (debug) {