prisma-sql 1.69.0 → 1.71.0

package/dist/index.cjs

@@ -57,235 +57,6 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
-// src/utils/normalize-value.ts
-var MAX_DEPTH = 20;
-function normalizeValue(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
-  if (depth > MAX_DEPTH) {
-    throw new Error(`Max normalization depth exceeded (${MAX_DEPTH} levels)`);
-  }
-  if (value instanceof Date) {
-    return normalizeDateValue(value);
-  }
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  if (Array.isArray(value)) {
-    return normalizeArrayValue(value, seen, depth);
-  }
-  if (value && typeof value === "object") {
-    return normalizeObjectValue(value, seen, depth);
-  }
-  return value;
-}
-function normalizeDateValue(date) {
-  const t = date.getTime();
-  if (!Number.isFinite(t)) {
-    throw new Error("Invalid Date value in SQL params");
-  }
-  return date.toISOString();
-}
-function normalizeArrayValue(value, seen, depth) {
-  const arrRef = value;
-  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;
-}
-function normalizeObjectValue(value, seen, depth) {
-  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;
-  if (seen.has(obj)) {
-    throw new Error("Circular reference in SQL params");
-  }
-  seen.add(obj);
-  const out = {};
-  for (const [k, v] of Object.entries(obj)) {
-    out[k] = normalizeValue(v, seen, depth + 1);
-  }
-  seen.delete(obj);
-  return out;
-}
-
-// src/sql-builder-dialect.ts
-var globalDialect = "postgres";
-function getGlobalDialect() {
-  return globalDialect;
-}
-function assertNonEmpty(value, name) {
-  if (!value || value.trim().length === 0) {
-    throw new Error(`${name} is required and cannot be empty`);
-  }
-}
-function arrayContains(column, value, arrayType, dialect) {
-  assertNonEmpty(column, "arrayContains column");
-  assertNonEmpty(value, "arrayContains value");
-  if (dialect === "postgres") {
-    return `${column} @> ARRAY[${value}]::${arrayType}`;
-  }
-  return `EXISTS (SELECT 1 FROM json_each(${column}) WHERE value = ${value})`;
-}
-function arrayOverlaps(column, value, arrayType, dialect) {
-  assertNonEmpty(column, "arrayOverlaps column");
-  assertNonEmpty(value, "arrayOverlaps value");
-  if (dialect === "postgres") {
-    return `${column} && ${value}::${arrayType}`;
-  }
-  return `EXISTS (
-    SELECT 1 FROM json_each(${column}) AS col
-    JOIN json_each(${value}) AS val
-    WHERE col.value = val.value
-  )`;
-}
-function arrayContainsAll(column, value, arrayType, dialect) {
-  assertNonEmpty(column, "arrayContainsAll column");
-  assertNonEmpty(value, "arrayContainsAll value");
-  if (dialect === "postgres") {
-    return `${column} @> ${value}::${arrayType}`;
-  }
-  return `NOT EXISTS (
-    SELECT 1 FROM json_each(${value}) AS val
-    WHERE NOT EXISTS (
-      SELECT 1 FROM json_each(${column}) AS col
-      WHERE col.value = val.value
-    )
-  )`;
-}
-function arrayIsEmpty(column, dialect) {
-  assertNonEmpty(column, "arrayIsEmpty column");
-  if (dialect === "postgres") {
-    return `(${column} IS NULL OR array_length(${column}, 1) IS NULL)`;
-  }
-  return `(${column} IS NULL OR json_array_length(${column}) = 0)`;
-}
-function arrayIsNotEmpty(column, dialect) {
-  assertNonEmpty(column, "arrayIsNotEmpty column");
-  if (dialect === "postgres") {
-    return `(${column} IS NOT NULL AND array_length(${column}, 1) IS NOT NULL)`;
-  }
-  return `(${column} IS NOT NULL AND json_array_length(${column}) > 0)`;
-}
-function arrayEquals(column, value, arrayType, dialect) {
-  assertNonEmpty(column, "arrayEquals column");
-  assertNonEmpty(value, "arrayEquals value");
-  if (dialect === "postgres") {
-    return `${column} = ${value}::${arrayType}`;
-  }
-  return `json(${column}) = json(${value})`;
-}
-function caseInsensitiveLike(column, pattern, dialect) {
-  assertNonEmpty(column, "caseInsensitiveLike column");
-  assertNonEmpty(pattern, "caseInsensitiveLike pattern");
-  if (dialect === "postgres") {
-    return `${column} ILIKE ${pattern}`;
-  }
-  return `LOWER(${column}) LIKE LOWER(${pattern})`;
-}
-function caseInsensitiveEquals(column, value, dialect) {
-  assertNonEmpty(column, "caseInsensitiveEquals column");
-  assertNonEmpty(value, "caseInsensitiveEquals value");
-  return `LOWER(${column}) = LOWER(${value})`;
-}
-function jsonExtractText(column, path, dialect) {
-  assertNonEmpty(column, "jsonExtractText column");
-  assertNonEmpty(path, "jsonExtractText path");
-  if (dialect === "postgres") {
-    const p = String(path).trim();
-    const pathExpr = /^\$\d+$/.test(p) ? `${p}::text[]` : p;
-    return `${column}#>>${pathExpr}`;
-  }
-  return `json_extract(${column}, ${path})`;
-}
-function jsonExtractNumeric(column, path, dialect) {
-  assertNonEmpty(column, "jsonExtractNumeric column");
-  assertNonEmpty(path, "jsonExtractNumeric path");
-  if (dialect === "postgres") {
-    const p = String(path).trim();
-    const pathExpr = /^\$\d+$/.test(p) ? `${p}::text[]` : p;
-    return `(${column}#>>${pathExpr})::numeric`;
-  }
-  return `CAST(json_extract(${column}, ${path}) AS REAL)`;
-}
-function jsonToText(column, dialect) {
-  assertNonEmpty(column, "jsonToText column");
-  if (dialect === "postgres") {
-    return `${column}::text`;
-  }
-  return column;
-}
-function inArray(column, value, dialect) {
-  assertNonEmpty(column, "inArray column");
-  assertNonEmpty(value, "inArray value");
-  if (dialect === "postgres") {
-    return `${column} = ANY(${value})`;
-  }
-  return `${column} IN (SELECT value FROM json_each(${value}))`;
-}
-function notInArray(column, value, dialect) {
-  assertNonEmpty(column, "notInArray column");
-  assertNonEmpty(value, "notInArray value");
-  if (dialect === "postgres") {
-    return `${column} != ALL(${value})`;
-  }
-  return `${column} NOT IN (SELECT value FROM json_each(${value}))`;
-}
-function getArrayType(prismaType, dialect) {
-  if (!prismaType || prismaType.length === 0) {
-    return dialect === "sqlite" ? "TEXT" : "text[]";
-  }
-  if (dialect === "sqlite") {
-    return "TEXT";
-  }
-  const baseType = prismaType.replace(/\[\]|\?/g, "");
-  switch (baseType) {
-    case "String":
-      return "text[]";
-    case "Int":
-      return "integer[]";
-    case "Float":
-      return "double precision[]";
-    case "Decimal":
-      return "numeric[]";
-    case "Boolean":
-      return "boolean[]";
-    case "BigInt":
-      return "bigint[]";
-    case "DateTime":
-      return "timestamptz[]";
-    default:
-      return `"${baseType}"[]`;
-  }
-}
-function jsonAgg(content, dialect) {
-  assertNonEmpty(content, "jsonAgg content");
-  if (dialect === "postgres") {
-    return `json_agg(${content})`;
-  }
-  return `json_group_array(${content})`;
-}
-function jsonBuildObject(pairs, dialect) {
-  const safePairs = (pairs != null ? pairs : "").trim();
-  if (dialect === "postgres") {
-    return safePairs.length > 0 ? `json_build_object(${safePairs})` : `json_build_object()`;
-  }
-  return safePairs.length > 0 ? `json_object(${safePairs})` : `json_object()`;
-}
-function prepareArrayParam(value, dialect) {
-  if (!Array.isArray(value)) {
-    throw new Error("prepareArrayParam requires array value");
-  }
-  if (dialect === "postgres") {
-    return value.map((v) => normalizeValue(v));
-  }
-  return JSON.stringify(value.map((v) => normalizeValue(v)));
-}
-
 // src/builder/shared/constants.ts
 var IS_PRODUCTION = process.env.NODE_ENV === "production";
 var SQL_SEPARATORS = Object.freeze({
@@ -1120,25 +891,276 @@ function joinCondition(field, parentModel, childModel, parentAlias, childAlias)
       { field: field.name }
     );
   }
