@vnejs/monorepo 0.0.4 → 0.0.5

package/package.json

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

package/src/build/index.js

@@ -0,0 +1,64 @@
+const resolveGraph = require("../workspace/resolve-graph");
+const findRoot = require("../workspace/find-root");
+const { run } = require("../publish/utils");
+
+const runLayerTurbo = (layer, root, { script, force }) => {
+  const filters = layer.map((pkg) => `--filter=${pkg.name}`).join(" ");
+  const forceFlag = force ? " --force" : "";
+
+  run(`npx turbo run ${script} ${filters}${forceFlag}`, root);
+};
+
+module.exports = (options = {}) => {
+  const script = options.script ?? "build";
+  const root = findRoot(options.cwd ?? process.cwd());
+  const dryRun = Boolean(options.dryRun);
+  const sequential = Boolean(options.sequential);
+
+  const { order, layers } = resolveGraph({
+    cwd: options.cwd ?? root,
+    script,
+    onlyVersion: options.onlyVersion,
+    name: options.name,
+    includeDependencies: Boolean(options.name || options.onlyVersion),
+  });
+
+  if (!order.length) {
+    console.error(`No workspace packages matched filters with script "${script}".`);
+    process.exit(1);
+  }
+
+  console.log(`\n=== Build: ${order.length} packages, ${layers.length} layers ===`);
+  console.log(`Script: ${script}`);
+  console.log(`Root: ${root}`);
+  console.log(`Mode: ${sequential ? "sequential" : "layers (turbo)"}\n`);
+
+  const runPackage = (pkg, label) => {
+    console.log(`\n==> ${label} ${pkg.name} (${pkg.dir})`);
+
+    if (dryRun) return;
+
+    run(`npm run ${script}`, pkg.absDir);
+  };
+
+  if (sequential) {
+    order.forEach((pkg, index) => runPackage(pkg, `[${index + 1}/${order.length}]`));
+  } else {
+    for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {
+      const layer = layers[layerIndex];
+      console.log(`\n=== Layer ${layerIndex + 1}/${layers.length} (${layer.length} packages) ===`);
+
+      if (dryRun) {
+        console.log(`  turbo run ${script} ${layer.map((pkg) => `--filter=${pkg.name}`).join(" ")}`);
+        layer.forEach((pkg, index) => {
+          console.log(`  ==> [${layerIndex + 1}/${layers.length}:${index + 1}/${layer.length}] ${pkg.name} (${pkg.dir})`);
+        });
+        continue;
+      }
+
+      runLayerTurbo(layer, root, { script, force: options.force });
+    }
+  }
+
+  if (dryRun) console.log("\nDry run complete.");
+};

package/src/clear/index.js

@@ -0,0 +1,24 @@
+const findRoot = require("../workspace/find-root");
+const { run } = require("../publish/utils");
+
+module.exports = (options = {}) => {
+  const root = findRoot(options.cwd ?? process.cwd());
+
+  console.log(`Monorepo root: ${root}\n`);
+
+  console.log("==> Removing node_modules...");
+  run("rm -rf node_modules", 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);
+
+  console.log("==> Removing dist folders...");
+  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);
+
+  console.log("\n==> Clear complete.");
+};

package/src/cli.js

@@ -9,6 +9,8 @@ const runChangedAction = require("./run-changed");
 const graphAction = require("./graph");
 const syncDepsAction = require("./sync-deps");
 const bumpAction = require("./bump");
+const buildAction = require("./build");
+const clearAction = require("./clear");
 
 const program = new Command();
 
@@ -78,6 +80,17 @@ program
     }),
   );
 
+program
+  .command("build")
+  .description("Build workspace packages in dependency order (turbo per layer)")
+  .option("--script <script>", "npm script to run in each package", "build")
+  .option("--only-version <pattern>", "filter by version prefix, e.g. 0.0.x")
+  .option("--name <pattern>", "filter by package name substring (includes dependency closure)")
+  .option("--sequential", "build one package at a time in flat graph order", false)
+  .option("--force", "pass --force to turbo (bypass cache)", false)
+  .option("--dry-run", "show build plan without running", false)
+  .action((options) => buildAction(options));
+
 program
   .command("changed-packages")
   .description("List workspace packages changed in git")
