prisma-sql 1.74.0 → 1.75.1

package/dist/index.js

@@ -1226,7 +1226,7 @@ var getNextSort = (sortRaw) => {
   if (s === "desc") return "asc";
   return sortRaw;
 };
-var flipObjectSort = (obj) => {
+var flipScalarSortObject = (obj) => {
   const out = __spreadValues({}, obj);
   const hasSort = Object.prototype.hasOwnProperty.call(obj, "sort");
   const hasDirection = Object.prototype.hasOwnProperty.call(obj, "direction");
@@ -1242,26 +1242,64 @@ var flipObjectSort = (obj) => {
   }
   return out;
 };
+function isScalarSortConfig(obj) {
+  return Object.prototype.hasOwnProperty.call(obj, "sort") || Object.prototype.hasOwnProperty.call(obj, "direction");
+}
+function flipRelationOrderByValue(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    out[k] = flipValue(v);
+  }
+  return out;
+}
 var flipValue = (v) => {
   if (typeof v === "string") return flipSortString(v);
-  if (isPlainObject(v)) return flipObjectSort(v);
+  if (isPlainObject(v)) {
+    if (isScalarSortConfig(v)) return flipScalarSortObject(v);
+    return flipRelationOrderByValue(v);
+  }
   return v;
 };
-var assertSingleFieldObject = (item) => {
+var expandToSingleFieldEntries = (item) => {
   if (!isPlainObject(item)) {
     throw new Error("orderBy array entries must be objects");
   }
   const entries = Object.entries(item);
-  if (entries.length !== 1) {
-    throw new Error("orderBy array entries must have exactly one field");
+  if (entries.length === 0) {
+    throw new Error("orderBy array entries must have at least one field");
   }
-  return entries[0];
+  return entries;
 };
+function expandOrderByInput(orderBy) {
+  if (!isNotNullish(orderBy)) return [];
+  if (Array.isArray(orderBy)) {
+    const result = [];
+    for (const item of orderBy) {
+      result.push(...expandToSingleFieldEntries(item));
+    }
+    return result;
+  }
+  if (isPlainObject(orderBy)) {
+    return Object.entries(orderBy);
+  }
+  throw new Error("orderBy must be an object or array of objects");
+}
+function isScalarOrderByValue(v) {
+  if (typeof v === "string") {
+    const lower = v.toLowerCase();
+    return lower === "asc" || lower === "desc";
+  }
+  if (isPlainObject(v) && isScalarSortConfig(v)) return true;
+  return false;
+}
 var flipOrderByArray = (orderBy) => {
-  return orderBy.map((item) => {
-    const [k, v] = assertSingleFieldObject(item);
-    return { [k]: flipValue(v) };
-  });
+  const result = [];
+  for (const item of orderBy) {
+    for (const [k, v] of expandToSingleFieldEntries(item)) {
+      result.push({ [k]: flipValue(v) });
+    }
+  }
+  return result;
 };
 var flipOrderByObject = (orderBy) => {
   const out = {};
@@ -1281,18 +1319,24 @@ function reverseOrderByInput(orderBy) {
   throw new Error("orderBy must be an object or array of objects");
 }
 var normalizePairs = (pairs, parseValue) => {
-  return pairs.map(([field, rawValue]) => {
+  const result = [];
+  for (const [field, rawValue] of pairs) {
+    if (!isScalarOrderByValue(rawValue)) continue;
     const parsed = parseValue(rawValue, field);
-    return {
+    result.push({
       [field]: parsed.nulls !== void 0 ? { direction: parsed.direction, nulls: parsed.nulls } : parsed.direction
-    };
-  });
+    });
+  }
+  return result;
 };
 function normalizeOrderByInput(orderBy, parseValue) {
   if (!isNotNullish(orderBy)) return [];
   if (Array.isArray(orderBy)) {
-    const pairs = orderBy.map(assertSingleFieldObject);
-    return normalizePairs(pairs, parseValue);
+    const allPairs = [];
+    for (const item of orderBy) {
+      allPairs.push(...expandToSingleFieldEntries(item));
+    }
+    return normalizePairs(allPairs, parseValue);
   }
   if (isPlainObject(orderBy)) {
     return normalizePairs(Object.entries(orderBy), parseValue);
@@ -1304,9 +1348,11 @@ function normalizeAndValidateOrderBy(orderBy, model, parseValue) {
   const normalized = normalizeOrderByInput(orderBy, parseValue);
   const entries = [];
   const scalarSet = getScalarFieldSet(model);
+  const relationSet = getRelationFieldSet(model);
   for (const item of normalized) {
     const [[field, value]] = Object.entries(item);
     if (!scalarSet.has(field)) {
+      if (relationSet.has(field)) continue;
       throw new Error(
         `orderBy field '${field}' not found on model ${model.name}`
       );
@@ -1765,16 +1811,6 @@ function buildOrderBy(orderBy, alias, dialect, model) {
   const d = dialect != null ? dialect : getGlobalDialect();
   return buildOrderByFragment(entries, alias, d, model);
 }
-function buildOrderByClause(args, alias, dialect, model) {
-  if (!isNotNullish(args.orderBy)) return "";
-  const result = buildOrderBy(args.orderBy, alias, dialect, model);
-  if (!isNonEmptyString(result)) {
-    throw new Error(
-      "buildOrderByClause: orderBy specified but produced empty result"
-    );
-  }
-  return result;
-}
 function normalizeTakeLike(v) {
   const n = normalizeIntLike("take", v, {
     min: Number.MIN_SAFE_INTEGER,
@@ -5569,6 +5605,114 @@ function buildIncludeSql(args, model, schemas, parentAlias, params, dialect, out
   });
 }
 
+// src/builder/shared/order-by-relation.ts
+function resolveTableRef(model, dialect) {
+  const tableName = model.tableName || model.dbName || model.name;
+  if (dialect === "sqlite") {
+    return quote(tableName);
+  }
+  const schema = model.schema || model.schemaName || "public";
+  return buildTableReference(schema, tableName, dialect);
+}
+function findRelationField(model, fieldName) {
+  return model.fields.find((f) => f.name === fieldName && f.isRelation);
+}
+function buildOrderByWithRelations(orderBy, alias, dialect, model, schemas) {
+  if (!isNotNullish(orderBy)) return { sql: "", joins: [] };
+  const expanded = expandOrderByInput(orderBy);
+  if (expanded.length === 0) return { sql: "", joins: [] };
+  const relationSet = getRelationFieldSet(model);
+  const scalarSet = getScalarFieldSet(model);
+  const orderFragments = [];
+  const joins = [];
+  const usedAliases = /* @__PURE__ */ new Set();
+  let relAliasCounter = 0;
+  for (const [fieldName, value] of expanded) {
+    if (scalarSet.has(fieldName)) {
+      const entries = normalizeAndValidateOrderBy(
+        [{ [fieldName]: value }],
+        model,
+        parseOrderByValue
+      );
+      const sql = buildOrderByFragment(entries, alias, dialect, model);
+      if (sql) orderFragments.push(sql);
+      continue;
+    }
+    if (relationSet.has(fieldName)) {
+      if (!isPlainObject(value)) {
+        throw new Error(`Relation orderBy for '${fieldName}' must be an object`);
+      }
+      const nestedEntries = Object.entries(value);
+      if (nestedEntries.length === 0) continue;
+      if ("_count" in value) {
+        throw new Error(
+          `Relation orderBy with _count on '${fieldName}' is not yet supported by prisma-sql`
+        );
+      }
+      const field = findRelationField(model, fieldName);
+      if (!field) {
+        throw new Error(
+          `Relation field '${fieldName}' not found on model ${model.name}`
+        );
+      }
+      const relatedModel = getModelByName(schemas, field.relatedModel);
+      if (!relatedModel) {
+        throw new Error(
+          `Related model '${field.relatedModel}' not found for relation '${fieldName}'`
+        );
+      }
+      const relScalarSet = getScalarFieldSet(relatedModel);
+      const relRelationSet = getRelationFieldSet(relatedModel);
+      for (const [nestedField] of nestedEntries) {
+        if (relRelationSet.has(nestedField)) {
+          throw new Error(
+            `Nested relation orderBy (${fieldName}.${nestedField}) is not yet supported by prisma-sql`
+          );
+        }
+        if (!relScalarSet.has(nestedField)) {
+          throw new Error(
+            `orderBy field '${nestedField}' does not exist on related model '${relatedModel.name}'`
+          );
+        }
+      }
+      let joinAlias;
+      do {
+        joinAlias = `ob_${relAliasCounter++}`;
+      } while (usedAliases.has(joinAlias));
+      usedAliases.add(joinAlias);
+      const tableRef = resolveTableRef(relatedModel, dialect);
+      const cond = joinCondition(
+        field,
+        model,
+        relatedModel,
+        alias,
+        joinAlias
+      );
+      joins.push(`LEFT JOIN ${tableRef} ${joinAlias} ON ${cond}`);
+      const entries = normalizeAndValidateOrderBy(
+        [value],
+        relatedModel,
+        parseOrderByValue
+      );
+      const sql = buildOrderByFragment(
+        entries,
+        joinAlias,
+        dialect,
+        relatedModel
+      );
+      if (sql) orderFragments.push(sql);
+      continue;
+    }
+    throw new Error(
+      `orderBy field '${fieldName}' does not exist on model ${model.name}`
+    );
+  }
+  return {
+    sql: orderFragments.join(SQL_SEPARATORS.ORDER_BY),
+    joins
+  };
+}
+
 // src/builder/select.ts
 function normalizeOrderByInput3(orderBy) {
   return normalizeOrderByInput(orderBy, parseOrderByValue);
@@ -5648,20 +5792,13 @@ Available fields: ${[...scalarSet].join(", ")}`
     assertScalarField(model, f, "distinct");
   }
 }
-function validateOrderBy(model, orderBy) {
+function validateOrderBy(model, orderBy, schemas) {
   if (!isNotNullish(orderBy)) return;
-  const items = normalizeOrderByInput3(orderBy);
-  if (items.length === 0) return;
+  const expanded = expandOrderByInput(orderBy);
+  if (expanded.length === 0) return;
   const scalarSet = getScalarFieldSet(model);
   const relationSet = getRelationFieldSet(model);
-  for (const it of items) {
-    const entries = Object.entries(it);
-    if (entries.length !== 1) {
-      throw new Error(
-        `orderBy array entries must have exactly one field. Got ${entries.length} fields: ${Object.keys(it).join(", ")}`
-      );
-    }
-    const [fieldName, value] = entries[0];
+  for (const [fieldName, value] of expanded) {
     const f = String(fieldName).trim();
     if (f.length === 0) {
       throw new Error("orderBy field name cannot be empty");
@@ -5671,20 +5808,20 @@ function validateOrderBy(model, orderBy) {
         `orderBy field name too long (${f.length} chars, max 255): ${f.slice(0, 50)}...`
       );
     }
-    if (!scalarSet.has(f)) {
-      if (relationSet.has(f)) {
-        throw new Error(
-          `orderBy field '${f}' is a relation field. Only scalar fields are allowed.
-Available scalar fields: ${[...scalarSet].join(", ")}`
-        );
+    if (scalarSet.has(f)) {
+      assertScalarField(model, f, "orderBy");
+      continue;
+    }
+    if (relationSet.has(f)) {
+      if (!isPlainObject(value)) {
+        throw new Error(`Relation orderBy for '${f}' must be an object`);
       }
-      throw new Error(
-        `orderBy field '${f}' does not exist on model ${model.name}.
-Available fields: ${[...scalarSet].join(", ")}`
-      );
+      continue;
     }
-    assertScalarField(model, f, "orderBy");
-    parseOrderByValue(value, f);
+    throw new Error(
+      `orderBy field '${f}' does not exist on model ${model.name}.
+Available fields: ${[...scalarSet].join(", ")}`
+    );
   }
 }
 function validateCursor(model, cursor, distinct) {
@@ -5767,11 +5904,12 @@ function buildSelectSpec(input) {
     model,
     alias
   );
-  const orderByClause = buildOrderByClause(
-    normalizedArgs,
+  const orderByResult = buildOrderByWithRelations(
+    normalizedArgs.orderBy,
     alias,
     dialect,
-    model
+    model,
+    schemas
   );
   const { take, skip, cursor } = getPaginationParams(method, normalizedArgs);
   const params = createParamStoreFrom(
@@ -5804,13 +5942,15 @@ function buildSelectSpec(input) {
       "Cursor pagination with distinct is not supported in SQLite due to window function limitations. Use findMany with skip/take instead, or remove distinct."
     );
   }
+  const orderByJoins = orderByResult.joins;
+  const combinedWhereJoins = whereResult.joins ? [...whereResult.joins, ...orderByJoins] : orderByJoins.length > 0 ? orderByJoins : [];
   return {
     select: selectFields,
     includes,
     from: { table: tableName, alias },
     whereClause: whereResult.clause,
-    whereJoins: whereResult.joins,
-    orderBy: orderByClause,
+    whereJoins: combinedWhereJoins,
+    orderBy: orderByResult.sql,
     pagination: { take, skip },
     distinct: normalizedArgs.distinct,
     method,