prisma-sql 1.75.4 → 1.75.6

package/dist/index.js

@@ -2372,6 +2372,12 @@ function maxDepthFromTree(nodes) {
   }
   return max;
 }
+function anyChildHasWhere(nodes) {
+  for (const n of nodes) {
+    if (n.hasChildWhere) return true;
+  }
+  return false;
+}
 function computeWhereInCost(nodes, parentCount) {
   const R = globalRoundtripRowEquivalent;
   let totalRows = 0;
@@ -2475,13 +2481,18 @@ function pickIncludeStrategy(params) {
     }
   }
   const costTree = buildCostTree(includeSpec, model, schemas);
+  const treeDepth = maxDepthFromTree(costTree);
+  if (treeDepth === 1 && anyChildHasWhere(costTree)) {
+    if (debug)
+      console.log(`  [strategy] ${model.name}: depth-1 + childWhere \u2192 where-in`);
+    return "where-in";
+  }
   const P = isSingleParent ? 1 : takeValue != null ? takeValue : DEFAULT_PARENT_COUNT;
   const costW = computeWhereInCost(costTree, P);
   const costC = computeCorrelatedCost(costTree, P);
   if (debug) {
-    const depth = maxDepthFromTree(costTree);
     console.log(
-      `  [strategy] ${model.name}: P=${P} D=${depth} costW=${costW.toFixed(0)} costC=${costC.toFixed(0)}`
+      `  [strategy] ${model.name}: P=${P} D=${treeDepth} costW=${costW.toFixed(0)} costC=${costC.toFixed(0)}`
     );
   }
   if (costC < costW) {
@@ -5606,6 +5617,7 @@ function buildIncludeSql(args, model, schemas, parentAlias, params, dialect, out
 }
 
 // src/builder/shared/order-by-relation.ts
+var MAX_RELATION_ORDER_BY_DEPTH = 10;
 function resolveTableRef(model, dialect) {
   const tableName = model.tableName || model.dbName || model.name;
   if (dialect === "sqlite") {
@@ -5617,6 +5629,90 @@ function resolveTableRef(model, dialect) {
 function findRelationField(model, fieldName) {
   return model.fields.find((f) => f.name === fieldName && f.isRelation);
 }
+function nextJoinAlias(ctx) {
+  let alias;
+  do {
+    alias = `ob_${ctx.aliasCounter.value++}`;
+  } while (ctx.usedAliases.has(alias));
+  ctx.usedAliases.add(alias);
+  return alias;
+}
+function resolveRelationOrderByChain(relationFieldName, value, currentModel, currentAlias, ctx, depth) {
+  if (depth > MAX_RELATION_ORDER_BY_DEPTH) {
+    throw new Error(
+      `Relation orderBy nesting too deep (max ${MAX_RELATION_ORDER_BY_DEPTH} levels)`
+    );
+  }
+  if ("_count" in value && value._count !== void 0) {
+    throw new Error(
+      `Relation orderBy with _count on '${relationFieldName}' is not yet supported by prisma-sql`
+    );
+  }
+  const field = findRelationField(currentModel, relationFieldName);
+  if (!field) {
+    throw new Error(
+      `Relation field '${relationFieldName}' not found on model ${currentModel.name}`
+    );
+  }
+  const relatedModel = getModelByName(ctx.schemas, field.relatedModel);
+  if (!relatedModel) {
+    throw new Error(
+      `Related model '${field.relatedModel}' not found for relation '${relationFieldName}'`
+    );
+  }
+  const joinAlias = nextJoinAlias(ctx);
+  const tableRef = resolveTableRef(relatedModel, ctx.dialect);
+  const cond = joinCondition(
+    field,
+    currentModel,
+    relatedModel,
+    currentAlias,
+    joinAlias
+  );
+  ctx.joins.push(`LEFT JOIN ${tableRef} ${joinAlias} ON ${cond}`);
+  const relScalarSet = getScalarFieldSet(relatedModel);
+  const relRelationSet = getRelationFieldSet(relatedModel);
+  const nestedEntries = Object.entries(value).filter(([, v]) => v !== void 0);
+  const orderFragments = [];
+  for (const [nestedField, nestedValue] of nestedEntries) {
+    if (relScalarSet.has(nestedField)) {
+      const entries = normalizeAndValidateOrderBy(
+        [{ [nestedField]: nestedValue }],
+        relatedModel,
+        parseOrderByValue
+      );
+      const sql = buildOrderByFragment(
+        entries,
+        joinAlias,
+        ctx.dialect,
+        relatedModel
+      );
+      if (sql) orderFragments.push(sql);
+      continue;
+    }
+    if (relRelationSet.has(nestedField)) {
+      if (!isPlainObject(nestedValue)) {
+        throw new Error(
+          `Relation orderBy for '${nestedField}' must be an object`
+        );
+      }
+      const nested = resolveRelationOrderByChain(
+        nestedField,
+        nestedValue,
+        relatedModel,
+        joinAlias,
+        ctx,
+        depth + 1
+      );
+      orderFragments.push(...nested);
+      continue;
+    }
+    throw new Error(
+      `orderBy field '${nestedField}' does not exist on related model '${relatedModel.name}'`
+    );
+  }
+  return orderFragments;
+}
 function buildOrderByWithRelations(orderBy, alias, dialect, model, schemas) {
   if (!isNotNullish(orderBy)) return { sql: "", joins: [] };
   const expanded = expandOrderByInput(orderBy);
@@ -5624,9 +5720,13 @@ function buildOrderByWithRelations(orderBy, alias, dialect, model, schemas) {
   const relationSet = getRelationFieldSet(model);
   const scalarSet = getScalarFieldSet(model);
   const orderFragments = [];
-  const joins = [];
-  const usedAliases = /* @__PURE__ */ new Set();
-  let relAliasCounter = 0;
+  const ctx = {
+    schemas,
+    dialect,
+    joins: [],
+    usedAliases: /* @__PURE__ */ new Set(),
+    aliasCounter: { value: 0 }
+  };
   for (const [fieldName, value] of expanded) {
     if (scalarSet.has(fieldName)) {
       const entries = normalizeAndValidateOrderBy(
@@ -5642,65 +5742,15 @@ function buildOrderByWithRelations(orderBy, alias, dialect, model, schemas) {
       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,
+      const fragments = resolveRelationOrderByChain(
+        fieldName,
+        value,
         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
+        ctx,
+        0
       );
-      if (sql) orderFragments.push(sql);
+      orderFragments.push(...fragments);
       continue;
     }
     throw new Error(
@@ -5709,7 +5759,7 @@ function buildOrderByWithRelations(orderBy, alias, dialect, model, schemas) {
   }
   return {
     sql: orderFragments.join(SQL_SEPARATORS.ORDER_BY),
-    joins
+    joins: ctx.joins
   };
 }