Improve --dry-run, CI output, and exit code handling (#212)

packages/plugins/plugin-build/src/commands/buildQuery/display/workspace/dependencies/displayDependencies.ts

@@ -1,6 +1,9 @@
 import { Project, Workspace } from "@yarnpkg/core";
-import { getInternalDependencies, getName } from "../../../utils";
-import { Maybe } from "../../../../../types";
+import {
+  getInternalDependencies,
+  getName,
+} from "@ojkelly/yarn-plugin-build/src/commands/buildQuery/utils";
+import { Maybe } from "@ojkelly/yarn-build-shared/dist/types";
 import { displayDependency } from "./displayDependency";
 import { DisplayFormatType } from "../..";
 

packages/plugins/shared/src/supervisor/graph.test.ts

@@ -17,7 +17,7 @@ describe("Simple dependency graph", () => {
     C.addDependency(D);
     C.addDependency(E);
 
-    await graph.resolve(A);
+    await graph.checkCyclical(A);
   });
 
   it("can detect cyclic dependencies", async () => {
@@ -42,7 +42,7 @@ describe("Simple dependency graph", () => {
     expect.assertions(2);
 
     try {
-      graph.resolve(A);
+      graph.checkCyclical(A);
     } catch (err) {
       if (err instanceof CyclicDependencyError) {
         expect(err.node).toMatch("D");

packages/plugins/shared/src/supervisor/graph.ts

@@ -1,5 +1,3 @@
-import { Workspace } from "@yarnpkg/core";
-
 class Graph {
   nodes: NodeGraph = {};
 
@@ -9,27 +7,40 @@ class Graph {
 
   ran: Set<string> = new Set();
 
+  dryRunCallback: (node: Node, iteration: number) => void = () => {
+    return;
+  };
+
   // Create a new node with the ID, or retrieve the existing one
-  addNode(id: string, callback?: RunCallback): Node {
+  addNode(id: string): Node {
     // If the Node already exists, return it
     if (this.nodes[id]) {
       return this.nodes[id];
     }
 
     // Otherwise make a new Node, store it, then return it
-    const newNode = new Node(id, this);
+    const newNode = new Node(id);
 
     this.nodes[id] = newNode;
 
-    this.size++;
+    this.size = Object.keys(this.nodes).length;
 
-    this.resolve(newNode);
+    this.checkCyclical(newNode);
 
-    if (!!callback) {
-      newNode.addRunCallback(callback);
+    return newNode;
+  }
+
+  addRunCallback(node: Node, callback: RunCallback): void {
+    let n = node;
+
+    if (!this.nodes[node.id]) {
+      n = this.addNode(node.id);
     }
 
-    return newNode;
+    if (!n.runCallback) {
+      n.addRunCallback(callback);
+      this.runSize++;
+    }
   }
 
   getNode(id: string): Node | void {
@@ -42,7 +53,7 @@ class Graph {
     this.ran = new Set();
   }
 
-  resolve(node: Node): void {
+  checkCyclical(node: Node): void {
     // resolved and unresolved are local to this function
     // as they are only relevant to this resolution
     const resolved: Set<string> = new Set();
@@ -58,21 +69,23 @@ class Graph {
   ) {
     unresolved.add(node.id);
 
-    for (const dep of node.dependencies) {
+    Object.keys(node.dependencies).forEach((k) => {
+      const dep = node.dependencies[k];
+
       if (!resolved.has(dep.id)) {
         if (unresolved.has(dep.id)) {
           throw new CyclicDependencyError(node.id, dep.id);
         }
 
         this.resolveNode(dep, resolved, unresolved);
       }
-    }
+    });
 
     resolved.add(node.id);
     unresolved.delete(node.id);
   }
 
-  async run(nodes: Node[]): Promise<RunLog> {
+  async run(nodes: Node[], dryRun = false): Promise<RunLog> {
     const queue: Set<RunQueueItem> = new Set<RunQueueItem>();
     const progress: Set<Node> = new Set<Node>();
 
@@ -83,13 +96,52 @@ class Graph {
       this.resolveQueue(n, queue, runLog);
     }
 
+    if (dryRun) {
+      await this.dryRunLoop(queue, runLog, progress, 0);
+
+      return runLog;
+    }
+
     await new Promise<void>((resolve) => {
       this.workLoop(queue, runLog, progress, resolve);
     });
 
     return runLog;
   }
 
+  private async dryRunLoop(
+    queue: Set<RunQueueItem>,
+    runLog: RunLog,
+    progress: Set<Node>,
+    iteration = 0
+  ): Promise<void> {
+    progress.forEach((n, i) => {
+      this.dryRunCallback(n, iteration - 1); // this is always for the previous iteration
+      runLog[n.id] = { success: true, done: true };
+
+      progress.delete(i);
+    });
+
+    if (queue.size !== 0) {
+      // Run everything that can be run now
+      queue.forEach((q) => {
+        if (q.canStart(runLog)) {
+          if (q?.node?.runCallback) {
+            progress.add(q.node);
+            queue.delete(q);
+          }
+        }
+      });
+    }
+
+    // Check if anything still needs to run
+    if (progress.size != 0) {
+      return await this.dryRunLoop(queue, runLog, progress, iteration + 1);
+    }
+
+    return;
+  }
+
   private workLoop(
     queue: Set<RunQueueItem>,
     runLog: RunLog,
@@ -139,7 +191,9 @@ class Graph {
   ): string[] {
     const parentDependencies: string[] = [];
 
-    for (const dep of node.dependencies) {
+    Object.keys(node.dependencies).forEach((k) => {
+      const dep = node.dependencies[k];
+
       parentDependencies.push(dep.id);
       if (!runLog[dep.id] && dep.runCallback) {
         runLog[dep.id] = { ...Graph.RunLogInit };
@@ -152,7 +206,7 @@ class Graph {
 
         queue.add(queueItem);
       }
-    }
+    });
 
     // parent item
     if (!runLog[node.id] && node.runCallback) {
@@ -188,31 +242,23 @@ type RunQueueItem = {
 class Node {
   id: string;
 
-  dependencies: Node[] = [];
-
-  graph: Graph;
-
-  // metadata
-  workspace?: Workspace;
+  dependencies: NodeGraph;
 
   cancelled = false;
 
+  skip = false;
+
   runCallback?: RunLogCallback;
 
-  constructor(id: string, graph: Graph) {
+  constructor(id: string) {
     this.id = id;
-    this.dependencies = [];
-    this.graph = graph;
+    this.dependencies = {};
   }
 
   addDependency(node: Node): Node {
-    this.dependencies.push(node);
-
-    return this;
-  }
-
-  addWorkSpace(workspace: Workspace): Node {
-    this.workspace = workspace;
+    if (!this.dependencies[node.id]) {
+      this.dependencies[node.id] = node;
+    }
 
     return this;
   }
@@ -231,7 +277,6 @@ class Node {
         runLog[this.id] = { done: true, success };
       });
     };
-    this.graph.runSize++;
 
     return this;
   }
@@ -241,9 +286,12 @@ class Node {
       if (typeof node.dependencies === `undefined`) {
         return;
       }
-      for (const n of node.dependencies) {
-        n.cancelled = true;
-      }
+
+      Object.keys(node.dependencies).forEach((k) => {
+        const v = node.dependencies[k];
+
+        v.cancelled = true;
+      });
     };
   }
 }