From 19b4371c985691b714c24ca6edeeef6ffd059c35 Mon Sep 17 00:00:00 2001
From: Kelly Selden <602423+kellyselden@users.noreply.github.com>
Date: Fri, 26 Jul 2024 14:25:38 -0700
Subject: [PATCH] feat: find longest dependency chain

---
 src/build-change-graph.js | 36 ++++++++-------------
 src/build-dag.js          | 67 +++++++++++++++++++++++++++++----------
 2 files changed, 65 insertions(+), 38 deletions(-)

diff --git a/src/build-change-graph.js b/src/build-change-graph.js
index f0ec109b..9302ab96 100644
--- a/src/build-change-graph.js
+++ b/src/build-change-graph.js
@@ -130,6 +130,8 @@ async function buildChangeGraph({
     return path.relative(workspaceMeta.cwd, cwd);
   });
 
+  let longestBranch;
+
   for (let _package of collectPackages(workspaceMeta)) {
     if (!_package.packageName || !_package.version) {
       continue;
@@ -179,17 +181,7 @@ async function buildChangeGraph({
       }
     }
 
-    let changedFiles = await getPackageChangedFiles({
-      fromCommit: _fromCommit,
-      toCommit,
-      packageCwd: _package.cwd,
-      shouldRunPerPackage: false,
-      shouldExcludeDeleted,
-      options: {
-        cwd: workspaceMeta.cwd,
-        cached,
-      },
-    });
+    let changedFiles = [];
 
     let newFiles = changedFiles;
 
@@ -203,23 +195,23 @@ async function buildChangeGraph({
     }
 
     if (!newFiles.length) {
-      continue;
+      // continue;
     }
 
-    let changedReleasableFiles = await getChangedReleasableFiles({
-      changedFiles: newFiles,
-      packageCwd: _package.cwd,
-      workspacesCwd: workspaceMeta.cwd,
-      shouldExcludeDevChanges,
-      fromCommit: _fromCommit,
-      nextConfig,
-    });
+    let changedReleasableFiles = [];
 
     if (shouldOnlyIncludeReleasable && !changedReleasableFiles.length) {
-      continue;
+      // continue;
     }
 
-    let dag = buildDAG(workspaceMeta, _package.packageName);
+    let {
+      dag,
+      longestBranch: _longestBranch,
+    } = buildDAG(workspaceMeta, _package.packageName);
+
+    if (_longestBranch.length > (longestBranch?.length ?? 0)) {
+      longestBranch = _longestBranch;
+    }
 
     packagesWithChanges[_package.packageName] = {
       changedFiles: newFiles,
diff --git a/src/build-dag.js b/src/build-dag.js
index ddb2c28a..adc6b938 100644
--- a/src/build-dag.js
+++ b/src/build-dag.js
@@ -24,6 +24,8 @@ function thirdPass({
 
   visitedNodes[currentPackageName] = group.node;
 
+  let longestBranch = branch;
+
   for (let _package of collectPackages(workspaceMeta)) {
     if (_package.packageName === currentPackageName) {
       continue;
@@ -42,7 +44,9 @@ function thirdPass({
       if (visitedNode) {
         let isCycle = branch.includes(_package.packageName);
 
-        group.node.dependents.push({
+        let {
+          newGroup,
+        } = createPackageNode({
           parent,
           dependencyType,
           dependencyRange,
@@ -50,6 +54,8 @@ function thirdPass({
           node: visitedNode,
         });
 
+        group.node.dependents.push(newGroup);
+
         continue;
       }
 
@@ -67,19 +73,29 @@ function thirdPass({
 
       group.node.dependents.push(newGroup);
 
+      if (dependencyType === 'devDependencies') {
+        continue;
+      }
+
       // We don't want to check if it's private here because
       // you could have a chain of private packages, and you
       // want to bump them all the way down.
       // if (group.node.isPackage) {
-      thirdPass({
+      let _longestBranch = thirdPass({
         workspaceMeta,
         group: newGroup,
         branch: newBranch,
         visitedNodes,
       });
+
+      if (_longestBranch.length > longestBranch.length) {
+        longestBranch = _longestBranch;
+      }
       // }
     }
   }
+
+  return longestBranch;
 }
 
 function createPackageNode({
@@ -88,24 +104,41 @@ function createPackageNode({
   dependencyType,
   dependencyRange,
   parent,
-  branch,
+  branch = [],
+  node,
+  isCycle = false,
 }) {
-  let _package = workspaceMeta.packages[packageName] ?? workspaceMeta;
+  let newNode;
+
+  if (node) {
+    newNode = node;
+  } else {
+    let _package = workspaceMeta.packages[packageName] ?? workspaceMeta;
+
+    newNode = {
+      isPackage: !_package.isPrivate,
+      cwd: _package.cwd,
+      packageName,
+      version: _package.version,
+      dependents: [],
+    };
+  }
 
-  let node = {
-    isPackage: !_package.isPrivate,
-    cwd: _package.cwd,
-    packageName,
-    version: _package.version,
-    dependents: [],
-  };
+  let longestChain;
+
+  if (isCycle) {
+    longestChain = Infinity;
+  } else {
+    longestChain = (parent?.longestChain ?? 0) + 1;
+  }
 
   let group = {
     parent,
     dependencyType,
     dependencyRange,
-    isCycle: false,
-    node,
+    isCycle,
+    node: newNode,
+    longestChain,
   };
 
   let newBranch = [...branch, packageName].filter(Boolean);
@@ -123,19 +156,21 @@ function buildDAG(workspaceMeta, packageName) {
   } = createPackageNode({
     workspaceMeta,
     packageName,
-    branch: [],
   });
 
   let visitedNodes = {};
 
-  thirdPass({
+  let longestBranch = thirdPass({
     workspaceMeta,
     group: newGroup,
     branch: newBranch,
     visitedNodes,
   });
 
-  return newGroup;
+  return {
+    dag: newGroup,
+    longestBranch,
+  };
 }
 
 module.exports = buildDAG;