@vnejs/monorepo 0.2.0 → 0.2.2

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@vnejs/monorepo",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Monorepo tooling for @vnejs",
   "main": "src/index.js",
   "bin": {
     "@vnejs/monorepo": "./src/cli.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "npx @vnejs/monorepo test",
     "publish:major": "npm version major && npm publish --access public",
     "publish:minor": "npm version minor && npm publish --access public",
     "publish:patch": "npm version patch && npm publish --access public"
@@ -15,8 +15,10 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@vnejs/configs.vitest": "~0.2.0",
     "commander": "~15.0.0",
     "happy-dom": "~20.10.6",
+    "p-limit": "~7.3.0",
     "typescript": "7.0.2",
     "vitest": "~4.1.9"
   }

package/src/bump/index.js

@@ -153,6 +153,9 @@ module.exports = async (version, options = {}) => {
       script: "publish:patch",
       ref: options.ref ?? "HEAD",
       dryRun,
+      concurrency: 8,
+      parallelMs: 270_000,
+      firstSerial: true,
     });
   }
 

package/src/clear/index.js

@@ -8,17 +8,17 @@ module.exports = (options = {}) => {
 
   console.log("==> Removing node_modules...");
   run("rm -rf node_modules", root);
-  run('find . -name node_modules -type d -prune -exec rm -rf {} +', root);
+  run("find . -name node_modules -type d -prune -exec rm -rf {} +", root);
 
   console.log("==> Removing Turbo cache...");
   run("rm -rf .turbo", root);
-  run('find . -name .turbo -type d -prune -exec rm -rf {} +', root);
+  run("find . -name .turbo -type d -prune -exec rm -rf {} +", root);
 
   console.log("==> Removing dist folders...");
-  run('find . -name dist -type d -prune -exec rm -rf {} +', root);
+  run("find . -name dist -type d -prune -exec rm -rf {} +", root);
 
   console.log("==> Removing package-lock files...");
-  run('find . -name package-lock.json -type f -delete', root);
+  run("find . -name package-lock.json -type f -delete", root);
 
   console.log("\n==> Clear complete.");
 };

package/src/cli.js

@@ -97,16 +97,23 @@ program
 
 program
   .command("run-changed")