-  const refFields = getReferenceFieldNames(field, fkFields.length);
-  if (refFields.length !== fkFields.length) {
-    throw createError(
-      `Relation '${field.name}' is missing references (or references count does not match foreignKey count). This is required to support non-id and composite keys.`,
-      { field: field.name }
-    );
+  const refFields = getReferenceFieldNames(field, fkFields.length);
+  if (refFields.length !== fkFields.length) {
+    throw createError(
+      `Relation '${field.name}' is missing references (or references count does not match foreignKey count). This is required to support non-id and composite keys.`,
+      { field: field.name }
+    );
+  }
+  const parts = [];
+  for (let i = 0; i < fkFields.length; i++) {
+    const fk = fkFields[i];
+    const ref = refFields[i];
+    const left = field.isForeignKeyLocal ? `${childAlias}.${quoteColumn(childModel, ref)}` : `${childAlias}.${quoteColumn(childModel, fk)}`;
+    const right = field.isForeignKeyLocal ? `${parentAlias}.${quoteColumn(parentModel, fk)}` : `${parentAlias}.${quoteColumn(parentModel, ref)}`;
+    parts.push(`${left} = ${right}`);
+  }
+  return parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
+}
+function getModelByName(schemas, name) {
+  return schemas.find((m) => m.name === name);
+}
+
+// src/utils/normalize-value.ts
+var globalDateMode = "iso";
+function setNormalizeDateMode(mode) {
+  globalDateMode = mode;
+}
+function detectSqliteDateMode(client) {
+  try {
+    const tables = client.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_prisma_%' LIMIT 50"
+    ).all();
+    for (const { name } of tables) {
+      const row = client.prepare(`SELECT typeof("createdAt") as t FROM "${name}" LIMIT 1`).get();
+      if (row) {
+        return row.t === "integer" ? "ms" : "iso";
+      }
+    }
+  } catch (e) {
+  }
+  return "iso";
+}
+var MAX_DEPTH = 20;
+function normalizeValue(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
+  if (depth > MAX_DEPTH) {
+    throw new Error(`Max normalization depth exceeded (${MAX_DEPTH} levels)`);
+  }
+  if (value instanceof Date) {
+    return normalizeDateValue(value);
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return normalizeArrayValue(value, seen, depth);
+  }
+  if (value && typeof value === "object") {
+    return normalizeObjectValue(value, seen, depth);
+  }
+  return value;
+}
+function normalizeDateValue(date) {
+  const t = date.getTime();
+  if (!Number.isFinite(t)) {
+    throw new Error("Invalid Date value in SQL params");
+  }
+  if (globalDateMode === "ms") {
+    return t;
+  }
+  return date.toISOString();
+}
+function normalizeArrayValue(value, seen, depth) {
+  const arrRef = value;
+  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;
+}
+function normalizeObjectValue(value, seen, depth) {
+  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;
+  if (seen.has(obj)) {
+    throw new Error("Circular reference in SQL params");
+  }
+  seen.add(obj);
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    out[k] = normalizeValue(v, seen, depth + 1);
+  }
+  seen.delete(obj);
+  return out;
+}
+
+// src/sql-builder-dialect.ts
+var globalDialect = "postgres";
+function getGlobalDialect() {
+  return globalDialect;
+}
+function assertNonEmpty(value, name) {
+  if (!value || value.trim().length === 0) {
+    throw new Error(`${name} is required and cannot be empty`);
+  }
+}
+function arrayContains(column, value, arrayType, dialect) {
+  assertNonEmpty(column, "arrayContains column");
+  assertNonEmpty(value, "arrayContains value");
+  if (dialect === "postgres") {
+    return `${column} @> ARRAY[${value}]::${arrayType}`;
+  }
+  return `EXISTS (SELECT 1 FROM json_each(${column}) WHERE value = ${value})`;
+}
+function arrayOverlaps(column, value, arrayType, dialect) {
+  assertNonEmpty(column, "arrayOverlaps column");
+  assertNonEmpty(value, "arrayOverlaps value");
+  if (dialect === "postgres") {
+    return `${column} && ${value}::${arrayType}`;
+  }
+  return `EXISTS (
+    SELECT 1 FROM json_each(${column}) AS col
+    JOIN json_each(${value}) AS val
+    WHERE col.value = val.value
+  )`;
+}
+function arrayContainsAll(column, value, arrayType, dialect) {
+  assertNonEmpty(column, "arrayContainsAll column");
+  assertNonEmpty(value, "arrayContainsAll value");
+  if (dialect === "postgres") {
+    return `${column} @> ${value}::${arrayType}`;
+  }
+  return `NOT EXISTS (
+    SELECT 1 FROM json_each(${value}) AS val
+    WHERE NOT EXISTS (
+      SELECT 1 FROM json_each(${column}) AS col
+      WHERE col.value = val.value
+    )
+  )`;
+}
+function arrayIsEmpty(column, dialect) {
+  assertNonEmpty(column, "arrayIsEmpty column");
+  if (dialect === "postgres") {
+    return `(${column} IS NULL OR array_length(${column}, 1) IS NULL)`;
+  }
+  return `(${column} IS NULL OR json_array_length(${column}) = 0)`;
+}
+function arrayIsNotEmpty(column, dialect) {
+  assertNonEmpty(column, "arrayIsNotEmpty column");
+  if (dialect === "postgres") {
+    return `(${column} IS NOT NULL AND array_length(${column}, 1) IS NOT NULL)`;
+  }
+  return `(${column} IS NOT NULL AND json_array_length(${column}) > 0)`;
+}
+function arrayEquals(column, value, arrayType, dialect) {
+  assertNonEmpty(column, "arrayEquals column");
+  assertNonEmpty(value, "arrayEquals value");
+  if (dialect === "postgres") {
+    return `${column} = ${value}::${arrayType}`;
+  }
+  return `json(${column}) = json(${value})`;
+}
+function caseInsensitiveLike(column, pattern, dialect) {
+  assertNonEmpty(column, "caseInsensitiveLike column");
+  assertNonEmpty(pattern, "caseInsensitiveLike pattern");
+  if (dialect === "postgres") {
+    return `${column} ILIKE ${pattern}`;
+  }
+  return `LOWER(${column}) LIKE LOWER(${pattern})`;
+}
+function caseInsensitiveEquals(column, value, dialect) {
+  assertNonEmpty(column, "caseInsensitiveEquals column");
+  assertNonEmpty(value, "caseInsensitiveEquals value");
+  return `LOWER(${column}) = LOWER(${value})`;
+}
+function jsonExtractText(column, path, dialect) {
+  assertNonEmpty(column, "jsonExtractText column");
+  assertNonEmpty(path, "jsonExtractText path");
+  if (dialect === "postgres") {
+    const p = String(path).trim();
+    const pathExpr = /^\$\d+$/.test(p) ? `${p}::text[]` : p;
+    return `${column}#>>${pathExpr}`;
+  }
+  return `json_extract(${column}, ${path})`;
+}
+function jsonExtractNumeric(column, path, dialect) {
+  assertNonEmpty(column, "jsonExtractNumeric column");
+  assertNonEmpty(path, "jsonExtractNumeric path");
+  if (dialect === "postgres") {
+    const p = String(path).trim();
+    const pathExpr = /^\$\d+$/.test(p) ? `${p}::text[]` : p;
+    return `(${column}#>>${pathExpr})::numeric`;
+  }
+  return `CAST(json_extract(${column}, ${path}) AS REAL)`;
+}
+function jsonToText(column, dialect) {
+  assertNonEmpty(column, "jsonToText column");
+  if (dialect === "postgres") {
+    return `${column}::text`;
+  }
+  return column;
+}
+function inArray(column, value, dialect) {
+  assertNonEmpty(column, "inArray column");
+  assertNonEmpty(value, "inArray value");
+  if (dialect === "postgres") {
+    return `${column} = ANY(${value})`;
+  }
+  return `${column} IN (SELECT value FROM json_each(${value}))`;
+}
+function notInArray(column, value, dialect) {
+  assertNonEmpty(column, "notInArray column");
+  assertNonEmpty(value, "notInArray value");
+  if (dialect === "postgres") {
+    return `${column} != ALL(${value})`;
+  }
+  return `${column} NOT IN (SELECT value FROM json_each(${value}))`;
+}
+function getArrayType(prismaType, dialect) {
+  if (!prismaType || prismaType.length === 0) {
+    return dialect === "sqlite" ? "TEXT" : "text[]";
+  }
+  if (dialect === "sqlite") {
+    return "TEXT";
+  }
+  const baseType = prismaType.replace(/\[\]|\?/g, "");
+  switch (baseType) {
+    case "String":
+      return "text[]";
+    case "Int":
+      return "integer[]";
+    case "Float":
+      return "double precision[]";
+    case "Decimal":
+      return "numeric[]";
+    case "Boolean":
+      return "boolean[]";
+    case "BigInt":
+      return "bigint[]";
+    case "DateTime":
+      return "timestamptz[]";
+    default:
+      return `"${baseType}"[]`;
+  }
+}
+function jsonAgg(content, dialect) {
+  assertNonEmpty(content, "jsonAgg content");
+  if (dialect === "postgres") {
+    return `json_agg(${content})`;
   }
-  const parts = [];
-  for (let i = 0; i < fkFields.length; i++) {
-    const fk = fkFields[i];
-    const ref = refFields[i];
-    const left = field.isForeignKeyLocal ? `${childAlias}.${quoteColumn(childModel, ref)}` : `${childAlias}.${quoteColumn(childModel, fk)}`;
-    const right = field.isForeignKeyLocal ? `${parentAlias}.${quoteColumn(parentModel, fk)}` : `${parentAlias}.${quoteColumn(parentModel, ref)}`;
-    parts.push(`${left} = ${right}`);
+  return `json_group_array(${content})`;
+}
+function jsonBuildObject(pairs, dialect) {
+  const safePairs = (pairs != null ? pairs : "").trim();
+  if (dialect === "postgres") {
+    return safePairs.length > 0 ? `json_build_object(${safePairs})` : `json_build_object()`;
   }
-  return parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
+  return safePairs.length > 0 ? `json_object(${safePairs})` : `json_object()`;
 }
-function getModelByName(schemas, name) {
-  return schemas.find((m) => m.name === name);
+function prepareArrayParam(value, dialect) {
+  if (!Array.isArray(value)) {
+    throw new Error("prepareArrayParam requires array value");
+  }
+  if (dialect === "postgres") {
+    return value.map((v) => normalizeValue(v));
+  }
+  return JSON.stringify(value.map((v) => normalizeValue(v)));
 }
 function normalizeIntLike(name, v, opts = {}) {
   var _a3, _b;
@@ -2278,14 +2300,15 @@ function hasPaginationArgs(value) {
   const obj = value;
   return "take" in obj && obj.take != null || "skip" in obj && typeof obj.skip === "number" && obj.skip > 0;
 }
-function buildCostTree(includeSpec, model, schemas) {
+function buildCostTree(includeSpec, model, schemas, depth = 0) {
+  if (depth > LIMITS.MAX_INCLUDE_DEPTH) return [];
   const relations = resolveIncludeRelations(includeSpec, model, schemas);
   const nodes = [];
   for (const rel of relations) {
     const fan = rel.isList ? getFanOut(model.name, rel.relName) : 1;
     const take = rel.isList ? readTake(rel.value) : 1;
     const eff = Math.min(fan, take);
-    const children = Object.keys(rel.nestedSpec).length > 0 ? buildCostTree(rel.nestedSpec, rel.relModel, schemas) : [];
+    const children = Object.keys(rel.nestedSpec).length > 0 ? buildCostTree(rel.nestedSpec, rel.relModel, schemas, depth + 1) : [];
     nodes.push({
       name: rel.relName,
       fan,
@@ -2351,19 +2374,26 @@ function hasOnlyToOneRelations(includeSpec, model) {
   }
   return true;
 }
-function countIncludeDepth(includeSpec, model, schemas) {
+function countIncludeDepth(includeSpec, model, schemas, depth = 0) {
+  if (depth > LIMITS.MAX_INCLUDE_DEPTH) return 0;
   const relations = resolveIncludeRelations(includeSpec, model, schemas);
   let maxDepth = 0;
   for (const rel of relations) {
     let childDepth = 1;
     if (Object.keys(rel.nestedSpec).length > 0) {
-      childDepth += countIncludeDepth(rel.nestedSpec, rel.relModel, schemas);
+      childDepth += countIncludeDepth(
+        rel.nestedSpec,
+        rel.relModel,
+        schemas,
+        depth + 1
+      );
     }
     if (childDepth > maxDepth) maxDepth = childDepth;
   }
   return maxDepth;
 }
-function hasChildPaginationAnywhere(includeSpec, model, schemas) {
+function hasChildPaginationAnywhere(includeSpec, model, schemas, depth = 0) {
+  if (depth > LIMITS.MAX_INCLUDE_DEPTH) return false;
   for (const [, value] of Object.entries(includeSpec)) {
     if (value === false) continue;
     if (hasPaginationArgs(value)) return true;
@@ -2371,7 +2401,12 @@ function hasChildPaginationAnywhere(includeSpec, model, schemas) {
   const relations = resolveIncludeRelations(includeSpec, model, schemas);
   for (const rel of relations) {
     if (Object.keys(rel.nestedSpec).length > 0) {
-      if (hasChildPaginationAnywhere(rel.nestedSpec, rel.relModel, schemas)) {
+      if (hasChildPaginationAnywhere(
+        rel.nestedSpec,
+        rel.relModel,
+        schemas,
+        depth + 1
+      )) {
         return true;
       }
     }
@@ -6136,9 +6171,10 @@ function buildAggregateFields(args, alias, model) {
   addAggregateFields(fields, args, alias, model);
   return fields;
 }
-function buildAggregateSql(args, whereResult, tableName, alias, model) {
+function buildAggregateSql(args, whereResult, tableName, alias, model, dialect) {
   assertSafeAlias(alias);
   assertSafeTableRef(tableName);
+  const d = dialect != null ? dialect : getGlobalDialect();
   const aggFields = buildAggregateFields(args, alias, model);
   if (!isNonEmptyArray(aggFields)) {
     throw new Error("buildAggregateSql requires at least one aggregate field");
@@ -6157,7 +6193,7 @@ function buildAggregateSql(args, whereResult, tableName, alias, model) {
   if (whereClause) parts.push(whereClause);
   const sql = parts.join(" ").trim();
   validateSelectQuery(sql);
-  validateParamConsistency(sql, whereResult.params);
+  validateParamConsistencyByDialect(sql, whereResult.params, d);
   return {
     sql,
     params: [...whereResult.params],
@@ -6236,7 +6272,7 @@ function buildGroupBySql(args, whereResult, tableName, alias, model, dialect) {
   const allParams = [...whereResult.params, ...snapshot.params];
   const allMappings = [...whereResult.paramMappings, ...snapshot.mappings];
   validateSelectQuery(sql);
-  validateParamConsistency(sql, allParams);
+  validateParamConsistencyByDialect(sql, allParams, d);
   return {
     sql,
     params: allParams,
@@ -6253,7 +6289,7 @@ function assertNoNegativeTake(args) {
     throw new Error("Negative take is not supported for count()");
   }
 }
-function buildSimpleCountSql(whereResult, tableName, alias) {
+function buildSimpleCountSql(whereResult, tableName, alias, dialect) {
   const joinsPart = whereResult.joins && whereResult.joins.length > 0 ? whereResult.joins.join(" ") : "";
   const whereClause = isValidWhereClause(whereResult.clause) ? SQL_TEMPLATES.WHERE + " " + whereResult.clause : "";
   const parts = [
@@ -6269,7 +6305,7 @@ function buildSimpleCountSql(whereResult, tableName, alias) {
   if (whereClause) parts.push(whereClause);
   const sql = parts.join(" ").trim();
   validateSelectQuery(sql);
-  validateParamConsistency(sql, whereResult.params);
+  validateParamConsistencyByDialect(sql, whereResult.params, dialect);
   return {
     sql,
     params: [...whereResult.params],
@@ -6281,14 +6317,15 @@ function buildCountSql(whereResult, tableName, alias, argsOrSkip, dialect, model
   assertSafeTableRef(tableName);
   const args = normalizeCountArgs(argsOrSkip);
   assertNoNegativeTake(args);
+  const d = dialect != null ? dialect : getGlobalDialect();
   if (!model) {
-    return buildSimpleCountSql(whereResult, tableName, alias);
+    return buildSimpleCountSql(whereResult, tableName, alias, d);
   }
   const pkFields = getPrimaryKeyFields(model);
   const distinctFields = isNonEmptyArray(args.distinct) ? args.distinct.map((x) => String(x)).filter((x) => x) : [];
   const selectFields = distinctFields.length > 0 ? distinctFields : pkFields;
   if (selectFields.length === 0) {
-    return buildSimpleCountSql(whereResult, tableName, alias);
+    return buildSimpleCountSql(whereResult, tableName, alias, d);
   }
   const select = {};
   for (const f of selectFields) select[f] = true;
@@ -6296,7 +6333,6 @@ function buildCountSql(whereResult, tableName, alias, argsOrSkip, dialect, model
     include: void 0,
     select
   });
-  const d = dialect != null ? dialect : getGlobalDialect();
   const subSchemas = Array.isArray(schemas) && schemas.length > 0 ? schemas : [model];
   const sub = buildSelectSql({
     method: "findMany",
@@ -6312,7 +6348,7 @@ function buildCountSql(whereResult, tableName, alias, argsOrSkip, dialect, model
     "_count._all"
   )} ${SQL_TEMPLATES.FROM} (${sub.sql}) ${SQL_TEMPLATES.AS} ${countAlias}`;
   validateSelectQuery(sql);
-  validateParamConsistency(sql, sub.params);
+  validateParamConsistencyByDialect(sql, sub.params, d);
   return {
     sql,
     params: sub.params,
@@ -6603,7 +6639,14 @@ function buildSqlResult(args) {
     dialect
   } = args;
   if (method === "aggregate") {
-    return buildAggregateSql(processed, whereResult, tableName, alias, modelDef);
+    return buildAggregateSql(
+      processed,
+      whereResult,
+      tableName,
+      alias,
+      modelDef,
+      dialect
+    );
   }
   if (method === "groupBy") {
     return buildGroupBySql(
@@ -7310,7 +7353,8 @@ function buildSQLFull(model, models, method, args, dialect) {
         whereResult,
         tableName,
         alias,
-        model
+        model,
+        dialect
       );
       break;
     case "groupBy":
@@ -7328,8 +7372,10 @@ function buildSQLFull(model, models, method, args, dialect) {
         whereResult,
         tableName,
         alias,
-        args.skip,
-        dialect
+        args,
+        dialect,
+        model,
+        models
       );
       break;
     default:
@@ -7343,7 +7389,8 @@ function buildSQLFull(model, models, method, args, dialect) {
         dialect
       });
   }
-  const sqlResult = dialect === "sqlite" ? pgToSqlitePlaceholders(result.sql, result.params) : { sql: result.sql, params: [...result.params] };
+  const needsPlaceholderConversion = dialect === "sqlite" && result.sql.includes("$");
+  const sqlResult = needsPlaceholderConversion ? pgToSqlitePlaceholders(result.sql, result.params) : { sql: result.sql, params: [...result.params] };
   return __spreadProps(__spreadValues({}, sqlResult), {
     paramMappings: result.paramMappings,
     requiresReduction: result.requiresReduction,
@@ -7504,68 +7551,234 @@ function validateTimeout(timeout) {
       `Transaction timeout must be a number, got ${typeof timeout}`
     );
   }
-  if (!Number.isFinite(timeout)) {
-    throw new Error(`Transaction timeout must be finite, got ${timeout}`);
+  if (!Number.isFinite(timeout)) {
+    throw new Error(`Transaction timeout must be finite, got ${timeout}`);
+  }
+  if (timeout < 0) {
+    throw new Error(`Transaction timeout must be non-negative, got ${timeout}`);
+  }
+  return Math.floor(timeout);
+}
+function createTransactionExecutor(deps) {
+  const { modelMap, allModels, dialect, postgresClient } = deps;
+  return {
+    execute(queries, options) {
+      return __async(this, null, function* () {
+        if (queries.length === 0) return [];
+        if (dialect !== "postgres") {
+          throw new Error("$transaction is only supported for postgres dialect");
+        }
+        if (!postgresClient) {
+          throw new Error("postgresClient is required for transactions");
+        }
+        const transactionCallback = (sql) => __async(null, null, function* () {
+          const results = [];
+          const isolationLevel = isolationLevelToPostgresKeyword(
+            options == null ? void 0 : options.isolationLevel
+          );
+          if (isolationLevel) {
+            yield sql.unsafe(
+              `SET TRANSACTION ISOLATION LEVEL ${isolationLevel.toUpperCase()}`
+            );
+          }
+          if ((options == null ? void 0 : options.timeout) !== void 0 && options.timeout !== null) {
+            const validatedTimeout = validateTimeout(options.timeout);
+            yield sql.unsafe(`SET LOCAL statement_timeout = $1`, [
+              validatedTimeout
+            ]);
+          }
+          for (const q of queries) {
+            const model = modelMap.get(q.model);
+            if (!model) {
+              throw new Error(
+                `Model '${q.model}' not found. Available: ${[...modelMap.keys()].join(", ")}`
+              );
+            }
+            const { sql: sqlStr, params } = buildSQLWithCache(
+              model,
+              allModels,
+              q.method,
+              q.args || {},
+              dialect
+            );
+            let rawResults = yield sql.unsafe(sqlStr, params);
+            const rowTransformer = getRowTransformer(q.method);
+            if (rowTransformer && Array.isArray(rawResults)) {
+              rawResults = rawResults.map(rowTransformer);
+            }
+            results.push(transformQueryResults(q.method, rawResults));
+          }
+          return results;
+        });
+        return yield postgresClient.begin(transactionCallback);
+      });
+    }
+  };
+}
+
+// src/builder/select/segment-planner.ts
+function isListField2(field) {
+  return typeof field.type === "string" && field.type.endsWith("[]");
+}
+function resolveRelation(model, relName, allModels) {
+  const field = model.fields.find((f) => f.name === relName);
+  if (!field || !field.isRelation || !field.relatedModel) return null;
+  const relModel = allModels.find((m) => m.name === field.relatedModel);
+  if (!relModel) return null;
+  return { field, relModel };
+}
+function extractPagination(relArgs) {
+  if (!isPlainObject(relArgs)) return {};
+  const obj = relArgs;
+  const result = {};
+  if ("take" in obj && typeof obj.take === "number") {
+    result.take = obj.take;
+  }
+  if ("skip" in obj && typeof obj.skip === "number" && obj.skip > 0) {
+    result.skip = obj.skip;
+  }
+  return result;
+}
+function buildWhereInSegment(name, relArgs, field, relModel) {
+  const keys = resolveRelationKeys(field, "whereIn");
+  if (keys.childKeys.length !== 1) return null;
+  const isList = isListField2(field);
+  const pagination = isList ? extractPagination(relArgs) : {};
+  return {
+    relationName: name,
+    relArgs,
+    childModelName: relModel.name,
+    fkFieldName: keys.childKeys[0],
+    parentKeyFieldName: keys.parentKeys[0],
+    isList,
+    perParentTake: pagination.take,
+    perParentSkip: pagination.skip
+  };
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (obj instanceof Date) return new Date(obj.getTime());
+  if (obj instanceof RegExp) return new RegExp(obj.source, obj.flags);
+  if (Array.isArray(obj)) return obj.map((item) => deepClone(item));
+  const cloned = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      cloned[key] = deepClone(obj[key]);
+    }
+  }
+  return cloned;
+}
+function removeRelationsFromArgs(args, names) {
+  if (!args) return args;
+  const filtered = deepClone(args);
+  if (filtered.include && isPlainObject(filtered.include)) {
+    for (const name of names) {
+      delete filtered.include[name];
+    }
+    if (Object.keys(filtered.include).length === 0) {
+      delete filtered.include;
+    }
+  }
+  if (filtered.select && isPlainObject(filtered.select)) {
+    for (const name of names) {
+      delete filtered.select[name];
+    }
+  }
+  return filtered;
+}
+function ensureParentKeysInSelect(args, segments) {
+  if (!(args == null ? void 0 : args.select)) return { args, injectedKeys: [] };
+  const injected = [];
+  const newSelect = __spreadValues({}, args.select);
+  for (const seg of segments) {
+    if (!newSelect[seg.parentKeyFieldName]) {
+      newSelect[seg.parentKeyFieldName] = true;
+      injected.push(seg.parentKeyFieldName);
+    }
+  }
+  if (injected.length === 0) return { args, injectedKeys: [] };
+  return { args: __spreadProps(__spreadValues({}, args), { select: newSelect }), injectedKeys: injected };
+}
+function extractIncludeSpec3(args, model) {
+  const spec = {};
+  const entries = extractRelationEntries(args, model);
+  for (const e of entries) {
+    if (e.value !== false) {
+      spec[e.name] = e.value;
+    }
+  }
+  return spec;
+}
+function planQueryStrategy(params) {
+  const { model, args, allModels, dialect, debug } = params;
+  const emptyPlan = {
+    filteredArgs: args,
+    originalArgs: args,
+    whereInSegments: [],
+    injectedParentKeys: []
+  };
+  const entries = extractRelationEntries(args, model);
+  if (entries.length === 0) {
+    return emptyPlan;
+  }
+  if (dialect === "postgres") {
+    const includeSpec = extractIncludeSpec3(args, model);
+    if (Object.keys(includeSpec).length > 0) {
+      isPlainObject(args) && "take" in args && args.take != null;
+      const takeValue = isPlainObject(args) && typeof args.take === "number" ? args.take : null;
+      const canFlatJoin = canUseFlatJoinForAll(includeSpec, model, allModels);
+      canUseLateralJoin(includeSpec, model, allModels);
+      hasChildPaginationAnywhere(
+        includeSpec,
+        model,
+        allModels
+      );
+      const strategy = pickIncludeStrategy({
+        includeSpec,
+        model,
+        schemas: allModels,
+        method: params.method,
+        takeValue,
+        canFlatJoin,
+        debug
+      });
+      if (debug) {
+        console.log(`  [planner] ${model.name}: strategy=${strategy}`);
+      }
+      if (strategy !== "where-in") {
+        return emptyPlan;
+      }
+    }
+  }
+  const whereInSegments = [];
+  const toRemove = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const resolved = resolveRelation(model, entry.name, allModels);
+    if (!resolved) continue;
+    const segment = buildWhereInSegment(
+      entry.name,
+      entry.value,
+      resolved.field,
+      resolved.relModel
+    );
+    if (segment) {
+      whereInSegments.push(segment);
+      toRemove.add(entry.name);
+    }
   }
-  if (timeout < 0) {
-    throw new Error(`Transaction timeout must be non-negative, got ${timeout}`);
+  if (toRemove.size === 0) {
+    return emptyPlan;
   }
-  return Math.floor(timeout);
-}
-function createTransactionExecutor(deps) {
-  const { modelMap, allModels, dialect, postgresClient } = deps;
+  const filteredArgs = removeRelationsFromArgs(args, toRemove);
+  const { args: finalArgs, injectedKeys } = ensureParentKeysInSelect(
+    filteredArgs,
+    whereInSegments
+  );
   return {
-    execute(queries, options) {
-      return __async(this, null, function* () {
-        if (queries.length === 0) return [];
-        if (dialect !== "postgres") {
-          throw new Error("$transaction is only supported for postgres dialect");
-        }
-        if (!postgresClient) {
-          throw new Error("postgresClient is required for transactions");
-        }
-        const transactionCallback = (sql) => __async(null, null, function* () {
-          const results = [];
-          const isolationLevel = isolationLevelToPostgresKeyword(
-            options == null ? void 0 : options.isolationLevel
-          );
-          if (isolationLevel) {
-            yield sql.unsafe(
-              `SET TRANSACTION ISOLATION LEVEL ${isolationLevel.toUpperCase()}`
-            );
-          }
-          if ((options == null ? void 0 : options.timeout) !== void 0 && options.timeout !== null) {
-            const validatedTimeout = validateTimeout(options.timeout);
-            yield sql.unsafe(`SET LOCAL statement_timeout = $1`, [
-              validatedTimeout
-            ]);
-          }
-          for (const q of queries) {
-            const model = modelMap.get(q.model);
-            if (!model) {
-              throw new Error(
-                `Model '${q.model}' not found. Available: ${[...modelMap.keys()].join(", ")}`
-              );
-            }
-            const { sql: sqlStr, params } = buildSQLWithCache(
-              model,
-              allModels,
-              q.method,
-              q.args || {},
-              dialect
-            );
-            let rawResults = yield sql.unsafe(sqlStr, params);
-            const rowTransformer = getRowTransformer(q.method);
-            if (rowTransformer && Array.isArray(rawResults)) {
-              rawResults = rawResults.map(rowTransformer);
-            }
-            results.push(transformQueryResults(q.method, rawResults));
-          }
-          return results;
-        });
-        return yield postgresClient.begin(transactionCallback);
-      });
-    }
+    filteredArgs: finalArgs,
+    originalArgs: args,
+    whereInSegments,
+    injectedParentKeys: injectedKeys
   };
 }
 
@@ -7609,9 +7822,9 @@ function extractChildLimit(relArgs) {
   return void 0;
 }
 function buildReducerConfig(parentModel, includeSpec, allModels, prefix = "", depth = 0) {
-  if (depth > 10) {
+  if (depth > LIMITS.MAX_NESTED_JOIN_DEPTH) {
     throw new Error(
-      `Reducer config exceeded maximum depth of 10 at path '${prefix}'`
+      `Reducer config exceeded maximum depth of ${LIMITS.MAX_NESTED_JOIN_DEPTH} at path '${prefix}'`
     );
   }
   const includedRelations = [];
@@ -7783,172 +7996,6 @@ function reduceFlatRows(rows, config) {
   return Array.from(resultMap.values());
 }
 
-// src/builder/select/segment-planner.ts
-function isListField2(field) {
-  return typeof field.type === "string" && field.type.endsWith("[]");
-}
-function resolveRelation(model, relName, allModels) {
-  const field = model.fields.find((f) => f.name === relName);
-  if (!field || !field.isRelation || !field.relatedModel) return null;
-  const relModel = allModels.find((m) => m.name === field.relatedModel);
-  if (!relModel) return null;
-  return { field, relModel };
-}
-function extractPagination(relArgs) {
-  if (!isPlainObject(relArgs)) return {};
-  const obj = relArgs;
-  const result = {};
-  if ("take" in obj && typeof obj.take === "number") {
-    result.take = obj.take;
-  }
-  if ("skip" in obj && typeof obj.skip === "number" && obj.skip > 0) {
-    result.skip = obj.skip;
-  }
-  return result;
-}
-function buildWhereInSegment(name, relArgs, field, relModel) {
-  const keys = resolveRelationKeys(field, "whereIn");
-  if (keys.childKeys.length !== 1) return null;
-  const isList = isListField2(field);
-  const pagination = isList ? extractPagination(relArgs) : {};
-  return {
-    relationName: name,
-    relArgs,
-    childModelName: relModel.name,
-    fkFieldName: keys.childKeys[0],
-    parentKeyFieldName: keys.parentKeys[0],
-    isList,
-    perParentTake: pagination.take,
-    perParentSkip: pagination.skip
-  };
-}
-function deepClone(obj) {
-  if (obj === null || typeof obj !== "object") return obj;
-  if (obj instanceof Date) return new Date(obj.getTime());
-  if (obj instanceof RegExp) return new RegExp(obj.source, obj.flags);
-  if (Array.isArray(obj)) return obj.map((item) => deepClone(item));
-  const cloned = {};
-  for (const key in obj) {
-    if (Object.prototype.hasOwnProperty.call(obj, key)) {
-      cloned[key] = deepClone(obj[key]);
-    }
-  }
-  return cloned;
-}
-function removeRelationsFromArgs(args, names) {
-  if (!args) return args;
-  const filtered = deepClone(args);
-  if (filtered.include && isPlainObject(filtered.include)) {
-    for (const name of names) {
-      delete filtered.include[name];
-    }
-    if (Object.keys(filtered.include).length === 0) {
-      delete filtered.include;
-    }
-  }
-  if (filtered.select && isPlainObject(filtered.select)) {
-    for (const name of names) {
-      delete filtered.select[name];
-    }
-  }
-  return filtered;
-}
-function ensureParentKeysInSelect(args, segments) {
-  if (!(args == null ? void 0 : args.select)) return { args, injectedKeys: [] };
-  const injected = [];
-  const newSelect = __spreadValues({}, args.select);
-  for (const seg of segments) {
-    if (!newSelect[seg.parentKeyFieldName]) {
-      newSelect[seg.parentKeyFieldName] = true;
-      injected.push(seg.parentKeyFieldName);
-    }
-  }
-  if (injected.length === 0) return { args, injectedKeys: [] };
-  return { args: __spreadProps(__spreadValues({}, args), { select: newSelect }), injectedKeys: injected };
-}
-function extractIncludeSpec3(args, model) {
-  const spec = {};
-  const entries = extractRelationEntries(args, model);
-  for (const e of entries) {
-    if (e.value !== false) {
-      spec[e.name] = e.value;
-    }
-  }
-  return spec;
-}
-function planQueryStrategy(params) {
-  const { model, args, allModels, dialect, debug } = params;
-  const emptyPlan = {
-    filteredArgs: args,
-    originalArgs: args,
-    whereInSegments: [],
-    injectedParentKeys: []
-  };
-  const entries = extractRelationEntries(args, model);
-  if (entries.length === 0) {
-    return emptyPlan;
-  }
-  if (dialect === "postgres") {
-    const includeSpec = extractIncludeSpec3(args, model);
-    if (Object.keys(includeSpec).length > 0) {
-      isPlainObject(args) && "take" in args && args.take != null;
-      const takeValue = isPlainObject(args) && typeof args.take === "number" ? args.take : null;
-      const canFlatJoin = canUseFlatJoinForAll(includeSpec, model, allModels);
-      canUseLateralJoin(includeSpec, model, allModels);
-      hasChildPaginationAnywhere(
-        includeSpec,
-        model,
-        allModels
-      );
-      const strategy = pickIncludeStrategy({
-        includeSpec,
-        model,
-        schemas: allModels,
-        method: params.method,
-        takeValue,
-        canFlatJoin,
-        debug
-      });
-      if (debug) {
-        console.log(`  [planner] ${model.name}: strategy=${strategy}`);
-      }
-      if (strategy !== "where-in") {
-        return emptyPlan;
-      }
-    }
-  }
-  const whereInSegments = [];
-  const toRemove = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    const resolved = resolveRelation(model, entry.name, allModels);
-    if (!resolved) continue;
-    const segment = buildWhereInSegment(
-      entry.name,
-      entry.value,
-      resolved.field,
-      resolved.relModel
-    );
-    if (segment) {
-      whereInSegments.push(segment);
-      toRemove.add(entry.name);
-    }
-  }
-  if (toRemove.size === 0) {
-    return emptyPlan;
-  }
-  const filteredArgs = removeRelationsFromArgs(args, toRemove);
-  const { args: finalArgs, injectedKeys } = ensureParentKeysInSelect(
-    filteredArgs,
-    whereInSegments
-  );
-  return {
-    filteredArgs: finalArgs,
-    originalArgs: args,
-    whereInSegments,
-    injectedParentKeys: injectedKeys
-  };
-}
-
 // src/builder/shared/where-in-utils.ts
 var MAX_RECURSIVE_DEPTH = 10;
 function buildParentKeyIndex(parentRows, parentKeyFieldName) {
@@ -9298,18 +9345,9 @@ function executePostgresQuery(opts) {
     return results;
   });
 }
-function executeSqliteQuery(client, sql, params, method, requiresReduction, includeSpec, model, allModels) {
+function executeSqliteQuery(client, sql, params, method) {
   const normalizedParams = normalizeParams(params);
   const shouldTransform = method === "groupBy" || method === "aggregate" || method === "count";
-  if (requiresReduction && includeSpec) {
-    const config = buildReducerConfig(model, includeSpec, allModels);
-    const stmt2 = getOrPrepareStatement(client, sql);
-    const useGet2 = shouldSqliteUseGet(method);
-    const rawResults2 = useGet2 ? stmt2.get(...normalizedParams) : stmt2.all(...normalizedParams);
-    const results2 = Array.isArray(rawResults2) ? rawResults2 : [rawResults2];
-    const transformed = shouldTransform ? results2.map(transformAggregateRow) : results2;
-    return reduceFlatRows(transformed, config);
-  }
   const stmt = getOrPrepareStatement(client, sql);
   const useGet = shouldSqliteUseGet(method);
   const rawResults = useGet ? stmt.get(...normalizedParams) : stmt.all(...normalizedParams);
@@ -9342,6 +9380,7 @@ exports.countIncludeDepth = countIncludeDepth;
 exports.createProgressiveReducer = createProgressiveReducer;
 exports.createStreamingReducer = createStreamingReducer;
 exports.createTransactionExecutor = createTransactionExecutor;
+exports.detectSqliteDateMode = detectSqliteDateMode;
 exports.executePostgresQuery = executePostgresQuery;
 exports.executeRaw = executeRaw;
 exports.executeSqliteQuery = executeSqliteQuery;
@@ -9362,6 +9401,7 @@ exports.planQueryStrategy = planQueryStrategy;
 exports.reduceFlatRows = reduceFlatRows;
 exports.reduceLateralRows = reduceLateralRows;
 exports.setJsonRowFactor = setJsonRowFactor;
+exports.setNormalizeDateMode = setNormalizeDateMode;
 exports.setRelationStats = setRelationStats;
 exports.setRoundtripRowEquivalent = setRoundtripRowEquivalent;
 exports.shouldSqliteUseGet = shouldSqliteUseGet;