@vnejs/monorepo 0.2.1 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vnejs/monorepo",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Monorepo tooling for @vnejs",
   "main": "src/index.js",
   "bin": {

package/src/cli.js

@@ -97,7 +97,7 @@ program
 
 program
   .command("run-changed")
-  .description("Run npm script in git-changed workspace packages (sequential by default)")
+  .description("Run npm script in git-changed workspace packages (dependency layers; sequential by default)")
   .option("--script <script>", "npm script name from package.json")
   .option("--ref <ref>", "git ref to compare against", "HEAD")
   .option("--dry-run", "list changed packages without running the script", false)

package/src/run-changed/index.js

@@ -1,30 +1,39 @@
 const path = require("path");
 
 const { getChangedPackages } = require("../changed-packages");
-const resolveGraph = require("../workspace/resolve-graph");
+const listWorkspacePackages = require("../workspace/list-packages");
+const { buildDependencyGraph, restrictGraph } = require("../workspace/build-graph");
+const { topoSortLayers } = require("../workspace/topo-sort");
 const { runAsync } = require("../publish/utils");
 const confirm = require("../utils/confirm");
 const { formatPackageLine } = require("../utils/format-package");
 const schedulePackages = require("./schedule");
 
-const sortByGraphOrder = (root, changedPackages, script) => {
-  const changedNames = new Set(changedPackages.map((pkg) => pkg.name));
-  const { order } = resolveGraph({ cwd: root, script });
+const groupChangedByGraph = (root, changedPackages) => {
+  const { packages: all } = listWorkspacePackages({ cwd: root });
+  const { graph } = buildDependencyGraph(all);
+  const byChangedName = new Map(changedPackages.map((pkg) => [pkg.name, pkg]));
+  const changedNames = [...byChangedName.keys()];
+  const layers = topoSortLayers(restrictGraph(graph, changedNames), changedNames).map((layer) => layer.map((name) => byChangedName.get(name)));
 
-  const sorted = order.filter((pkg) => changedNames.has(pkg.name));
+  return { packages: layers.flat(), layers };
+};
 
-  const sortedNames = new Set(sorted.map((pkg) => pkg.name));
-  const rest = changedPackages.filter((pkg) => !sortedNames.has(pkg.name));
+const printPackages = (layers) => {
+  const total = layers.reduce((sum, layer) => sum + layer.length, 0);
+  let index = 0;
 
-  return [...sorted, ...rest];
-};
+  layers.forEach((layer, layerIndex) => {
+    console.log(`\n=== Layer ${layerIndex + 1}/${layers.length} (${layer.length} packages) ===`);
 
-const printPackages = (packages) => {
-  packages.forEach((pkg, index) => {
-    console.log(formatPackageLine(pkg, { tag: `[${index + 1}/${packages.length}]` }));
+    layer.forEach((pkg) => {
+      index += 1;
+      console.log(formatPackageLine(pkg, { indent: "  ", tag: `[${index}/${total}]` }));
+    });
   });
+
   console.log("");
-  console.log(`Total: ${packages.length}`);
+  console.log(`Total: ${total}, layers: ${layers.length}`);
 };
 
 const parseConcurrency = (value) => {
@@ -71,16 +80,16 @@ module.exports = async (options = {}) => {
     return;
   }
 
-  const packages = sortByGraphOrder(root, changedPackages, script);
+  const { packages, layers } = groupChangedByGraph(root, changedPackages);
 
   if (options.dryRun) {
-    printPackages(packages);
+    printPackages(layers);
     return;
   }
 
   if (options.confirm) {
     console.log(`\nThe following packages will run "${script}":\n`);
-    printPackages(packages);
+    printPackages(layers);
 
     const confirmed = await confirm(`Continue? [y/N] `);
 
@@ -92,8 +101,11 @@ module.exports = async (options = {}) => {
     console.log("");
   }
 
+  console.log(`\n=== Run-changed: ${packages.length} packages, ${layers.length} layers ===`);
+
   await schedulePackages({
     packages,
+    layers,
     concurrency,
     parallelMs,
     firstSerial,

package/src/run-changed/schedule.js

@@ -2,14 +2,26 @@ const pLimit = require("p-limit").default;
 
 const PARALLEL_WINDOW_ENDED = "Parallel window ended; concurrency set to 1";
 
-const schedulePackages = async ({
-  packages,
-  runFn,
-  concurrency = 1,
-  parallelMs,
-  firstSerial = false,
-  log = console.log,
-}) => {
+const toGroups = (packages, layers) => {
+  const source = layers ?? (packages?.length ? [packages] : []);
+
+  return source.map((layer) => [...layer]).filter((layer) => layer.length);
+};
+
+const rejectFailed = (results, log) => {
+  const failed = results.filter((result) => result.status === "rejected");
+
+  if (!failed.length) return;
+
+  for (const result of failed) {
+    const reason = result.reason;
+    log(reason?.stack ?? String(reason));
+  }
+
+  throw new Error(`${failed.length} package script(s) failed.`);
+};
+
+const schedulePackages = async ({ packages = [], layers, runFn, concurrency = 1, parallelMs, firstSerial = false, log = console.log }) => {
   if (!Number.isInteger(concurrency) || concurrency < 1) {
     throw new Error("concurrency must be an integer >= 1");
   }
@@ -18,18 +30,20 @@ const schedulePackages = async ({
     throw new Error("parallelMs must be a number >= 0");
   }
 
-  if (!packages.length) return;
+  const groups = toGroups(packages, layers);
+
+  if (!groups.length) return;
 
   let startIndex = 0;
 
   if (firstSerial) {
-    await runFn(packages[0], 0);
+    await runFn(groups[0][0], 0);
     startIndex = 1;
-  }
-
-  const remaining = packages.slice(startIndex);
+    groups[0] = groups[0].slice(1);
 
-  if (!remaining.length) return;
+    if (!groups[0].length) groups.shift();
+    if (!groups.length) return;
+  }
 
   const limit = pLimit(concurrency);
   let timer;
@@ -42,20 +56,13 @@ const schedulePackages = async ({
   }
 
   try {
-    const results = await Promise.allSettled(
-      remaining.map((pkg, offset) => limit(() => runFn(pkg, startIndex + offset))),
-    );
-
-    const failed = results.filter((result) => result.status === "rejected");
+    for (const layer of groups) {
+      const layerStart = startIndex;
+      const results = await Promise.allSettled(layer.map((pkg, offset) => limit(() => runFn(pkg, layerStart + offset))));
 
-    if (!failed.length) return;
-
-    for (const result of failed) {
-      const reason = result.reason;
-      log(reason?.stack ?? String(reason));
+      startIndex += layer.length;
+      rejectFailed(results, log);
     }
-
-    throw new Error(`${failed.length} package script(s) failed.`);
   } finally {
     if (timer) clearTimeout(timer);
   }

package/src/run-changed/schedule.test.js

@@ -38,6 +38,18 @@ const flush = async () => {
   await Promise.resolve();
 };
 
+const waitUntilStarted = async (started, expected) => {
+  for (let i = 0; i < 20; i++) {
+    if (started.length >= expected.length && expected.every((name, index) => started[index] === name)) {
+      return;
+    }
+
+    await flush();
+  }
+
+  expect(started).toEqual(expected);
+};
+
 describe("schedulePackages", () => {
   afterEach(() => {
     vi.useRealTimers();
@@ -141,6 +153,70 @@ describe("schedulePackages", () => {
     await done;
   });
 
+  it("does not start a later layer until the previous layer finishes", async () => {
+    const { started, runFn, resolve } = createTrackedRunner();
+    const done = schedulePackages({
+      layers: [packages("a", "b"), packages("c")],
+      runFn,
+      concurrency: 2,
+    });
+
+    await flush();
+    expect(started).toEqual(["a", "b"]);
+
+    resolve("a");
+    await flush();
+    expect(started).toEqual(["a", "b"]);
+
+    resolve("b");
+    await waitUntilStarted(started, ["a", "b", "c"]);
+
+    resolve("c");
+    await done;
+  });
+
+  it("does not start the next layer when the current layer fails", async () => {
+    const { started, runFn, resolve, reject } = createTrackedRunner();
+    const logs = [];
+    const done = schedulePackages({
+      layers: [packages("a", "b"), packages("c")],
+      runFn,
+      concurrency: 2,
+      log: (message) => logs.push(message),
+    });
+
+    await flush();
+    reject("a", new Error("a failed"));
+    resolve("b");
+
+    await expect(done).rejects.toThrow("1 package script(s) failed.");
+    expect(started).toEqual(["a", "b"]);
+    expect(logs.some((message) => String(message).includes("a failed"))).toBe(true);
+  });
+
+  it("runs firstSerial from the first layer, then the rest of that layer", async () => {
+    const { started, runFn, resolve } = createTrackedRunner();
+    const done = schedulePackages({
+      layers: [packages("a", "b"), packages("c")],
+      runFn,
+      concurrency: 2,
+      firstSerial: true,
+    });
+
+    await flush();
+    expect(started).toEqual(["a"]);
+
+    resolve("a");
+    await flush();
+    expect(started).toEqual(["a", "b"]);
+
+    resolve("b");
+    await waitUntilStarted(started, ["a", "b", "c"]);
+
+    resolve("c");
+    await done;
+  });
+
   it("waits for in-flight failures and then rejects", async () => {
     const { started, runFn, resolve, reject } = createTrackedRunner();
     const logs = [];