prisma-sql 1.71.0 → 1.73.0

package/dist/index.cjs

@@ -57,6 +57,265 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
+// 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 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({
@@ -761,406 +1020,155 @@ function normalizeKeyList(input) {
 }
 
 // src/builder/shared/model-field-cache.ts
-var FIELD_INDICES_CACHE = /* @__PURE__ */ new WeakMap();
-function normalizeField(field) {
-  return field;
-}
-function getFieldIndices(model) {
-  var _a3;
-  let cached = FIELD_INDICES_CACHE.get(model);
-  if (cached) return cached;
-  const scalarFields = /* @__PURE__ */ new Map();
-  const relationFields = /* @__PURE__ */ new Map();
-  const allFieldsByName = /* @__PURE__ */ new Map();
-  const scalarNames = [];
-  const relationNames = [];
-  const jsonFields = /* @__PURE__ */ new Set();
-  const pkFields = [];
-  const columnMap = /* @__PURE__ */ new Map();
-  const quotedColumns = /* @__PURE__ */ new Map();
-  for (const rawField of model.fields) {
-    const field = normalizeField(rawField);
-    allFieldsByName.set(field.name, field);
-    if (field.isRelation) {
-      relationFields.set(field.name, field);
-      relationNames.push(field.name);
-    } else {
-      scalarFields.set(field.name, field);
-      scalarNames.push(field.name);
-      const fieldType = String((_a3 = field.type) != null ? _a3 : "").toLowerCase();
-      if (fieldType === "json") {
-        jsonFields.add(field.name);
-      }
-      if (field.isId || field.isPrimaryKey || field.primaryKey) {
-        pkFields.push(field.name);
-      }
-      if (field.dbName && field.dbName !== field.name) {
-        columnMap.set(field.name, field.dbName);
-      }
-      const columnName = field.dbName || field.name;
-      quotedColumns.set(field.name, quote(columnName));
-    }
-  }
-  cached = Object.freeze({
-    scalarFields,
-    relationFields,
-    allFieldsByName,
-    scalarNames,
-    relationNames,
-    jsonFields,
-    pkFields,
-    columnMap,
-    quotedColumns
-  });
-  FIELD_INDICES_CACHE.set(model, cached);
-  return cached;
-}
-function getRelationFieldSet(model) {
-  return new Set(getFieldIndices(model).relationNames);
-}
-function getScalarFieldSet(model) {
-  return new Set(getFieldIndices(model).scalarNames);
-}
-function getColumnMap(model) {
-  return getFieldIndices(model).columnMap;
-}
-function getScalarFieldNames(model) {
-  return [...getFieldIndices(model).scalarNames];
-}
-function getQuotedColumn(model, fieldName) {
-  return getFieldIndices(model).quotedColumns.get(fieldName);
-}
-function getJsonFieldSet(model) {
-  return getFieldIndices(model).jsonFields;
-}
-function parseJsonIfNeeded(isJson, value) {
-  if (!isJson) return value;
-  if (value == null) return value;
-  if (typeof value !== "string") return value;
-  try {
-    return JSON.parse(value);
-  } catch (e) {
-    return value;
-  }
-}
-function maybeParseJson(value, jsonSet, fieldName) {
-  if (!jsonSet.has(fieldName)) return value;
-  if (value == null) return value;
-  if (typeof value !== "string") return value;
-  try {
-    return JSON.parse(value);
-  } catch (e) {
-    return value;
-  }
-}
-
-// src/builder/joins.ts
-function isRelationField(fieldName, model) {
-  return getRelationFieldSet(model).has(fieldName);
-}
-function isValidRelationField(field) {
-  if (!isNotNullish(field)) return false;
-  if (!field.isRelation) return false;
-  if (!isNotNullish(field.relatedModel) || field.relatedModel.trim().length === 0)
-    return false;
-  const fk = normalizeKeyList(field.foreignKey);
-  if (fk.length === 0) return false;
-  const refs = normalizeKeyList(field.references);
-  if (refs.length === 0) {
-    return fk.length === 1;
-  }
-  if (refs.length !== fk.length) return false;
-  return true;
-}
-function getReferenceFieldNames(field, foreignKeyCount) {
-  const refs = normalizeKeyList(field.references);
-  if (refs.length === 0) {
-    if (foreignKeyCount === 1) return [SPECIAL_FIELDS.ID];
-    return [];
-  }
-  if (refs.length !== foreignKeyCount) return [];
-  return refs;
-}
-function joinCondition(field, parentModel, childModel, parentAlias, childAlias) {
-  assertSafeAlias(parentAlias);
-  assertSafeAlias(childAlias);
-  const fkFields = normalizeKeyList(field.foreignKey);
-  if (fkFields.length === 0) {
-    throw createError(
-      `Relation '${field.name}' is missing foreignKey. This indicates a schema parsing error. Relations must specify fields/references.`,
-      { 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
-    )
-  )`;
+var FIELD_INDICES_CACHE = /* @__PURE__ */ new WeakMap();
+function normalizeField(field) {
+  return field;
 }
-function arrayIsEmpty(column, dialect) {
-  assertNonEmpty(column, "arrayIsEmpty column");
-  if (dialect === "postgres") {
-    return `(${column} IS NULL OR array_length(${column}, 1) IS NULL)`;
+function getFieldIndices(model) {
+  var _a3;
+  let cached = FIELD_INDICES_CACHE.get(model);
+  if (cached) return cached;
+  const scalarFields = /* @__PURE__ */ new Map();
+  const relationFields = /* @__PURE__ */ new Map();
+  const allFieldsByName = /* @__PURE__ */ new Map();
+  const scalarNames = [];
+  const relationNames = [];
+  const jsonFields = /* @__PURE__ */ new Set();
+  const pkFields = [];
+  const columnMap = /* @__PURE__ */ new Map();
+  const quotedColumns = /* @__PURE__ */ new Map();
+  for (const rawField of model.fields) {
+    const field = normalizeField(rawField);
+    allFieldsByName.set(field.name, field);
+    if (field.isRelation) {
+      relationFields.set(field.name, field);
+      relationNames.push(field.name);
+    } else {
+      scalarFields.set(field.name, field);
+      scalarNames.push(field.name);
+      const fieldType = String((_a3 = field.type) != null ? _a3 : "").toLowerCase();
+      if (fieldType === "json") {
+        jsonFields.add(field.name);
+      }
+      if (field.isId || field.isPrimaryKey || field.primaryKey) {
+        pkFields.push(field.name);
+      }
+      if (field.dbName && field.dbName !== field.name) {
+        columnMap.set(field.name, field.dbName);
+      }
+      const columnName = field.dbName || field.name;
+      quotedColumns.set(field.name, quote(columnName));
+    }
   }
-  return `(${column} IS NULL OR json_array_length(${column}) = 0)`;
+  cached = Object.freeze({
+    scalarFields,
+    relationFields,
+    allFieldsByName,
+    scalarNames,
+    relationNames,
+    jsonFields,
+    pkFields,
+    columnMap,
+    quotedColumns
+  });
+  FIELD_INDICES_CACHE.set(model, cached);
+  return cached;
 }
-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 getRelationFieldSet(model) {
+  return new Set(getFieldIndices(model).relationNames);
 }
-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 getScalarFieldSet(model) {
+  return new Set(getFieldIndices(model).scalarNames);
 }
-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 getColumnMap(model) {
+  return getFieldIndices(model).columnMap;
 }
-function caseInsensitiveEquals(column, value, dialect) {
-  assertNonEmpty(column, "caseInsensitiveEquals column");
-  assertNonEmpty(value, "caseInsensitiveEquals value");
-  return `LOWER(${column}) = LOWER(${value})`;
+function getScalarFieldNames(model) {
+  return [...getFieldIndices(model).scalarNames];
 }
-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 getQuotedColumn(model, fieldName) {
+  return getFieldIndices(model).quotedColumns.get(fieldName);
 }
-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 getJsonFieldSet(model) {
+  return getFieldIndices(model).jsonFields;
 }
-function jsonToText(column, dialect) {
-  assertNonEmpty(column, "jsonToText column");
-  if (dialect === "postgres") {
-    return `${column}::text`;
+function parseJsonIfNeeded(isJson, value) {
+  if (!isJson) return value;
+  if (value == null) return value;
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch (e) {
+    return value;
   }
-  return column;
 }
-function inArray(column, value, dialect) {
-  assertNonEmpty(column, "inArray column");
-  assertNonEmpty(value, "inArray value");
-  if (dialect === "postgres") {
-    return `${column} = ANY(${value})`;
+function maybeParseJson(value, jsonSet, fieldName) {
+  if (!jsonSet.has(fieldName)) return value;
+  if (value == null) return value;
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch (e) {
+    return 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}))`;
+
+// src/builder/joins.ts
+function isRelationField(fieldName, model) {
+  return getRelationFieldSet(model).has(fieldName);
 }
-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 isValidRelationField(field) {
+  if (!isNotNullish(field)) return false;
+  if (!field.isRelation) return false;
+  if (!isNotNullish(field.relatedModel) || field.relatedModel.trim().length === 0)
+    return false;
+  const fk = normalizeKeyList(field.foreignKey);
+  if (fk.length === 0) return false;
+  const refs = normalizeKeyList(field.references);
+  if (refs.length === 0) {
+    return fk.length === 1;
   }
+  if (refs.length !== fk.length) return false;
+  return true;
 }
-function jsonAgg(content, dialect) {
-  assertNonEmpty(content, "jsonAgg content");
-  if (dialect === "postgres") {
-    return `json_agg(${content})`;
+function getReferenceFieldNames(field, foreignKeyCount) {
+  const refs = normalizeKeyList(field.references);
+  if (refs.length === 0) {
+    if (foreignKeyCount === 1) return [SPECIAL_FIELDS.ID];
+    return [];
   }
-  return `json_group_array(${content})`;
+  if (refs.length !== foreignKeyCount) return [];
+  return refs;
 }
-function jsonBuildObject(pairs, dialect) {
-  const safePairs = (pairs != null ? pairs : "").trim();
-  if (dialect === "postgres") {
-    return safePairs.length > 0 ? `json_build_object(${safePairs})` : `json_build_object()`;
+function joinCondition(field, parentModel, childModel, parentAlias, childAlias) {
+  assertSafeAlias(parentAlias);
+  assertSafeAlias(childAlias);
+  const fkFields = normalizeKeyList(field.foreignKey);
+  if (fkFields.length === 0) {
+    throw createError(
+      `Relation '${field.name}' is missing foreignKey. This indicates a schema parsing error. Relations must specify fields/references.`,
+      { field: field.name }
+    );
   }
-  return safePairs.length > 0 ? `json_object(${safePairs})` : `json_object()`;
-}
-function prepareArrayParam(value, dialect) {
-  if (!Array.isArray(value)) {
-    throw new Error("prepareArrayParam requires array value");
+  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 }
+    );
   }
-  if (dialect === "postgres") {
-    return value.map((v) => normalizeValue(v));
+  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.stringify(value.map((v) => normalizeValue(v)));
+  return parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
+}
+function getModelByName(schemas, name) {
+  return schemas.find((m) => m.name === name);
 }
 function normalizeIntLike(name, v, opts = {}) {
   var _a3, _b;
@@ -4868,7 +4876,6 @@ var DEFAULT_SELECT_CACHE = /* @__PURE__ */ new WeakMap();
 function toSelectEntries(select) {
   const out = [];
   for (const [k, v] of Object.entries(select)) {
-    if (k === "_count") continue;
     if (v !== false && v !== void 0) out.push([k, v]);
   }
   return out;
@@ -4961,7 +4968,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) {
@@ -5142,23 +5151,56 @@ function buildNestedToOneJoins(relations, baseAlias, baseModel, aliasGen, dialec
   }
   return { joins, aliasMap };
 }
-function buildNestedToOneSelects(relations, aliasMap) {
+function buildNestedToOneSelects(relations, aliasMap, dialect) {
   const selects = [];
   for (const rel of relations) {
     const relAlias = aliasMap.get(rel.name);
     if (!relAlias) continue;
     const relSelect = buildRelationSelect(rel.args, rel.model, relAlias);
     if (!relSelect || relSelect.trim().length === 0) continue;
-    selects.push(`${sqlStringLiteral(rel.name)}, ${relSelect}`);
+    const jsonExpr = jsonBuildObject(relSelect, dialect);
+    const pkField = getPrimaryKeyField(rel.model);
+    const pkCol = `${relAlias}.${quoteColumn(rel.model, pkField)}`;
+    const nullSafeExpr = `CASE WHEN ${pkCol} IS NOT NULL THEN ${jsonExpr} ELSE NULL END`;
+    selects.push(`${sqlStringLiteral(rel.name)}, ${nullSafeExpr}`);
   }
   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 = [];
@@ -5187,7 +5229,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,
@@ -5197,7 +5240,11 @@ function buildSelectWithNestedIncludes(relArgs, relModel, relAlias, ctx) {
     ctx.dialect
   );
   const baseSelect = buildRelationSelect(relArgs, relModel, relAlias);
-  const nestedSelects = buildNestedToOneSelects(nestedToOnes, aliasMap);
+  const nestedSelects = buildNestedToOneSelects(
+    nestedToOnes,
+    aliasMap,
+    ctx.dialect
+  );
   const allParts = [];
   if (baseSelect && baseSelect.trim().length > 0) {
     allParts.push(baseSelect);
@@ -5205,9 +5252,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) {
@@ -5589,7 +5638,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(", ")}`
         );
       }
@@ -5627,7 +5676,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(", ")}`
         );
       }
@@ -9367,6 +9416,26 @@ function executeRaw(client, sql, params, dialect) {
 function buildSQL(model, models, method, args, dialect) {
   return buildSQLWithCache(model, models, method, args, dialect);
 }
+function createToSQLFunction(models, dialect) {
+  if (!models || !Array.isArray(models) || models.length === 0) {
+    throw new Error("createToSQL requires non-empty models array");
+  }
+  const modelMap = new Map(models.map((m) => [m.name, m]));
+  setGlobalDialect(dialect);
+  return function toSQL(model, method, args = {}) {
+    const m = modelMap.get(model);
+    if (!m) {
+      throw new Error(
+        `Model '${model}' not found. Available: ${[...modelMap.keys()].join(", ")}`
+      );
+    }
+    return buildSQL(m, models, method, args, dialect);
+  };
+}
+function createToSQL(modelsOrDmmf, dialect) {
+  const models = Array.isArray(modelsOrDmmf) ? modelsOrDmmf : schemaParser.convertDMMFToModels(modelsOrDmmf.datamodel);
+  return createToSQLFunction(models, dialect);
+}
 function generateSQL2(directive) {
   return generateSQL(directive);
 }
@@ -9379,6 +9448,7 @@ exports.buildSQL = buildSQL;
 exports.countIncludeDepth = countIncludeDepth;
 exports.createProgressiveReducer = createProgressiveReducer;
 exports.createStreamingReducer = createStreamingReducer;
+exports.createToSQL = createToSQL;
 exports.createTransactionExecutor = createTransactionExecutor;
 exports.detectSqliteDateMode = detectSqliteDateMode;
 exports.executePostgresQuery = executePostgresQuery;