prisma-sql 1.36.0 → 1.38.0

package/dist/index.cjs

@@ -196,7 +196,7 @@ function getArrayType(prismaType, dialect) {
     case "DateTime":
       return "timestamptz[]";
     default:
-      return "text[]";
+      return `"${baseType}"[]`;
   }
 }
 function jsonAgg(content, dialect) {
@@ -1841,7 +1841,7 @@ function buildLogical(operator, value, ctx, builder) {
 }
 function buildScalarField(fieldName, value, ctx) {
   const field = assertFieldExists(fieldName, ctx.model, ctx.path);
-  const expr = col(ctx.alias, fieldName);
+  const expr = col(ctx.alias, fieldName, ctx.model);
   if (value === null) {
     return freezeResult(`${expr} ${SQL_TEMPLATES.IS_NULL}`, EMPTY_JOINS);
   }
@@ -3329,8 +3329,8 @@ function replaceOrderByAlias(orderBy, fromAlias, outerAlias) {
   const replacement = `${outerAlias}.`;
   return orderBy.split(needle).join(replacement);
 }
-function buildDistinctColumns(distinct, fromAlias) {
-  return distinct.map((f) => col(fromAlias, f)).join(SQL_SEPARATORS.FIELD_LIST);
+function buildDistinctColumns(distinct, fromAlias, model) {
+  return distinct.map((f) => col(fromAlias, f, model)).join(SQL_SEPARATORS.FIELD_LIST);
 }
 function buildOutputColumns(scalarNames, includeNames, hasCount) {
   const outputCols = [...scalarNames, ...includeNames];
@@ -3344,13 +3344,13 @@ function buildOutputColumns(scalarNames, includeNames, hasCount) {
   return formatted;
 }
 function buildWindowOrder(args) {
-  const { baseOrder, idField, fromAlias } = args;
+  const { baseOrder, idField, fromAlias, model } = args;
   const orderFields = baseOrder.split(SQL_SEPARATORS.ORDER_BY).map((s) => s.trim().toLowerCase());
   const hasIdInOrder = orderFields.some(
     (f) => f.startsWith(`${fromAlias}.id `) || f.startsWith(`${fromAlias}."id" `)
   );
   if (hasIdInOrder) return baseOrder;
-  const idTiebreaker = idField ? `, ${col(fromAlias, "id")} ASC` : "";
+  const idTiebreaker = idField ? `, ${col(fromAlias, "id", model)} ASC` : "";
   return `${baseOrder}${idTiebreaker}`;
 }
 function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
@@ -3367,14 +3367,17 @@ function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
     includeNames,
     hasCount
   );
-  const distinctCols = buildDistinctColumns([...distinct], from.alias);
-  const fallbackOrder = [...distinct].map((f) => `${col(from.alias, f)} ASC`).join(SQL_SEPARATORS.FIELD_LIST);
-  const idField = model.fields.find((f) => f.name === "id" && !f.isRelation);
+  const distinctCols = buildDistinctColumns([...distinct], from.alias, model);
+  const fallbackOrder = [...distinct].map((f) => `${col(from.alias, f, model)} ASC`).join(SQL_SEPARATORS.FIELD_LIST);
+  const idField = model.fields.find(
+    (f) => f.name === "id" && !f.isRelation
+  );
   const baseOrder = isNonEmptyString(orderBy) ? orderBy : fallbackOrder;
   const windowOrder = buildWindowOrder({
     baseOrder,
     idField,
-    fromAlias: from.alias
+    fromAlias: from.alias,
+    model
   });
   const outerOrder = isNonEmptyString(orderBy) ? replaceOrderByAlias(orderBy, from.alias, `"__tp_distinct"`) : replaceOrderByAlias(fallbackOrder, from.alias, `"__tp_distinct"`);
   const joins = buildJoinsSql(whereJoins, countJoins);
@@ -3485,9 +3488,9 @@ function withCountJoins(spec, countJoins, whereJoins) {
     whereJoins: [...whereJoins || [], ...countJoins || []]
   });
 }
-function buildPostgresDistinctOnClause(fromAlias, distinct) {
+function buildPostgresDistinctOnClause(fromAlias, distinct, model) {
   if (!isNonEmptyArray(distinct)) return null;
-  const distinctCols = buildDistinctColumns([...distinct], fromAlias);
+  const distinctCols = buildDistinctColumns([...distinct], fromAlias, model);
   return `${SQL_TEMPLATES.DISTINCT_ON} (${distinctCols})`;
 }
 function pushJoinGroups(parts, ...groups) {
@@ -3517,7 +3520,8 @@ function constructFinalSql(spec) {
     method,
     cursorClause,
     params,
-    dialect
+    dialect,
+    model
   } = spec;
   const useWindowDistinct = hasWindowDistinct(spec);
   assertDistinctAllowed(method, useWindowDistinct);
@@ -3531,7 +3535,7 @@ function constructFinalSql(spec) {
     return finalizeSql(sql2, params);
   }
   const parts = [SQL_TEMPLATES.SELECT];
-  const distinctOn = dialect === "postgres" ? buildPostgresDistinctOnClause(from.alias, distinct) : null;
+  const distinctOn = dialect === "postgres" ? buildPostgresDistinctOnClause(from.alias, distinct, model) : null;
   if (distinctOn) parts.push(distinctOn);
   const baseSelect = (select != null ? select : "").trim();
   const fullSelectList = buildSelectList(baseSelect, includeCols);
@@ -3791,17 +3795,17 @@ function getModelFieldMap(model) {
 function isTruthySelection(v) {
   return v === true;
 }
-function aggExprForField(aggKey, field, alias) {
+function aggExprForField(aggKey, field, alias, model) {
   if (aggKey === "_count") {
-    return field === "_all" ? `COUNT(*)` : `COUNT(${col(alias, field)})`;
+    return field === "_all" ? `COUNT(*)` : `COUNT(${col(alias, field, model)})`;
   }
   if (field === "_all") {
     throw new Error(`'${aggKey}' does not support '_all'`);
   }
-  if (aggKey === "_sum") return `SUM(${col(alias, field)})`;
-  if (aggKey === "_avg") return `AVG(${col(alias, field)})`;
-  if (aggKey === "_min") return `MIN(${col(alias, field)})`;
-  return `MAX(${col(alias, field)})`;
+  if (aggKey === "_sum") return `SUM(${col(alias, field, model)})`;
+  if (aggKey === "_avg") return `AVG(${col(alias, field, model)})`;
+  if (aggKey === "_min") return `MIN(${col(alias, field, model)})`;
+  return `MAX(${col(alias, field, model)})`;
 }
 function buildComparisonOp(op) {
   const sqlOp = COMPARISON_OPS[op];
@@ -3982,7 +3986,7 @@ function buildHavingForAggregateFirstShape(aggKey, target, alias, params, dialec
   for (const [field, filter] of Object.entries(target)) {
     assertHavingAggTarget(aggKey, field, model);
     if (!isPlainObject(filter) || Object.keys(filter).length === 0) continue;
-    const expr = aggExprForField(aggKey, field, alias);
+    const expr = aggExprForField(aggKey, field, alias, model);
     out.push(...buildHavingOpsForExpr(expr, filter, params, dialect));
   }
   return out;
@@ -3999,7 +4003,7 @@ function buildHavingForFieldFirstShape(fieldName, target, alias, params, dialect
     assertAggregateFieldType(aggKey, field.type, field.name, model.name);
     const entries = Object.entries(aggFilter);
     if (entries.length === 0) continue;
-    const expr = aggExprForField(aggKey, fieldName, alias);
+    const expr = aggExprForField(aggKey, fieldName, alias, model);
     for (const [op, val] of entries) {
       if (op === "mode") continue;
       const built = buildSimpleComparison(expr, op, val, params, dialect);
@@ -4038,10 +4042,10 @@ function assertCountableScalarField(fieldMap, model, fieldName) {
     );
   }
 }
-function pushCountField(fields, alias, fieldName) {
+function pushCountField(fields, alias, fieldName, model) {
   const outAlias = `_count.${fieldName}`;
   fields.push(
-    `COUNT(${col(alias, fieldName)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
+    `COUNT(${col(alias, fieldName, model)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
   );
 }
 function addCountFields(fields, countArg, alias, model, fieldMap) {
@@ -4059,7 +4063,7 @@ function addCountFields(fields, countArg, alias, model, fieldMap) {
   );
   for (const [f] of selected) {
     assertCountableScalarField(fieldMap, model, f);
-    pushCountField(fields, alias, f);
+    pushCountField(fields, alias, f, model);
   }
 }
 function getAggregateSelectionObject(args, agg) {
@@ -4080,10 +4084,10 @@ function assertAggregatableScalarField(fieldMap, model, agg, fieldName) {
   }
   return field;
 }
-function pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName) {
+function pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName, model) {
   const outAlias = `${agg}.${fieldName}`;
   fields.push(
-    `${aggFn}(${col(alias, fieldName)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
+    `${aggFn}(${col(alias, fieldName, model)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
   );
 }
 function addAggregateFields(fields, args, alias, model, fieldMap) {
@@ -4101,7 +4105,7 @@ function addAggregateFields(fields, args, alias, model, fieldMap) {
         fieldName
       );
       assertAggregateFieldType(agg, field.type, fieldName, model.name);
-      pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName);
+      pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName, model);
     }
   }
 }
@@ -4164,7 +4168,7 @@ function assertGroupByBy(args, model) {
   return byFields;
 }
 function buildGroupBySelectParts(args, alias, model, byFields) {
-  const groupCols = byFields.map((f) => col(alias, f));
+  const groupCols = byFields.map((f) => col(alias, f, model));
   const groupFields = groupCols.join(SQL_SEPARATORS.FIELD_LIST);
   const aggFields = buildAggregateFields(args, alias, model);
   const selectFields = isNonEmptyArray(aggFields) ? groupCols.concat(aggFields).join(SQL_SEPARATORS.FIELD_LIST) : groupCols.join(SQL_SEPARATORS.FIELD_LIST);