monorepo-next 8.4.1 → 8.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monorepo-next",
-  "version": "8.4.1",
+  "version": "8.6.0",
   "description": "Detach monorepo packages from normal linking",
   "bin": {
     "next": "bin/next.js"
@@ -62,7 +62,9 @@
     "conventional-recommended-bump": "6.1.0",
     "debug": "^4.3.1",
     "execa": "^5.0.0",
+    "glob": "^8.0.0",
     "inquirer": "^8.0.0",
+    "js-yaml": "^4.0.0",
     "minimatch": "^5.0.0",
     "npm-packlist": "^5.0.0",
     "rfc6902": "^5.0.0",
@@ -76,8 +78,9 @@
     "@crowdstrike/commitlint": "^5.0.0",
     "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
+    "common-tags": "^1.8.2",
     "eslint": "^8.0.0",
-    "eslint-config-crowdstrike": "^4.0.0",
+    "eslint-config-crowdstrike": "^7.0.0",
     "eslint-config-crowdstrike-node": "^3.0.0",
     "eslint-plugin-json-files": "^1.0.0",
     "eslint-plugin-mocha": "^10.0.0",
@@ -86,7 +89,7 @@
     "git-fixtures": "^4.0.0",
     "mocha": "^10.0.0",
     "mocha-helpers": "^6.2.1",
-    "remark-cli": "^10.0.0",
+    "remark-cli": "^11.0.0",
     "remark-preset-lint-crowdstrike": "^2.0.0",
     "renovate-config-standard": "^2.0.0",
     "sinon": "^14.0.0",

package/src/build-change-graph.js

@@ -21,22 +21,17 @@ async function getPackageChangedFiles({
   packageCwd,
   options,
 }) {
-  let isAncestor = await isCommitAncestorOf(fromCommit, toCommit, options);
-
-  let olderCommit;
-  let newerCommit;
-  if (isAncestor) {
-    olderCommit = fromCommit;
-    newerCommit = toCommit;
-  } else {
-    olderCommit = toCommit;
-    newerCommit = fromCommit;
-  }
+  // Be careful you don't accidentally use `...` instead of `..`.
+  // `...` finds the merge-base and uses that instead of `fromCommit`.
+  // https://stackoverflow.com/a/60496462
+  let committedChanges = await git(['diff', '--name-only', `${fromCommit}..${toCommit}`, packageCwd], options);
 
-  let committedChanges = await git(['diff', '--name-only', `${olderCommit}...${newerCommit}`, packageCwd], options);
   committedChanges = getLinesFromOutput(committedChanges);
+
   let dirtyChanges = await git(['status', '--porcelain', packageCwd, '-u'], options);
+
   dirtyChanges = getLinesFromOutput(dirtyChanges).map(line => line.substr(3));
+
   let changedFiles = Array.from(new Set(committedChanges).union(dirtyChanges));
 
   return changedFiles;

package/src/build-dep-graph.js

@@ -4,7 +4,7 @@ const path = require('path');
 const semver = require('semver');
 const dependencyTypes = require('./dependency-types');
 const readJson = require('./json').read;
-const getWorkspacesPaths = require('./get-workspaces-paths');
+const { getWorkspacesPaths } = require('./get-workspaces-paths');
 
 function copyDeps(left, right) {
   for (let dependencyType of dependencyTypes) {
@@ -77,7 +77,7 @@ async function buildDepGraph({
 }) {
   let workspacePackageJson = await readJson(path.join(workspaceCwd, 'package.json'));
 
-  let workspaces = await getWorkspacesPaths({ workspaceCwd });
+  let workspaces = await getWorkspacesPaths({ cwd: workspaceCwd });
 
   let packageDirs = workspaces.map(dir => path.join(workspaceCwd, dir));
 

package/src/get-workspaces-paths.js

@@ -1,33 +1,178 @@
 'use strict';
 
 const execa = require('execa');
+const fs = { ...require('fs'), ...require('fs').promises };
+const { promisify } = require('util');
+const glob = promisify(require('glob'));
+const jsYaml = require('js-yaml');
 const path = require('path');
 const readJson = require('./json').read;
+const readJsonSync = require('./json').readSync;
+
+function processPnpm({ stdout }, cwd) {
+  let workspaces = stdout.split(/\r?\n/).reduce((workspaces, workspace) => {
+    if (!workspace.startsWith('No projects matched the filters')) {
+      if (process.platform === 'darwin' && workspace.startsWith(`${path.sep}private${path.sep}`)) {
+        workspace = `${path.sep}${path.relative(`${path.sep}private`, workspace)}`;
+      }
+
+      let relative = path.relative(cwd, workspace);
+
+      workspaces.push(relative);
+    }
+
+    return workspaces;
+  }, []);
+
+  return workspaces;
+}
+
+function processYarn({ stdout }) {
+  let json = JSON.parse(stdout);
+
+  let workspaces = Object.values(json).map(({ location }) => location);
+
+  return workspaces;
+}
+
+function processPnpmYaml(buffer) {
+  // read packagesGlobs excluding packagesGLobs starting with !
+  // https://pnpm.io/pnpm-workspace_yaml
+  let packagesGlobs = jsYaml.load(buffer).packages.filter((packagesGlob) => !packagesGlob.startsWith('!'));
+
+  return packagesGlobs;
+}
+
+function processGlobs({ cwd, _2dFilesArray, isPnpm }) {
+  let _1dFilesArray = Array.prototype.concat.apply([], _2dFilesArray);
+
+  let packagePaths = [...new Set(_1dFilesArray)];
+
+  let neededYarnKeys = ['name', 'version'];
+
+  let workspaces = packagePaths.filter(packagePath => {
+    let packageJson;
+
+    try {
+      packageJson = readJsonSync(path.join(cwd, packagePath, 'package.json'));
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        return;
+      }
+
+      throw err;
+    }
+
+    if (isPnpm) {
+      return true;
+    }
+
+    // for yarn, not a valid package if name and version are missing in package.json
+    if (neededYarnKeys.every(key => key in packageJson)) {
+      return true;
+    }
+  });
+
+  return workspaces;
+}
 
 async function getWorkspacesPaths({
-  workspaceCwd,
+  cwd,
+  shouldSpawn = false,
+}) {
+  let workspacePackageJson = await readJson(path.join(cwd, 'package.json'));
+
+  let { workspaces } = workspacePackageJson;
+
+  let isPnpm = !workspaces;
+
+  if (shouldSpawn) {
+    if (isPnpm) {
+      workspaces = processPnpm(
+        await execa('pnpm', ['recursive', 'exec', '--', 'node', '-e', 'console.log(process.cwd())'], {
+          cwd,
+        }),
+        cwd,
+      );
+    } else {
+      workspaces = processYarn(
+        await execa('yarn', ['--silent', 'workspaces', 'info'], {
+          cwd,
+        }),
+      );
+    }
+  } else {
+    let packagesGlobs;
+
+    if (isPnpm) {
+      packagesGlobs = processPnpmYaml(
+        await fs.readFile(path.join(cwd, 'pnpm-workspace.yaml')),
+      );
+    } else {
+      packagesGlobs = workspaces.packages || workspaces;
+    }
+
+    let _2dFilesArray = await Promise.all(packagesGlobs.map(packagesGlob => {
+      return glob(packagesGlob, {
+        cwd,
+      });
+    }));
+
+    workspaces = processGlobs({ cwd, _2dFilesArray, isPnpm });
+  }
+
+  return workspaces;
+}
+
+function getWorkspacesPathsSync({
+  cwd,
+  shouldSpawn = false,
 }) {
-  let workspacePackageJson = await readJson(path.join(workspaceCwd, 'package.json'));
+  let workspacePackageJson = readJsonSync(path.join(cwd, 'package.json'));
 
   let { workspaces } = workspacePackageJson;
 
-  if (!workspaces) {
-    workspaces = (await execa('pnpm', ['recursive', 'exec', '--', 'node', '-e', 'console.log(process.cwd())'], { cwd: workspaceCwd })).stdout
-      .split(/\r?\n/)
-      .map(workspace => path.relative(workspaceCwd, workspace));
+  let isPnpm = !workspaces;
+
+  if (shouldSpawn) {
+    if (isPnpm) {
+      workspaces = processPnpm(
+        execa.sync('pnpm', ['recursive', 'exec', '--', 'node', '-e', 'console.log(process.cwd())'], {
+          cwd,
+        }),
+        cwd,
+      );
+    } else {
+      workspaces = processYarn(
+        execa.sync('yarn', ['--silent', 'workspaces', 'info'], {
+          cwd,
+        }),
+      );
+    }
   } else {
-    let jsonString = (
-      await execa('yarn', ['--silent', 'workspaces', 'info'], {
-        cwd: workspaceCwd,
-      })
-    ).stdout;
-  
-    let workspacesJson = JSON.parse(jsonString);
-    
-    workspaces = Object.values(workspacesJson).map(({ location }) => location);
+    let packagesGlobs;
+
+    if (isPnpm) {
+      packagesGlobs = processPnpmYaml(
+        fs.readFileSync(path.join(cwd, 'pnpm-workspace.yaml')),
+      );
+    } else {
+      packagesGlobs = workspaces.packages || workspaces;
+    }
+
+    let _2dFilesArray = packagesGlobs.map(packagesGlob => {
+      return glob.sync(packagesGlob, {
+        cwd,
+      });
+    });
+
+    workspaces = processGlobs({ cwd, _2dFilesArray, isPnpm });
   }
 
   return workspaces;
 }
 
-module.exports = getWorkspacesPaths;
+module.exports = {
+  getWorkspacesPaths,
+  getWorkspacesPathsSync,
+};

package/src/json.js

@@ -11,6 +11,10 @@ async function read(path) {
   return JSON.parse(await fs.readFile(path, 'utf8'));
 }
 
+function readSync(path) {
+  return JSON.parse(fs.readFileSync(path, 'utf8'));
+}
+
 async function write(path, json) {
   await fs.writeFile(path, stringify(json));
 }
@@ -18,5 +22,6 @@ async function write(path, json) {
 module.exports = {
   stringify,
   read,
+  readSync,
   write,
 };

package/src/releasable.js

@@ -18,6 +18,32 @@ const filesContributingToReleasability = new Set([
 
 const packageJsonDevChangeRegex = /^\/(?:devDependencies|publishConfig)(?:\/|$)/m;
 
+const relativePathRegex = /^\.{2}(?:\/|\\|$)/;
+
+function removeSubDirs(files) {
+  let remainingFiles = new Set(files);
+
+  for (let file of remainingFiles) {
+    let isSubDir = remainingFiles.some(nextFile => {
+      if (file === nextFile) {
+        return false;
+      }
+
+      let relative = path.relative(file, nextFile);
+
+      let isSubDir = !relativePathRegex.test(relative);
+
+      return isSubDir;
+    });
+
+    if (isSubDir) {
+      remainingFiles.delete(file);
+    }
+  }
+
+  return remainingFiles;
+}
+
 async function prepareTmpPackage({
   cwd,
   tmpDir,
@@ -38,11 +64,11 @@ async function prepareTmpPackage({
     }
   }
 
-  for (let file of changedFiles) {
-    if (filesContributingToReleasability.has(file)) {
-      continue;
-    }
+  let remainingFiles = changedFiles.diff(filesContributingToReleasability);
+
+  remainingFiles = removeSubDirs(remainingFiles);
 
+  for (let file of remainingFiles) {
     let filePath = path.join(tmpDir, file);
 
     await fs.mkdir(path.dirname(filePath), { recursive: true });
@@ -161,4 +187,6 @@ async function getChangedReleasableFiles({
 module.exports = {
   getChangedReleasableFiles,
   packageJsonDevChangeRegex,
+  removeSubDirs,
+  relativePathRegex,
 };