prisma-sql 1.69.0 → 1.71.0

package/dist/generator.js

@@ -2312,7 +2312,7 @@ var require_package = __commonJS({
   "package.json"(exports$1, module) {
     module.exports = {
       name: "prisma-sql",
-      version: "1.69.0",
+      version: "1.71.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",
@@ -2378,13 +2378,13 @@ var require_package = __commonJS({
       license: "MIT",
       dependencies: {
         "@dee-wan/schema-parser": "1.4.0",
-        "@prisma/generator-helper": "^7.4.0",
-        "@prisma/internals": "^7.4.0"
+        "@prisma/generator-helper": "^6.19.2",
+        "@prisma/internals": "^6.19.2"
       },
       devDependencies: {
         "@faker-js/faker": "^10.2.0",
-        "@prisma/adapter-better-sqlite3": "^7.4.0",
-        "@prisma/adapter-pg": "^7.4.0",
+        "@prisma/adapter-better-sqlite3": "^6.19.2",
+        "@prisma/adapter-pg": "^6.19.2",
         "@semantic-release/changelog": "^6.0.3",
         "@semantic-release/git": "^10.0.1",
         "@types/better-sqlite3": "^7.6.13",
@@ -2398,8 +2398,8 @@ var require_package = __commonJS({
         tsx: "^4.21.0",
         typescript: "^5.9.3",
         vitest: "^4.0.18",
-        "@prisma/client": "7.4.0",
-        prisma: "7.4.0"
+        "@prisma/client": "6.19.2",
+        prisma: "6.19.2"
       },
       engines: {
         node: ">=16.0.0"
@@ -2408,243 +2408,6 @@ var require_package = __commonJS({
   }
 });
 
-// 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 setGlobalDialect(dialect) {
-  if (dialect !== "postgres" && dialect !== "sqlite") {
-    throw new Error(
-      `Invalid dialect: ${dialect}. Must be 'postgres' or 'sqlite'`
-    );
-  }
-  globalDialect = dialect;
-}
-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({
@@ -3469,6 +3232,241 @@ function joinCondition(field, parentModel, childModel, parentAlias, childAlias)
 function getModelByName(schemas, name) {
   return schemas.find((m) => m.name === name);
 }
+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 setGlobalDialect(dialect) {
+  if (dialect !== "postgres" && dialect !== "sqlite") {
+    throw new Error(
+      `Invalid dialect: ${dialect}. Must be 'postgres' or 'sqlite'`
+    );
+  }
+  globalDialect = dialect;
+}
+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)));
+}
 function normalizeIntLike(name, v, opts = {}) {
   var _a3, _b;
   if (!isNotNullish(v)) return void 0;
@@ -4587,14 +4585,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,
@@ -4660,19 +4659,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;
@@ -4680,7 +4686,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;
       }
     }
@@ -8445,9 +8456,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");
@@ -8466,7 +8478,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],
@@ -8545,7 +8557,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,
@@ -8562,7 +8574,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 = [
@@ -8578,7 +8590,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],
@@ -8590,14 +8602,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 select2 = {};
   for (const f of selectFields) select2[f] = true;
@@ -8605,7 +8618,6 @@ function buildCountSql(whereResult, tableName, alias, argsOrSkip, dialect, model
     include: void 0,
     select: select2
   });
-  const d = dialect != null ? dialect : getGlobalDialect();
   const subSchemas = Array.isArray(schemas) && schemas.length > 0 ? schemas : [model];
   const sub = buildSelectSql({
     method: "findMany",
@@ -8621,7 +8633,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,
@@ -8765,7 +8777,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(
@@ -10017,6 +10036,8 @@ function generateImports(runtimeImportPath) {
   createTransactionExecutor, 
   transformQueryResults, 
   normalizeValue, 
+  setNormalizeDateMode,
+  detectSqliteDateMode,
   planQueryStrategy, 
   executeWhereInSegments,
   buildReducerConfig,
@@ -10389,7 +10410,11 @@ function generateExtension(runtimeImportPath) {
     throw new Error(\`Generated code is for \${DIALECT}, but you provided \${actualDialect}\`)
   }
 
-async function executeQuery(
+  if ((DIALECT as string) === 'sqlite') {
+    setNormalizeDateMode(detectSqliteDateMode(client))
+  }
+
+  async function executeQuery(
     sql: string,
     params: unknown[],
     method: string,
@@ -10413,8 +10438,14 @@ async function executeQuery(
         lateralMeta,
       })
     }
-    
-    return executeSqliteQuery(client, sql, params, method, requiresReduction, includeSpec, model, MODELS)
+  
+    try {
+      const result = executeSqliteQuery(client, sql, params, method)
+      return result
+    } catch (err) {
+      console.log('[sqlite-debug] FAILED:', err instanceof Error ? err.message : err)
+      throw err
+    }
   }
 
   async function executeWhereInQuery(sql: string, params: unknown[]): Promise<unknown[]> {