@@ -101,4 +114,9 @@ program
   .option("--dry-run", "list packages without running the script", false)
   .action(runChangedAction);
 
+program
+  .command("clear")
+  .description("Clean node_modules, caches, dist, and lockfiles")
+  .action(clearAction);
+
 program.parse();

package/src/index.js

@@ -6,6 +6,8 @@ module.exports = {
   graph: require("./graph"),
   syncDeps: require("./sync-deps"),
   bump: require("./bump"),
+  build: require("./build"),
+  clear: require("./clear"),
   resolveGraph: require("./workspace/resolve-graph"),
   listWorkspacePackages: require("./workspace/list-packages"),
   toTildeMinor: require("./workspace/to-tilde-minor"),

package/src/workspace/build-graph.js

@@ -25,6 +25,24 @@ const buildDependencyGraph = (packages) => {
   return { graph, byName };
 };
 
+const expandDependencyClosure = (packageNames, graph, byName) => {
+  const expanded = new Set(packageNames);
+  const queue = [...packageNames];
+
+  while (queue.length) {
+    const name = queue.shift();
+
+    for (const dep of graph.get(name) ?? []) {
+      if (!byName.has(dep) || expanded.has(dep)) continue;
+
+      expanded.add(dep);
+      queue.push(dep);
+    }
+  }
+
+  return [...expanded];
+};
+
 const restrictGraph = (graph, packageNames) => {
   const names = new Set(packageNames);
   const restricted = new Map();
@@ -42,5 +60,6 @@ const restrictGraph = (graph, packageNames) => {
 module.exports = {
   DEPENDENCY_FIELDS,
   buildDependencyGraph,
+  expandDependencyClosure,
   restrictGraph,
 };

package/src/workspace/list-packages.js

@@ -18,9 +18,13 @@ const expandWorkspacePattern = (root, pattern) => {
     if (part === "**") {
       if (!existsSync(dir)) return;
 
+      walk(dir, idx + 1);
+
       for (const entry of readdirSync(dir, { withFileTypes: true })) {
         if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist") {
-          walk(path.join(dir, entry.name), idx + 1);
+          const subdir = path.join(dir, entry.name);
+          walk(subdir, idx + 1);
+          walk(subdir, idx);
         }
       }
 

package/src/workspace/resolve-graph.js

@@ -1,26 +1,28 @@
 const listWorkspacePackages = require("./list-packages");
 const filterPackages = require("./filter-packages");
-const { buildDependencyGraph, restrictGraph } = require("./build-graph");
+const { buildDependencyGraph, expandDependencyClosure, restrictGraph } = require("./build-graph");
 const { topoSort, topoSortLayers } = require("./topo-sort");
 
 module.exports = (options = {}) => {
   const { root, packages } = listWorkspacePackages({ cwd: options.cwd });
-  const selected = filterPackages(packages, options);
+  let selected = filterPackages(packages, options);
 
   if (!selected.length) {
     return { root, selected: [], order: [], layers: [], byName: new Map() };
   }
 
   const byName = new Map(packages.map((pkg) => [pkg.name, pkg]));
-  const restricted = restrictGraph(
-    buildDependencyGraph(packages).graph,
-    selected.map((pkg) => pkg.name),
-  );
-  const layerNames = topoSortLayers(
-    restricted,
-    selected.map((pkg) => pkg.name),
-  );
-  const order = topoSort(restricted, selected.map((pkg) => pkg.name)).map((name) => byName.get(name));
+  const { graph } = buildDependencyGraph(packages);
+  let packageNames = selected.map((pkg) => pkg.name);
+
+  if (options.includeDependencies && packageNames.length) {
+    packageNames = expandDependencyClosure(packageNames, graph, byName);
+    selected = packageNames.map((name) => byName.get(name)).filter(Boolean);
+  }
+
+  const restricted = restrictGraph(graph, packageNames);
+  const layerNames = topoSortLayers(restricted, packageNames);
+  const order = topoSort(restricted, packageNames).map((name) => byName.get(name));
   const layers = layerNames.map((layer) => layer.map((name) => byName.get(name)));
 
   return { root, selected, order, layers, byName };