prisma-sql 1.58.0 → 1.59.0

package/dist/generator.js

@@ -54,7 +54,7 @@ var require_package = __commonJS({
   "package.json"(exports$1, module) {
     module.exports = {
       name: "prisma-sql",
-      version: "1.58.0",
+      version: "1.59.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",
@@ -295,7 +295,8 @@ var REGEX_CACHE = {
 var LIMITS = Object.freeze({
   MAX_QUERY_DEPTH: 50,
   MAX_ARRAY_SIZE: 1e4,
-  MAX_STRING_LENGTH: 1e4
+  MAX_STRING_LENGTH: 1e4,
+  MAX_HAVING_DEPTH: 50
 });
 
 // src/utils/normalize-value.ts
@@ -592,73 +593,6 @@ function createError(message, ctx, code = "VALIDATION_ERROR") {
   return new SqlBuilderError(parts.join("\n"), code, ctx);
 }
 
-// src/builder/shared/model-field-cache.ts
-var MODEL_CACHE = /* @__PURE__ */ new WeakMap();
-function quote(id) {
-  const needsQuoting2 = !/^[a-z_][a-z0-9_]*$/.test(id) || /^(select|from|where|having|order|group|limit|offset|join|inner|left|right|outer|cross|full|and|or|not|by|as|on|union|intersect|except|case|when|then|else|end|user|users|table|column|index|values|in|like|between|is|exists|null|true|false|all|any|some|update|insert|delete|create|drop|alter|truncate|grant|revoke|exec|execute)$/i.test(
-    id
-  );
-  if (needsQuoting2) {
-    return `"${id.replace(/"/g, '""')}"`;
-  }
-  return id;
-}
-function ensureFullCache(model) {
-  let cache = MODEL_CACHE.get(model);
-  if (!cache) {
-    const fieldInfo = /* @__PURE__ */ new Map();
-    const scalarFields = /* @__PURE__ */ new Set();
-    const relationFields = /* @__PURE__ */ new Set();
-    const columnMap = /* @__PURE__ */ new Map();
-    const fieldByName = /* @__PURE__ */ new Map();
-    const quotedColumns = /* @__PURE__ */ new Map();
-    for (const f of model.fields) {
-      const info = {
-        name: f.name,
-        dbName: f.dbName || f.name,
-        type: f.type,
-        isRelation: !!f.isRelation,
-        isRequired: !!f.isRequired
-      };
-      fieldInfo.set(f.name, info);
-      fieldByName.set(f.name, f);
-      if (info.isRelation) {
-        relationFields.add(f.name);
-      } else {
-        scalarFields.add(f.name);
-        const dbName = info.dbName;
-        columnMap.set(f.name, dbName);
-        quotedColumns.set(f.name, quote(dbName));
-      }
-    }
-    cache = {
-      fieldInfo,
-      scalarFields,
-      relationFields,
-      columnMap,
-      fieldByName,
-      quotedColumns
-    };
-    MODEL_CACHE.set(model, cache);
-  }
-  return cache;
-}
-function getFieldInfo(model, fieldName) {
-  return ensureFullCache(model).fieldInfo.get(fieldName);
-}
-function getScalarFieldSet(model) {
-  return ensureFullCache(model).scalarFields;
-}
-function getRelationFieldSet(model) {
-  return ensureFullCache(model).relationFields;
-}
-function getColumnMap(model) {
-  return ensureFullCache(model).columnMap;
-}
-function getQuotedColumn(model, fieldName) {
-  return ensureFullCache(model).quotedColumns.get(fieldName);
-}
-
 // src/builder/shared/validators/sql-validators.ts
 function isValidWhereClause(clause) {
   return isNotNullish(clause) && clause.trim().length > 0 && clause !== DEFAULT_WHERE_CLAUSE;
@@ -802,6 +736,78 @@ function needsQuoting(identifier) {
   return false;
 }
 
+// src/builder/shared/model-field-cache.ts
+var MODEL_CACHE = /* @__PURE__ */ new WeakMap();
+function quoteIdent(id) {
+  if (typeof id !== "string" || id.trim().length === 0) {
+    throw new Error("quoteIdent: identifier is required and cannot be empty");
+  }
+  if (/[\u0000-\u001F\u007F]/.test(id)) {
+    throw new Error(
+      `quoteIdent: identifier contains invalid characters: ${JSON.stringify(id)}`
+    );
+  }
+  if (needsQuoting(id)) {
+    return `"${id.replace(/"/g, '""')}"`;
+  }
+  return id;
+}
+function ensureFullCache(model) {
+  let cache = MODEL_CACHE.get(model);
+  if (!cache) {
+    const fieldInfo = /* @__PURE__ */ new Map();
+    const scalarFields = /* @__PURE__ */ new Set();
+    const relationFields = /* @__PURE__ */ new Set();
+    const columnMap = /* @__PURE__ */ new Map();
+    const fieldByName = /* @__PURE__ */ new Map();
+    const quotedColumns = /* @__PURE__ */ new Map();
+    for (const f of model.fields) {
+      const info = {
+        name: f.name,
+        dbName: f.dbName || f.name,
+        type: f.type,
+        isRelation: !!f.isRelation,
+        isRequired: !!f.isRequired
+      };
+      fieldInfo.set(f.name, info);
+      fieldByName.set(f.name, f);
+      if (info.isRelation) {
+        relationFields.add(f.name);
+      } else {
+        scalarFields.add(f.name);
+        const dbName = info.dbName;
+        columnMap.set(f.name, dbName);
+        quotedColumns.set(f.name, quoteIdent(dbName));
+      }
+    }
+    cache = {
+      fieldInfo,
+      scalarFields,
+      relationFields,
+      columnMap,
+      fieldByName,
+      quotedColumns
+    };
+    MODEL_CACHE.set(model, cache);
+  }
+  return cache;
+}
+function getFieldInfo(model, fieldName) {
+  return ensureFullCache(model).fieldInfo.get(fieldName);
+}
+function getScalarFieldSet(model) {
+  return ensureFullCache(model).scalarFields;
+}
+function getRelationFieldSet(model) {
+  return ensureFullCache(model).relationFields;
+}
+function getColumnMap(model) {
+  return ensureFullCache(model).columnMap;
+}
+function getQuotedColumn(model, fieldName) {
+  return ensureFullCache(model).quotedColumns.get(fieldName);
+}
+
 // src/builder/shared/sql-utils.ts
 function containsControlChars(s) {
   return /[\u0000-\u001F\u007F]/.test(s);
@@ -944,7 +950,7 @@ function assertSafeQualifiedName(input) {
     }
   }
 }
-function quote2(id) {
+function quote(id) {
   if (isEmptyString(id)) {
     throw new Error("quote: identifier is required and cannot be empty");
   }
@@ -964,13 +970,13 @@ function resolveColumnName(model, fieldName) {
   return columnMap.get(fieldName) || fieldName;
 }
 function quoteColumn(model, fieldName) {
-  if (!model) return quote2(fieldName);
+  if (!model) return quote(fieldName);
   const cached = getQuotedColumn(model, fieldName);
-  return cached || quote2(fieldName);
+  return cached || quote(fieldName);
 }
 function col(alias, field, model) {
   const columnName = model ? getColumnMap(model).get(field) || field : field;
-  const quoted = model ? getQuotedColumn(model, field) || quote2(columnName) : quote2(columnName);
+  const quoted = model ? getQuotedColumn(model, field) || quote(columnName) : quote(columnName);
   return alias + "." + quoted;
 }
 function colWithAlias(alias, field, model) {
@@ -981,9 +987,9 @@ function colWithAlias(alias, field, model) {
     throw new Error("colWithAlias: field is required and cannot be empty");
   }
   const columnName = resolveColumnName(model, field);
-  const columnRef = alias + "." + (model ? getQuotedColumn(model, field) || quote2(columnName) : quote2(columnName));
+  const columnRef = alias + "." + (model ? getQuotedColumn(model, field) || quote(columnName) : quote(columnName));
   if (columnName !== field) {
-    return columnRef + " AS " + quote2(field);
+    return columnRef + " AS " + quote(field);
   }
   return columnRef;
 }
@@ -1006,7 +1012,7 @@ function buildTableReference(schemaName, tableName, dialect) {
   }
   const d = dialect != null ? dialect : "postgres";
   if (d === "sqlite") {
-    return quote2(tableName);
+    return quote(tableName);
   }
   if (isEmptyString(schemaName)) {
     throw new Error(
@@ -1671,6 +1677,7 @@ function buildOrderEntries(orderBy) {
   }
   return entries;
 }
+var MAX_NOT_DEPTH = 50;
 function buildNotComposite(expr, val, params, dialect, buildOp, separator) {
   const entries = Object.entries(val).filter(
     ([k, v]) => k !== "mode" && v !== void 0
@@ -1685,13 +1692,18 @@ function buildNotComposite(expr, val, params, dialect, buildOp, separator) {
   if (clauses.length === 1) return `${SQL_TEMPLATES.NOT} ${clauses[0]}`;
   return `${SQL_TEMPLATES.NOT} (${clauses.join(separator)})`;
 }
-function buildScalarOperator(expr, op, val, params, mode, fieldType, dialect) {
+function buildScalarOperator(expr, op, val, params, mode, fieldType, dialect, depth = 0) {
   if (val === void 0) return "";
+  if (depth > MAX_NOT_DEPTH) {
+    throw new Error(
+      `NOT operator nesting too deep (max ${MAX_NOT_DEPTH} levels). This usually indicates a circular reference or adversarial input.`
+    );
+  }
   if (val === null) {
     return handleNullValue(expr, op);
   }
   if (op === Ops.NOT && isPlainObject(val)) {
-    return handleNotOperator(expr, val, params, mode, fieldType, dialect);
+    return handleNotOperator(expr, val, params, mode, fieldType, dialect, depth);
   }
   if (op === Ops.NOT) {
     const placeholder = params.addAuto(val);
@@ -1737,7 +1749,7 @@ function normalizeMode(v) {
   if (v === Modes.DEFAULT) return Modes.DEFAULT;
   return void 0;
 }
-function handleNotOperator(expr, val, params, outerMode, fieldType, dialect) {
+function handleNotOperator(expr, val, params, outerMode, fieldType, dialect, depth = 0) {
   const innerMode = normalizeMode(val.mode);
   const effectiveMode = innerMode != null ? innerMode : outerMode;
   const entries = Object.entries(val).filter(
@@ -1754,7 +1766,8 @@ function handleNotOperator(expr, val, params, outerMode, fieldType, dialect) {
         params,
         effectiveMode,
         fieldType,
-        void 0
+        void 0,
+        depth + 1
       );
       if (sub && sub.trim().length > 0) clauses.push(`(${sub})`);
     }
@@ -1767,23 +1780,20 @@ function handleNotOperator(expr, val, params, outerMode, fieldType, dialect) {
     val,
     params,
     dialect,
-    (e, subOp, subVal, p, d) => buildScalarOperator(e, subOp, subVal, p, effectiveMode, fieldType, d),
+    (e, subOp, subVal, p, d) => buildScalarOperator(
+      e,
+      subOp,
+      subVal,
+      p,
+      effectiveMode,
+      fieldType,
+      d,
+      depth + 1
+    ),
     ` ${SQL_TEMPLATES.AND} `
   );
 }
-function buildDynamicLikePattern(op, placeholder, dialect) {
-  if (dialect === "postgres") {
-    switch (op) {
-      case Ops.CONTAINS:
-        return `('%' || ${placeholder} || '%')`;
-      case Ops.STARTS_WITH:
-        return `(${placeholder} || '%')`;
-      case Ops.ENDS_WITH:
-        return `('%' || ${placeholder})`;
-      default:
-        return placeholder;
-    }
-  }
+function buildDynamicLikePattern(op, placeholder) {
   switch (op) {
     case Ops.CONTAINS:
       return `('%' || ${placeholder} || '%')`;
@@ -1799,7 +1809,7 @@ function handleLikeOperator(expr, op, val, params, mode, dialect) {
   if (val === void 0) return "";
   if (isDynamicParameter(val)) {
     const placeholder2 = params.addAuto(val);
-    const patternExpr = buildDynamicLikePattern(op, placeholder2, dialect);
+    const patternExpr = buildDynamicLikePattern(op, placeholder2);
     if (mode === Modes.INSENSITIVE) {
       return caseInsensitiveLike(expr, patternExpr, dialect);
     }
@@ -2085,7 +2095,7 @@ function freezeJoins(items) {
 function isListRelation(fieldType) {
   return typeof fieldType === "string" && fieldType.endsWith("[]");
 }
-function buildToOneNullCheck(field, parentAlias, relTable, relAlias, join3, wantNull) {
+function buildToOneNullCheck(field, parentModel, parentAlias, relTable, relAlias, join3, wantNull) {
   const isLocal = field.isForeignKeyLocal === true;
   const fkFields = normalizeKeyList(field.foreignKey);
   if (isLocal) {
@@ -2095,8 +2105,7 @@ function buildToOneNullCheck(field, parentAlias, relTable, relAlias, join3, want
       });
     }
     const parts = fkFields.map((fk) => {
-      const safe = fk.replace(/"/g, '""');
-      const expr = `${parentAlias}."${safe}"`;
+      const expr = `${parentAlias}.${quoteColumn(parentModel, fk)}`;
       return wantNull ? `${expr} ${SQL_TEMPLATES.IS_NULL}` : `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
     });
     if (parts.length === 1) return parts[0];
@@ -2141,7 +2150,7 @@ function buildListRelationFilters(args) {
       ) || relModel.fields.find((f) => !f.isRelation && f.name === "id");
       if (checkField) {
         const leftJoinSql = `LEFT JOIN ${relTable} ${relAlias} ON ${join3}`;
-        const whereClause = `${relAlias}.${quote2(checkField.name)} IS NULL`;
+        const whereClause = `${relAlias}.${quote(checkField.name)} IS NULL`;
         return Object.freeze({
           clause: whereClause,
           joins: freezeJoins([leftJoinSql])
@@ -2234,6 +2243,7 @@ function buildToOneRelationFilters(args) {
     const wantNull = filterKey === "is";
     const clause2 = buildToOneNullCheck(
       field,
+      ctx.model,
       ctx.alias,
       relTable,
       relAlias,
@@ -2463,7 +2473,8 @@ function buildWhereInternal(where, ctx, builder) {
   }
   const allJoins = [];
   const clauses = [];
-  for (const [key, value] of Object.entries(where)) {
+  for (const key in where) {
+    const value = where[key];
     if (value === void 0) continue;
     const result = buildWhereEntry(key, value, ctx, builder);
     appendResult(result, clauses, allJoins);
@@ -2713,8 +2724,6 @@ function createStoreInternal(startIndex, initialParams = [], initialMappings = [
   }
   let dirty = true;
   let cachedSnapshot = null;
-  let frozenParams = null;
-  let frozenMappings = null;
   function assertCanAdd() {
     if (index > MAX_PARAM_INDEX) {
       throw new Error(
@@ -2766,17 +2775,13 @@ function createStoreInternal(startIndex, initialParams = [], initialMappings = [
   }
   function snapshot() {
     if (!dirty && cachedSnapshot) return cachedSnapshot;
-    if (!frozenParams) frozenParams = Object.freeze(params.slice());
-    if (!frozenMappings) frozenMappings = Object.freeze(mappings.slice());
     const snap = {
       index,
-      params: frozenParams,
-      mappings: frozenMappings
+      params: params.slice(),
+      mappings: mappings.slice()
     };
     cachedSnapshot = snap;
     dirty = false;
-    frozenParams = null;
-    frozenMappings = null;
     return snap;
   }
   return {
@@ -3706,7 +3711,7 @@ function buildDistinctColumns(distinct, fromAlias, model) {
 }
 function buildOutputColumns(scalarNames, includeNames, hasCount) {
   const outputCols = hasCount ? [...scalarNames, ...includeNames, "_count"] : [...scalarNames, ...includeNames];
-  const formatted = outputCols.map((n) => quote2(n)).join(SQL_SEPARATORS.FIELD_LIST);
+  const formatted = outputCols.map((n) => quote(n)).join(SQL_SEPARATORS.FIELD_LIST);
   if (!isNonEmptyString(formatted)) {
     throw new Error("distinct emulation requires at least one output column");
   }
@@ -3802,7 +3807,7 @@ function buildIncludeColumns(spec) {
         dialect
       );
       if (countBuild.jsonPairs) {
-        countCols = jsonBuildObject(countBuild.jsonPairs, dialect) + " " + SQL_TEMPLATES.AS + " " + quote2("_count");
+        countCols = jsonBuildObject(countBuild.jsonPairs, dialect) + " " + SQL_TEMPLATES.AS + " " + quote("_count");
       }
       countJoins = countBuild.joins;
     }
@@ -3815,7 +3820,7 @@ function buildIncludeColumns(spec) {
   const emptyJson = dialect === "postgres" ? `'[]'::json` : `json('[]')`;
   const includeCols = hasIncludes ? includes.map((inc) => {
     const expr = inc.isOneToOne ? "(" + inc.sql + ")" : "COALESCE((" + inc.sql + "), " + emptyJson + ")";
-    return expr + " " + SQL_TEMPLATES.AS + " " + quote2(inc.name);
+    return expr + " " + SQL_TEMPLATES.AS + " " + quote(inc.name);
   }).join(SQL_SEPARATORS.FIELD_LIST) : "";
   const allCols = joinNonEmpty(
     [includeCols, countCols],
@@ -4180,6 +4185,7 @@ function buildComparisons(expr, filter, params, dialect, builder, excludeKeys =
 }
 
 // src/builder/aggregates.ts
+var MAX_NOT_DEPTH2 = 50;
 var AGGREGATES = [
   ["_sum", "SUM"],
   ["_avg", "AVG"],
@@ -4294,8 +4300,13 @@ function buildBinaryComparison(expr, op, val, params) {
   const placeholder = addHavingParam(params, op, val);
   return expr + " " + sqlOp + " " + placeholder;
 }
-function buildSimpleComparison(expr, op, val, params, dialect) {
+function buildSimpleComparison(expr, op, val, params, dialect, depth = 0) {
   assertHavingOp(op);
+  if (depth > MAX_NOT_DEPTH2) {
+    throw new Error(
+      `NOT operator nesting too deep in HAVING (max ${MAX_NOT_DEPTH2} levels).`
+    );
+  }
   if (val === null) return buildNullComparison(expr, op);
   if (op === Ops.NOT && isPlainObject(val)) {
     return buildNotComposite(
@@ -4303,7 +4314,7 @@ function buildSimpleComparison(expr, op, val, params, dialect) {
       val,
       params,
       dialect,
-      buildSimpleComparison,
+      (e, subOp, subVal, p, d) => buildSimpleComparison(e, subOp, subVal, p, d, depth + 1),
       SQL_SEPARATORS.CONDITION_AND
     );
   }
@@ -4320,23 +4331,36 @@ function combineLogical(key, subClauses) {
   if (key === LogicalOps.NOT) return negateClauses(subClauses);
   return subClauses.join(" " + key + " ");
 }
-function buildHavingNode(node, alias, params, dialect, model) {
+function buildHavingNode(node, alias, params, dialect, model, depth = 0) {
+  if (depth > LIMITS.MAX_HAVING_DEPTH) {
+    throw new Error(
+      `HAVING clause nesting too deep (max ${LIMITS.MAX_HAVING_DEPTH} levels). This usually indicates a circular reference.`
+    );
+  }
   const clauses = [];
   for (const key in node) {
     if (!Object.prototype.hasOwnProperty.call(node, key)) continue;
     const value = node[key];
-    const built = buildHavingEntry(key, value, alias, params, dialect, model);
+    const built = buildHavingEntry(
+      key,
+      value,
+      alias,
+      params,
+      dialect,
+      model,
+      depth
+    );
     for (const c of built) {
       if (c && c.length > 0) clauses.push(c);
     }
   }
   return clauses.join(SQL_SEPARATORS.CONDITION_AND);
 }
-function buildLogicalClause2(key, value, alias, params, dialect, model) {
+function buildLogicalClause2(key, value, alias, params, dialect, model, depth = 0) {
   const items = normalizeLogicalValue2(key, value);
   const subClauses = [];
   for (const it of items) {
-    const c = buildHavingNode(it, alias, params, dialect, model);
+    const c = buildHavingNode(it, alias, params, dialect, model, depth + 1);
     if (c && c.length > 0) subClauses.push("(" + c + ")");
   }
   if (subClauses.length === 0) return "";
@@ -4395,7 +4419,7 @@ function buildHavingForFieldFirstShape(fieldName, target, alias, params, dialect
   }
   return out;
 }
-function buildHavingEntry(key, value, alias, params, dialect, model) {
+function buildHavingEntry(key, value, alias, params, dialect, model, depth = 0) {
   if (isLogicalKey(key)) {
     const logical = buildLogicalClause2(
       key,
@@ -4403,7 +4427,8 @@ function buildHavingEntry(key, value, alias, params, dialect, model) {
       alias,
       params,
       dialect,
-      model
+      model,
+      depth
     );
     return logical ? [logical] : [];
   }
@@ -4430,7 +4455,7 @@ 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");
-  return buildHavingNode(having, alias, params, d, model);
+  return buildHavingNode(having, alias, params, d, model, 0);
 }
 function normalizeCountArg(v) {
   if (!isNotNullish(v)) return void 0;
@@ -4440,13 +4465,13 @@ function normalizeCountArg(v) {
 }
 function pushCountAllField(fields) {
   fields.push(
-    SQL_TEMPLATES.COUNT_ALL + " " + SQL_TEMPLATES.AS + " " + quote2("_count._all")
+    SQL_TEMPLATES.COUNT_ALL + " " + SQL_TEMPLATES.AS + " " + quote("_count._all")
   );
 }
 function pushCountField(fields, alias, fieldName, model) {
   const outAlias = "_count." + fieldName;
   fields.push(
-    "COUNT(" + col(alias, fieldName, model) + ") " + SQL_TEMPLATES.AS + " " + quote2(outAlias)
+    "COUNT(" + col(alias, fieldName, model) + ") " + SQL_TEMPLATES.AS + " " + quote(outAlias)
   );
 }
 function addCountFields(fields, countArg, alias, model) {
@@ -4483,7 +4508,7 @@ function assertAggregatableScalarField(model, agg, fieldName) {
 function pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName, model) {
   const outAlias = agg + "." + fieldName;
   fields.push(
-    aggFn + "(" + col(alias, fieldName, model) + ") " + SQL_TEMPLATES.AS + " " + quote2(outAlias)
+    aggFn + "(" + col(alias, fieldName, model) + ") " + SQL_TEMPLATES.AS + " " + quote(outAlias)
   );
 }
 function addAggregateFields(fields, args, alias, model) {
@@ -4567,7 +4592,7 @@ function buildGroupBySql(args, whereResult, tableName, alias, model, dialect) {
   assertSafeAlias(alias);
   assertSafeTableRef(tableName);
   const byFields = assertGroupByBy(args, model);
-  const d = getGlobalDialect();
+  const d = dialect != null ? dialect : getGlobalDialect();
   const params = createParamStore(whereResult.nextParamIndex);
   const { groupFields, selectFields } = buildGroupBySelectParts(
     args,
@@ -4630,7 +4655,7 @@ function buildCountSql(whereResult, tableName, alias, skip, _dialect) {
     SQL_TEMPLATES.SELECT,
     SQL_TEMPLATES.COUNT_ALL,
     SQL_TEMPLATES.AS,
-    quote2("_count._all"),
+    quote("_count._all"),
     SQL_TEMPLATES.FROM,
     tableName,
     alias
@@ -4671,15 +4696,21 @@ function buildSqlResult(args) {
     return buildAggregateSql(processed, whereResult, tableName, alias, modelDef);
   }
   if (method === "groupBy") {
-    return buildGroupBySql(processed, whereResult, tableName, alias, modelDef);
+    return buildGroupBySql(
+      processed,
+      whereResult,
+      tableName,
+      alias,
+      modelDef,
+      dialect
+    );
   }
   if (method === "count") {
     return buildCountSql(
       whereResult,
       tableName,
       alias,
-      processed.skip
-    );
+      processed.skip);
   }
   return buildSelectSql({
     method,
@@ -4719,22 +4750,23 @@ function normalizeSqlAndMappingsForDialect(sql, paramMappings, dialect) {
 }
 function buildParamsFromMappings(mappings) {
   const sorted = [...mappings].sort((a, b) => a.index - b.index);
-  return sorted.reduce(
-    (acc, m) => {
-      if (m.dynamicName !== void 0) {
-        acc.dynamicKeys.push(m.dynamicName);
-        return acc;
-      }
-      if (m.value !== void 0) {
-        acc.staticParams.push(m.value);
-        return acc;
-      }
+  const staticParams = [];
+  const dynamicKeys = [];
+  let paramOrder = "";
+  for (const m of sorted) {
+    if (m.dynamicName !== void 0) {
+      dynamicKeys.push(m.dynamicName);
+      paramOrder += "d";
+    } else if (m.value !== void 0) {
+      staticParams.push(m.value);
+      paramOrder += "s";
+    } else {
       throw new Error(
         `CRITICAL: ParamMap ${m.index} has neither dynamicName nor value`
       );
-    },
-    { staticParams: [], dynamicKeys: [] }
-  );
+    }
+  }
+  return { staticParams, dynamicKeys, paramOrder };
 }
 function resolveModelContext(directive) {
   const { model, datamodel } = directive.context;
@@ -4800,12 +4832,13 @@ function finalizeDirective(args) {
     return (_a = m.value) != null ? _a : void 0;
   });
   validateParamConsistencyByDialect(normalizedSql, params, dialect);
-  const { staticParams, dynamicKeys } = buildParamsFromMappings(normalizedMappings);
+  const { staticParams, dynamicKeys, paramOrder } = buildParamsFromMappings(normalizedMappings);
   return {
     method: directive.method,
     sql: normalizedSql,
     staticParams,
     dynamicKeys,
+    paramOrder,
     paramMappings: normalizedMappings,
     originalDirective: directive
   };
@@ -4944,6 +4977,7 @@ function generateCode(models, queries, dialect, datamodel) {
   const { mappings, fieldTypes } = extractEnumMappings(datamodel);
   return `// Generated by @prisma-sql/generator - DO NOT EDIT
 import { buildSQL, buildBatchSql, parseBatchResults, buildBatchCountSql, parseBatchCountResults, createTransactionExecutor, transformQueryResults, type PrismaMethod, type Model, type BatchQuery, type BatchCountQuery, type TransactionQuery, type TransactionOptions } from 'prisma-sql'
+import { normalizeValue } from 'prisma-sql/utils/normalize-value'
 
 class DeferredQuery {
   constructor(
@@ -4985,14 +5019,12 @@ function createBatchProxy(): BatchProxy {
     {
       get(_target, modelName: string): any {
         if (typeof modelName === 'symbol') return undefined
-
         const model = MODEL_MAP.get(modelName)
         if (!model) {
           throw new Error(
             \`Model '\${modelName}' not found. Available: \${[...MODEL_MAP.keys()].join(', ')}\`,
           )
         }
-
         return new Proxy(
           {},
           {
@@ -5002,7 +5034,6 @@ function createBatchProxy(): BatchProxy {
                   \`Method '\${method}' not supported in batch. Supported: \${[...ACCELERATED_METHODS].join(', ')}\`,
                 )
               }
-
               return (args?: any): DeferredQuery => {
                 return new DeferredQuery(
                   modelName,
@@ -5018,52 +5049,6 @@ function createBatchProxy(): BatchProxy {
   ) as BatchProxy
 }
 
-function normalizeValue(value: unknown, seen = new WeakSet<object>(), depth = 0): unknown {
-  const MAX_DEPTH = 20
-  if (depth > MAX_DEPTH) {
-    throw new Error(\`Max normalization depth exceeded (\${MAX_DEPTH} levels)\`)
-  }
-  if (value instanceof Date) {
-    const t = value.getTime()
-    if (!Number.isFinite(t)) {
-      throw new Error('Invalid Date value in SQL params')
-    }
-    return value.toISOString()
-  }
-  if (typeof value === 'bigint') {
-    return value.toString()
-  }
-  if (Array.isArray(value)) {
-    const arrRef = value as unknown as object
-    if (seen.has(arrRef)) {
-      throw new Error('Circular reference in SQL params')
-    }
-    seen.add(arrRef)
-    const out = value.map((v) => normalizeValue(v, seen, depth + 1))
-    seen.delete(arrRef)
-    return out
-  }
-  if (value && typeof value === 'object') {
-    if (value instanceof Uint8Array) return value
-    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) return value
-    const proto = Object.getPrototypeOf(value)
-    const isPlain = proto === Object.prototype || proto === null
-    if (!isPlain) return value
-    const obj = value as Record<string, unknown>
-    if (seen.has(obj)) {
-      throw new Error('Circular reference in SQL params')
-    }
-    seen.add(obj)
-    const out: Record<string, unknown> = {}
-    for (const [k, v] of Object.entries(obj)) {
-      out[k] = normalizeValue(v, seen, depth + 1)
-    }
-    seen.delete(obj)
-    return out
-  }
-  return value
-}
-
 function normalizeParams(params: unknown[]): unknown[] {
   return params.map(p => normalizeValue(p))
 }
@@ -5153,19 +5138,16 @@ function transformEnumValuesByModel(modelName: string, obj: any, path: string[]
   if (typeof obj === 'object') {
     const transformed: any = {}
     const modelFields = ENUM_FIELDS[modelName] || {}
-
     for (const [key, value] of Object.entries(obj)) {
       const nextPath = [...path, key]
 
       const relModel = getRelatedModelName(modelName, key)
-
       if (relModel && value && typeof value === 'object') {
         transformed[key] = transformEnumValuesByModel(relModel, value, nextPath)
         continue
       }
 
       const enumType = modelFields[key]
-
       if (enumType) {
         if (value && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
           const transformedOperators: any = {}
@@ -5184,25 +5166,27 @@ function transformEnumValuesByModel(modelName: string, obj: any, path: string[]
         transformed[key] = value
       }
     }
-
     return transformed
   }
 
   return obj
 }
 
+function bigIntSafeReplacer(_key: string, value: unknown): unknown {
+  if (typeof value === 'bigint') return '__bigint__' + value.toString()
+  return value
+}
+
 function normalizeQuery(args: any): string {
   if (!args) return '{}'
-
-  const normalized = JSON.parse(JSON.stringify(args))
+  const jsonStr = JSON.stringify(args, bigIntSafeReplacer)
+  const normalized = JSON.parse(jsonStr)
 
   function replaceDynamicParams(obj: any, path: string[] = []): any {
     if (!obj || typeof obj !== 'object') return obj
-
     if (Array.isArray(obj)) {
       return obj.map((v) => replaceDynamicParams(v, path))
     }
-
     const result: any = {}
     for (const [key, value] of Object.entries(obj)) {
       if (isDynamicKeyForQueryKey(path, key)) {
@@ -5218,7 +5202,6 @@ function normalizeQuery(args: any): string {
 
   function removeEmptyObjects(obj: any): any {
     if (!obj || typeof obj !== 'object' || Array.isArray(obj)) return obj
-
     const result: any = {}
     for (const [key, value] of Object.entries(obj)) {
       if (value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0) {
@@ -5232,6 +5215,7 @@ function normalizeQuery(args: any): string {
   const cleaned = removeEmptyObjects(withMarkers)
 
   return JSON.stringify(cleaned, (key, value) => {
+    if (typeof value === 'bigint') return '__bigint__' + value.toString()
     if (value && typeof value === 'object' && !Array.isArray(value)) {
       const sorted: Record<string, unknown> = {}
       for (const k of Object.keys(value).sort()) {
@@ -5245,37 +5229,28 @@ 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 =
       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, normalizedParams)
   }
-
   const stmt = client.prepare(sql)
-
   if (sql.toUpperCase().includes('COUNT(*) AS')) {
     return [stmt.get(...normalizedParams)]
   }
-
   return stmt.all(...normalizedParams)
 }
 
@@ -5300,14 +5275,11 @@ export function speedExtension(config: {
   }) => void
 }) {
   const { postgres, sqlite, debug, onQuery } = config
-
   if (!postgres && !sqlite) {
     throw new Error('speedExtension requires postgres or sqlite client')
   }
-
   const client = postgres || sqlite
   const actualDialect = postgres ? 'postgres' : 'sqlite'
-
   if (actualDialect !== DIALECT) {
     throw new Error(\`Generated code is for \${DIALECT}, but you provided \${actualDialect}\`)
   }
@@ -5324,12 +5296,9 @@ export function speedExtension(config: {
     const handleMethod = async function(this: any, method: PrismaMethod, args: any) {
       const modelName = this?.name || this?.$name
       const startTime = Date.now()
-
       const transformedArgs = transformEnumValuesByModel(modelName, args || {})
-
       const queryKey = normalizeQuery(transformedArgs)
       const prebakedQuery = QUERIES[modelName]?.[method]?.[queryKey]
-
       let sql: string
       let params: unknown[]
       let prebaked = false
@@ -5343,11 +5312,9 @@ export function speedExtension(config: {
         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 = normalizeParams(result.params as unknown[])
@@ -5379,16 +5346,13 @@ export function speedExtension(config: {
     ): Promise<{ [K in keyof T]: any }> {
       const batchProxy = createBatchProxy()
       const queries = await callback(batchProxy)
-
       const batchQueries: Record<string, BatchQuery> = {}
-
       for (const [key, deferred] of Object.entries(queries)) {
         if (!(deferred instanceof DeferredQuery)) {
           throw new Error(
             \`Batch query '\${key}' must be a deferred query. Did you await it?\`,
           )
         }
-
         batchQueries[key] = {
           model: deferred.model,
           method: deferred.method,
@@ -5414,8 +5378,8 @@ export function speedExtension(config: {
       const rows = await client.unsafe(sql, normalizedParams as any[])
       const row = rows[0] as Record<string, unknown>
       const results = parseBatchResults(row, keys, batchQueries, aliases)
-      const duration = Date.now() - startTime
 
+      const duration = Date.now() - startTime
       onQuery?.({
         model: '_batch',
         method: 'batch',
@@ -5430,7 +5394,6 @@ export function speedExtension(config: {
 
     async function batchCount(queries: BatchCountQuery[]): Promise<number[]> {
       if (queries.length === 0) return []
-
       const startTime = Date.now()
       const { sql, params } = buildBatchCountSql(
         queries,
@@ -5449,8 +5412,8 @@ export function speedExtension(config: {
       const rows = await client.unsafe(sql, normalizedParams as any[])
       const row = rows[0] as Record<string, unknown>
       const results = parseBatchCountResults(row, queries.length)
-      const duration = Date.now() - startTime
 
+      const duration = Date.now() - startTime
       onQuery?.({
         model: '_batch',
         method: 'count',
@@ -5468,14 +5431,11 @@ export function speedExtension(config: {
       options?: TransactionOptions,
     ): Promise<unknown[]> {
       const startTime = Date.now()
-
       if (debug) {
         console.log(\`[\${DIALECT}] $transaction (\${queries.length} queries)\`)
       }
-
       const results = await txExecutor.execute(queries, options)
       const duration = Date.now() - startTime
-
       onQuery?.({
         model: '_transaction',
         method: 'transaction',
@@ -5484,13 +5444,11 @@ export function speedExtension(config: {
         duration,
         prebaked: false,
       })
-
       return results
     }
 
     return prisma.$extends({
       name: 'prisma-sql-generated',
-
       client: {
         $original: prisma,
         $batch: batch as <T extends Record<string, DeferredQuery>>(
@@ -5499,7 +5457,6 @@ export function speedExtension(config: {
         $batchCount: batchCount as (...args: any[]) => Promise<number[]>,
         $transaction: transaction as (...args: any[]) => Promise<unknown[]>,
       },
-
       model: {
         $allModels: {
           async findMany(args: any) {