prisma-sql 1.71.0 → 1.72.0

package/dist/generator.cjs

@@ -2323,7 +2323,7 @@ var require_package = __commonJS({
   "package.json"(exports$1, module) {
     module.exports = {
       name: "prisma-sql",
-      version: "1.71.0",
+      version: "1.72.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",
@@ -2389,13 +2389,13 @@ var require_package = __commonJS({
       license: "MIT",
       dependencies: {
         "@dee-wan/schema-parser": "1.4.0",
-        "@prisma/generator-helper": "^6.19.2",
-        "@prisma/internals": "^6.19.2"
+        "@prisma/generator-helper": "^7.4.0",
+        "@prisma/internals": "^7.4.0"
       },
       devDependencies: {
         "@faker-js/faker": "^10.2.0",
-        "@prisma/adapter-better-sqlite3": "^6.19.2",
-        "@prisma/adapter-pg": "^6.19.2",
+        "@prisma/adapter-better-sqlite3": "^7.4.0",
+        "@prisma/adapter-pg": "^7.4.0",
         "@semantic-release/changelog": "^6.0.3",
         "@semantic-release/git": "^10.0.1",
         "@types/better-sqlite3": "^7.6.13",
@@ -2409,8 +2409,8 @@ var require_package = __commonJS({
         tsx: "^4.21.0",
         typescript: "^5.9.3",
         vitest: "^4.0.18",
-        "@prisma/client": "6.19.2",
-        prisma: "6.19.2"
+        "@prisma/client": "7.4.0",
+        prisma: "7.4.0"
       },
       engines: {
         node: ">=16.0.0"
@@ -2418,6 +2418,241 @@ var require_package = __commonJS({
     };
   }
 });
+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";
@@ -3243,241 +3478,6 @@ 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;
@@ -7164,7 +7164,6 @@ var DEFAULT_SELECT_CACHE = /* @__PURE__ */ new WeakMap();
 function toSelectEntries(select2) {
   const out = [];
   for (const [k, v] of Object.entries(select2)) {
-    if (k === "_count") continue;
     if (v !== false && v !== void 0) out.push([k, v]);
   }
   return out;
@@ -7257,7 +7256,9 @@ function validateFieldKeys(entries, scalarSet, relationSet, allowCount = false)
     if (!scalarSet.has(k) && !relationSet.has(k)) unknown.push(k);
   }
   if (unknown.length > 0) {
-    throw new Error(`Select contains unknown fields: ${unknown.join(", ")}`);
+    throw new Error(
+      `Unknown field '${unknown.join("', '")}' does not exist on this model`
+    );
   }
 }
 function buildSelectedScalarParts(entries, scalarNames, alias, model) {
@@ -7449,12 +7450,41 @@ function buildNestedToOneSelects(relations, aliasMap) {
   }
   return selects;
 }
+function extractCountSelectFromRelArgs(relArgs) {
+  if (!isPlainObject(relArgs)) return null;
+  const obj = relArgs;
+  if (!isPlainObject(obj.select)) return null;
+  const sel = obj.select;
+  const countRaw = sel["_count"];
+  if (!countRaw) return null;
+  if (isPlainObject(countRaw) && "select" in countRaw) {
+    return countRaw.select;
+  }
+  return null;
+}
 function buildSelectWithNestedIncludes(relArgs, relModel, relAlias, ctx) {
   const nestedToOnes = extractNestedToOneRelations(
     relArgs,
     relModel,
     ctx.schemaByName
   );
+  const countSelect = extractCountSelectFromRelArgs(relArgs);
+  const countJoins = [];
+  function appendCountToSelect(baseSelect2) {
+    if (!countSelect || Object.keys(countSelect).length === 0) return baseSelect2;
+    const countBuild = buildRelationCountSql(
+      countSelect,
+      relModel,
+      ctx.schemas,
+      relAlias,
+      ctx.params,
+      ctx.dialect
+    );
+    if (!countBuild.jsonPairs) return baseSelect2;
+    countJoins.push(...countBuild.joins);
+    const countExpr = `'_count', ${jsonBuildObject(countBuild.jsonPairs, ctx.dialect)}`;
+    return baseSelect2 ? `${baseSelect2}${SQL_SEPARATORS.FIELD_LIST}${countExpr}` : countExpr;
+  }
   if (nestedToOnes.length === 0) {
     let relSelect = buildRelationSelect(relArgs, relModel, relAlias);
     let nestedIncludes = [];
@@ -7483,7 +7513,8 @@ function buildSelectWithNestedIncludes(relArgs, relModel, relAlias, ctx) {
       ).join(SQL_SEPARATORS.FIELD_LIST);
       relSelect = isNotNullish(relSelect) && relSelect.trim().length > 0 ? `${relSelect}${SQL_SEPARATORS.FIELD_LIST}${nestedSelects2}` : nestedSelects2;
     }
-    return { select: relSelect, nestedJoins: [] };
+    relSelect = appendCountToSelect(relSelect);
+    return { select: relSelect, nestedJoins: countJoins };
   }
   const { joins, aliasMap } = buildNestedToOneJoins(
     nestedToOnes,
@@ -7501,9 +7532,11 @@ function buildSelectWithNestedIncludes(relArgs, relModel, relAlias, ctx) {
   for (const ns of nestedSelects) {
     allParts.push(ns);
   }
+  let finalSelect = allParts.join(SQL_SEPARATORS.FIELD_LIST);
+  finalSelect = appendCountToSelect(finalSelect);
   return {
-    select: allParts.join(SQL_SEPARATORS.FIELD_LIST),
-    nestedJoins: joins
+    select: finalSelect,
+    nestedJoins: [...joins, ...countJoins]
   };
 }
 function buildWhereParts(whereInput, relModel, relAlias, ctx) {
@@ -7885,7 +7918,7 @@ function validateDistinct(model, distinct) {
       const relationSet = getRelationFieldSet(model);
       if (relationSet.has(f)) {
         throw new Error(
-          `distinct field '${f}' is a relation. Only scalar fields are allowed.
+          `distinct field '${f}' is a relation field. Only scalar fields are allowed.
 Available scalar fields: ${[...scalarSet].join(", ")}`
         );
       }
@@ -7923,7 +7956,7 @@ function validateOrderBy(model, orderBy) {
     if (!scalarSet.has(f)) {
       if (relationSet.has(f)) {
         throw new Error(
-          `orderBy field '${f}' is a relation. Only scalar fields are allowed.
+          `orderBy field '${f}' is a relation field. Only scalar fields are allowed.
 Available scalar fields: ${[...scalarSet].join(", ")}`
         );
       }