fix(core): with-deps should handle circular dependencies

Author: vsavkin

e2e/workspace/src/workspace.test.ts

@@ -498,24 +498,24 @@ forEachCli((cliName) => {
       );
       expect(resWithDeps.tasks).toEqual([
         {
-          id: `${mypublishablelib}:build`,
+          id: `${myapp}:build`,
           overrides: {},
           target: {
-            project: mypublishablelib,
+            project: myapp,
             target: 'build',
           },
-          command: `npm run ${cliCommand} -- build ${mypublishablelib}`,
-          outputs: [`dist/libs/${mypublishablelib}`],
+          command: `npm run ${cliCommand} -- build ${myapp}`,
+          outputs: [`dist/apps/${myapp}`],
         },
         {
-          id: `${myapp}:build`,
+          id: `${mypublishablelib}:build`,
           overrides: {},
           target: {
-            project: myapp,
+            project: mypublishablelib,
             target: 'build',
           },
-          command: `npm run ${cliCommand} -- build ${myapp}`,
-          outputs: [`dist/apps/${myapp}`],
+          command: `npm run ${cliCommand} -- build ${mypublishablelib}`,
+          outputs: [`dist/libs/${mypublishablelib}`],
         },
       ]);
       compareTwoArrays(resWithDeps.projects, [

packages/workspace/src/core/project-graph/operators.spec.ts

@@ -173,6 +173,65 @@ describe('withDeps', () => {
       },
     });
   });
+
+  it('should handle circular deps', () => {
+    const graph: ProjectGraph = {
+      nodes: {
+        lib1: { name: 'lib1', type: 'lib', data: null },
+        lib2: { name: 'lib2', type: 'lib', data: null },
+      },
+      dependencies: {
+        lib1: [
+          {
+            type: DependencyType.static,
+            source: 'lib1',
+            target: 'lib2',
+          },
+        ],
+        lib2: [
+          {
+            type: DependencyType.static,
+            source: 'lib2',
+            target: 'lib1',
+          },
+        ],
+      },
+    };
+
+    const affectedNodes = [{ name: 'lib1', type: 'lib', data: null }];
+
+    const result = withDeps(graph, affectedNodes);
+    expect(result).toEqual({
+      nodes: {
+        lib1: {
+          name: 'lib1',
+          type: 'lib',
+          data: null,
+        },
+        lib2: {
+          name: 'lib2',
+          type: 'lib',
+          data: null,
+        },
+      },
+      dependencies: {
+        lib2: [
+          {
+            type: 'static',
+            source: 'lib2',
+            target: 'lib1',
+          },
+        ],
+        lib1: [
+          {
+            type: 'static',
+            source: 'lib1',
+            target: 'lib2',
+          },
+        ],
+      },
+    });
+  });
 });
 
 describe('filterNodes', () => {

packages/workspace/src/core/project-graph/operators.ts

@@ -80,22 +80,35 @@ export function withDeps(
   subsetNodes: ProjectGraphNode[]
 ): ProjectGraph {
   const builder = new ProjectGraphBuilder();
-  Object.values(subsetNodes).forEach(recur);
+  const visitedNodes = [];
+  const visitedEdges = [];
+  Object.values(subsetNodes).forEach(recurNodes);
+  Object.values(subsetNodes).forEach(recurEdges);
   return builder.build();
 
   // ---------------------------------------------------------------------------
 
-  function recur(node) {
+  function recurNodes(node) {
+    if (visitedNodes.indexOf(node.name) > -1) return;
+    builder.addNode(node);
+    visitedNodes.push(node.name);
+
+    original.dependencies[node.name].forEach((n) => {
+      recurNodes(original.nodes[n.target]);
+    });
+  }
+
+  function recurEdges(node) {
+    if (visitedEdges.indexOf(node.name) > -1) return;
+    visitedEdges.push(node.name);
+
     const ds = original.dependencies[node.name];
-    // 1. Recursively add all source nodes
     ds.forEach((n) => {
-      recur(original.nodes[n.target]);
+      builder.addDependency(n.type, n.source, n.target);
     });
-    // 2. Add current node
-    builder.addNode(node);
-    // 3. Add all source dependencies
+
     ds.forEach((n) => {
-      builder.addDependency(n.type, n.source, n.target);
+      recurEdges(original.nodes[n.target]);
     });
   }
 }