-  .description("Run npm script sequentially in git-changed workspace packages")
+  .description("Run npm script in git-changed workspace packages (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)
   .option("--confirm", "ask for confirmation before running the script", false)
-  .action(runChangedAction);
+  .option("--concurrency <n>", "max parallel package scripts (p-limit)", "1")
+  .option("--parallel-ms <ms>", "after this window, drop concurrency to 1")
+  .option("--first-serial", "run the first package to completion before the parallel pool", false)
+  .action((options) =>
+    runChangedAction({
+      ...options,
+      concurrency: Number(options.concurrency),
+      parallelMs: options.parallelMs == null ? undefined : Number(options.parallelMs),
+      firstSerial: Boolean(options.firstSerial),
+    }),
+  );
 
-program
-  .command("clear")
-  .description("Clean node_modules, caches, dist, and lockfiles")
-  .action(clearAction);
+program.command("clear").description("Clean node_modules, caches, dist, and lockfiles").action(clearAction);
 
 program.parse();

package/src/graph/index.js

@@ -69,9 +69,7 @@ module.exports = (options = {}) => {
   if (options.flat) {
     order.forEach((pkg, index) => {
       const meta = layerMetaByName.get(pkg.name);
-      console.log(
-        `${index + 1}\t${meta.layer}/${meta.layerTotal}\t${formatPackageRef(pkg)}\t${pkg.dir}`,
-      );
+      console.log(`${index + 1}\t${meta.layer}/${meta.layerTotal}\t${formatPackageRef(pkg)}\t${pkg.dir}`);
     });
   } else {
     for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {

package/src/package/index.js

@@ -19,8 +19,7 @@ module.exports = (options = {}) => {
   // TS 7 no longer exports `typescript/bin/tsc`; resolve via package.json `bin`.
   const typescriptPkgPath = require.resolve("typescript/package.json");
   const typescriptPkg = require(typescriptPkgPath);
-  const tscRel =
-    typeof typescriptPkg.bin === "string" ? typescriptPkg.bin : typescriptPkg.bin.tsc;
+  const tscRel = typeof typescriptPkg.bin === "string" ? typescriptPkg.bin : typescriptPkg.bin.tsc;
   const tsc = path.resolve(path.dirname(typescriptPkgPath), tscRel);
   execSync(`node "${tsc}" -p "${config}"`, { cwd: pkgDir, stdio: "inherit" });
 };

package/src/publish/utils.js

@@ -1,4 +1,4 @@
-const { execSync } = require("child_process");
+const { execSync, spawn } = require("child_process");
 const { existsSync, readFileSync, writeFileSync } = require("fs");
 const path = require("path");
 
@@ -28,6 +28,21 @@ const run = (command, pkgDir) => {
   execSync(command, { cwd: pkgDir, stdio: "inherit" });
 };
 
+const runAsync = (command, pkgDir) =>
+  new Promise((resolve, reject) => {
+    const child = spawn(command, { cwd: pkgDir, stdio: "inherit", shell: true });
+
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+
+      reject(new Error(`${command} exited with ${code}`));
+    });
+  });
+
 const prepareForPublish = (pkgDir) => {
   const pkg = readPackageJson(pkgDir);
   if (!pkg.scripts?.build) return;
@@ -35,4 +50,4 @@ const prepareForPublish = (pkgDir) => {
   run("npx @vnejs/monorepo package --clean", pkgDir);
 };
 
-module.exports = { readPackageName, readVersion, writeVersion, run, prepareForPublish };
+module.exports = { readPackageName, readVersion, writeVersion, run, runAsync, prepareForPublish };

package/src/run-changed/index.js

@@ -2,9 +2,10 @@ const path = require("path");
 
 const { getChangedPackages } = require("../changed-packages");
 const resolveGraph = require("../workspace/resolve-graph");
-const { run } = require("../publish/utils");
+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));
@@ -26,8 +27,37 @@ const printPackages = (packages) => {
   console.log(`Total: ${packages.length}`);
 };
 
+const parseConcurrency = (value) => {
+  if (value == null) return 1;
+
+  const concurrency = Number(value);
+
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    console.error('Invalid "--concurrency". Must be an integer >= 1.');
+    process.exit(1);
+  }
+
+  return concurrency;
+};
+
+const parseParallelMs = (value) => {
+  if (value == null) return undefined;
+
+  const parallelMs = Number(value);
+
+  if (!Number.isFinite(parallelMs) || parallelMs < 0) {
+    console.error('Invalid "--parallel-ms". Must be a number >= 0.');
+    process.exit(1);
+  }
+
+  return parallelMs;
+};
+
 module.exports = async (options = {}) => {
   const script = options.script;
+  const concurrency = parseConcurrency(options.concurrency);
+  const parallelMs = parseParallelMs(options.parallelMs);
+  const firstSerial = Boolean(options.firstSerial);
 
   if (!options.dryRun && !script) {
     console.error('Missing required option "--script".');
@@ -62,9 +92,15 @@ module.exports = async (options = {}) => {
     console.log("");
   }
 
-  for (const [index, pkg] of packages.entries()) {
-    const pkgDir = path.join(root, pkg.dir);
-    console.log(formatPackageLine(pkg, { leadingNewline: true, tag: `[${index + 1}/${packages.length}]` }));
-    run(`npm run ${script}`, pkgDir);
-  }
+  await schedulePackages({
+    packages,
+    concurrency,
+    parallelMs,
+    firstSerial,
+    runFn: async (pkg, index) => {
+      const pkgDir = path.join(root, pkg.dir);
+      console.log(formatPackageLine(pkg, { leadingNewline: true, tag: `[${index + 1}/${packages.length}]` }));
+      await runAsync(`npm run ${script}`, pkgDir);
+    },
+  });
 };

package/src/run-changed/schedule.js

@@ -0,0 +1,56 @@
+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 }) => {
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    throw new Error("concurrency must be an integer >= 1");
+  }
+
+  if (parallelMs != null && (!Number.isFinite(parallelMs) || parallelMs < 0)) {
+    throw new Error("parallelMs must be a number >= 0");
+  }
+
+  if (!packages.length) return;
+
+  let startIndex = 0;
+
+  if (firstSerial) {
+    await runFn(packages[0], 0);
+    startIndex = 1;
+  }
+
+  const remaining = packages.slice(startIndex);
+
+  if (!remaining.length) return;
+
+  const limit = pLimit(concurrency);
+  let timer;
+
+  if (parallelMs != null && concurrency > 1) {
+    timer = setTimeout(() => {
+      limit.concurrency = 1;
+      log(PARALLEL_WINDOW_ENDED);
+    }, parallelMs);
+  }
+
+  try {
+    const results = await Promise.allSettled(remaining.map((pkg, offset) => limit(() => runFn(pkg, startIndex + offset))));
+
+    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.`);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+};
+
+module.exports = schedulePackages;
+module.exports.PARALLEL_WINDOW_ENDED = PARALLEL_WINDOW_ENDED;

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

@@ -0,0 +1,163 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import schedulePackages, { PARALLEL_WINDOW_ENDED } from "./schedule.js";
+
+const packages = (...names) => names.map((name) => ({ name }));
+
+const createDeferred = () => {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  return { promise, resolve, reject };
+};
+
+const createTrackedRunner = () => {
+  const started = [];
+  const deferreds = new Map();
+
+  const runFn = (pkg) => {
+    started.push(pkg.name);
+    const deferred = createDeferred();
+    deferreds.set(pkg.name, deferred);
+    return deferred.promise;
+  };
+
+  const resolve = (name) => deferreds.get(name).resolve();
+  const reject = (name, error) => deferreds.get(name).reject(error);
+
+  return { started, deferreds, runFn, resolve, reject };
+};
+
+const flush = async () => {
+  await Promise.resolve();
+  await Promise.resolve();
+  await Promise.resolve();
+};
+
+describe("schedulePackages", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("runs the first package outside the pool when firstSerial is set", async () => {
+    const { started, runFn, resolve } = createTrackedRunner();
+    const done = schedulePackages({
+      packages: packages("a", "b", "c"),
+      runFn,
+      concurrency: 2,
+      firstSerial: true,
+    });
+
+    await flush();
+    expect(started).toEqual(["a"]);
+
+    resolve("a");
+    await flush();
+    expect(started).toEqual(["a", "b", "c"]);
+
+    resolve("b");
+    resolve("c");
+    await done;
+  });
+
+  it("does not start the pool when the first-serial package fails", async () => {
+    const { started, runFn, reject } = createTrackedRunner();
+    const done = schedulePackages({
+      packages: packages("a", "b"),
+      runFn,
+      concurrency: 2,
+      firstSerial: true,
+    });
+
+    await flush();
+    reject("a", new Error("first failed"));
+
+    await expect(done).rejects.toThrow("first failed");
+    expect(started).toEqual(["a"]);
+  });
+
+  it("drops concurrency to 1 after parallelMs; in-flight tasks keep running", async () => {
+    vi.useFakeTimers();
+
+    const { started, runFn, resolve } = createTrackedRunner();
+    const logs = [];
+    const done = schedulePackages({
+      packages: packages("a", "b", "c", "d", "e"),
+      runFn,
+      concurrency: 3,
+      parallelMs: 100,
+      log: (message) => logs.push(message),
+    });
+
+    await flush();
+    expect(started).toEqual(["a", "b", "c"]);
+
+    await vi.advanceTimersByTimeAsync(100);
+    expect(logs).toContain(PARALLEL_WINDOW_ENDED);
+    expect(started).toEqual(["a", "b", "c"]);
+
+    resolve("a");
+    await flush();
+    expect(started).toEqual(["a", "b", "c"]);
+
+    resolve("b");
+    await flush();
+    expect(started).toEqual(["a", "b", "c"]);
+
+    resolve("c");
+    await flush();
+    expect(started).toEqual(["a", "b", "c", "d"]);
+
+    resolve("d");
+    await flush();
+    expect(started).toEqual(["a", "b", "c", "d", "e"]);
+
+    resolve("e");
+    await done;
+  });
+
+  it("keeps concurrency for the whole run when parallelMs is omitted", async () => {
+    const { started, runFn, resolve } = createTrackedRunner();
+    const done = schedulePackages({
+      packages: packages("a", "b", "c", "d"),
+      runFn,
+      concurrency: 3,
+    });
+
+    await flush();
+    expect(started).toEqual(["a", "b", "c"]);
+
+    resolve("a");
+    await flush();
+    expect(started).toEqual(["a", "b", "c", "d"]);
+
+    resolve("b");
+    resolve("c");
+    resolve("d");
+    await done;
+  });
+
+  it("waits for in-flight failures and then rejects", async () => {
+    const { started, runFn, resolve, reject } = createTrackedRunner();
+    const logs = [];
+    const done = schedulePackages({
+      packages: packages("a", "b"),
+      runFn,
+      concurrency: 2,
+      log: (message) => logs.push(message),
+    });
+
+    await flush();
+    expect(started).toEqual(["a", "b"]);
+
+    reject("a", new Error("a failed"));
+    resolve("b");
+
+    await expect(done).rejects.toThrow("1 package script(s) failed.");
+    expect(logs.some((message) => String(message).includes("a failed"))).toBe(true);
+  });
+});

package/src/sync-deps/index.js

@@ -32,9 +32,7 @@ const syncPackageDeps = (options = {}) => {
     return null;
   }
 
-  const workspaceVersions = options.workspace
-    ? new Map(listWorkspacePackages({ cwd: pkgDir }).packages.map((pkg) => [pkg.name, pkg.version]))
-    : new Map();
+  const workspaceVersions = options.workspace ? new Map(listWorkspacePackages({ cwd: pkgDir }).packages.map((pkg) => [pkg.name, pkg.version])) : new Map();
 
   const pkg = readPackageJson(pkgDir);
   const changes = [];

package/src/workspace/fetch-npm-version.js

@@ -38,9 +38,7 @@ module.exports = (name, options = {}) => {
     }
 
     if (attempt === maxAttempts) {
-      console.warn(
-        `${name}: expected ${expectVersion}.x on npm, last seen: ${version ?? "not found"} — giving up`,
-      );
+      console.warn(`${name}: expected ${expectVersion}.x on npm, last seen: ${version ?? "not found"} — giving up`);
       return version;
     }
 

package/src/workspace/filter-packages.js

@@ -4,8 +4,7 @@ const isStubTestScript = require("./is-stub-test-script");
 
 const DEFAULT_EXCLUDED_DIRS = [];
 
-const isExcludedDir = (dir, excludedDirs) =>
-  excludedDirs.some((excluded) => dir === excluded || dir.startsWith(`${excluded}/`));
+const isExcludedDir = (dir, excludedDirs) => excludedDirs.some((excluded) => dir === excluded || dir.startsWith(`${excluded}/`));
 
 module.exports = (packages, options = {}) => {
   let result = packages;

package/vitest.config.js

@@ -0,0 +1,10 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { createVitestConfig } from "@vnejs/configs.vitest/create-config.js";
+
+export default createVitestConfig({
+  dirname: path.dirname(fileURLToPath(import.meta.url)),
+  environment: "node",
+  include: ["src/**/*.test.js"],
+});