monorepo-next 9.1.1 → 9.2.1

package/README.md

@@ -23,6 +23,7 @@ Commands:
                                    resume normal linking            [aliases: a]
   next changed-files [packages..]  list changed files
   next changed                     list changed packages
+  next cycles                      detect circular references
   next defrag                      synchronize all dependency version
                                    discrepancies
   next detach [package]            detach a package from normal linking
@@ -73,6 +74,16 @@ Options:
                              external dev dep, don't count it towards a package
                              change.                  [boolean] [default: false]
 
+next cycles
+
+detect circular references
+
+Options:
+  --help                            Show help                          [boolean]
+  --version                         Show version number                [boolean]
+  --detect-dev-dependencies, --dev  alert when there is a devDependency in the
+                                    loop              [boolean] [default: false]
+
 next defrag
 
 synchronize all dependency version discrepancies

package/bin/commands/cycles.js

@@ -0,0 +1,26 @@
+'use strict';
+
+module.exports = {
+  command: 'cycles',
+  describe: 'detect circular references',
+  builder: {
+    'detect-dev-dependencies': {
+      describe: 'alert when there is a devDependency in the loop',
+      alias: ['dev'],
+      type: 'boolean',
+      default: false,
+    },
+  },
+  async handler(argv) {
+    const detectCircularReferences = require('../../src/detect-circular-references');
+
+    let cycles = await detectCircularReferences({
+      ...argv,
+      shouldDetectDevDependencies: argv['detect-dev-dependencies'],
+    });
+
+    for (let cycle of cycles) {
+      console.log(cycle);
+    }
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monorepo-next",
-  "version": "9.1.1",
+  "version": "9.2.1",
   "description": "Detach monorepo packages from normal linking",
   "bin": {
     "next": "bin/next.js"
@@ -80,8 +80,8 @@
     "chai-as-promised": "^7.1.1",
     "common-tags": "^1.8.2",
     "eslint": "^8.0.0",
-    "eslint-config-crowdstrike": "^9.0.0",
-    "eslint-config-crowdstrike-node": "^3.0.0",
+    "eslint-config-crowdstrike": "10.1.0",
+    "eslint-config-crowdstrike-node": "3.0.1",
     "eslint-plugin-json-files": "^2.0.0",
     "eslint-plugin-mocha": "^10.0.0",
     "eslint-plugin-node": "^11.0.0",
@@ -95,6 +95,6 @@
     "sinon": "^15.0.0",
     "sinon-chai": "^3.5.0",
     "standard-node-template": "3.2.1",
-    "yargs-help-output": "^2.0.0"
+    "yargs-help-output": "^3.0.0"
   }
 }

package/src/cycle.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const dependencyTypes = require('./dependency-types');
+
+function createPackageNode({
+  packageName,
+  dependencyType,
+  dependencyRange,
+  parent,
+  branch,
+}) {
+  let group = {
+    parent,
+    dependencyType,
+    dependencyRange,
+    isCycle: false,
+    packageName,
+  };
+
+  let newBranch = [...branch, group].filter(Boolean);
+
+  return {
+    newGroup: group,
+    newBranch,
+  };
+}
+
+function findGroupInBranchByPackageName(branch, packageName) {
+  let _i = -1;
+
+  for (let i = 0; i < branch.length; i++) {
+    if (branch[i].packageName === packageName) {
+      _i = i;
+
+      break;
+    }
+  }
+
+  return _i;
+}
+
+function _getCycles({
+  packages,
+  _package,
+  dependencyType,
+  dependencyRange,
+  parent,
+  branch,
+  visitedNodes,
+  cycles,
+  shouldDetectDevDependencies,
+}) {
+  let visitedNode = visitedNodes[_package.packageName];
+
+  if (visitedNode) {
+    let i = findGroupInBranchByPackageName(branch, _package.packageName);
+
+    let isCycle = i !== -1;
+
+    let existingGroup = {
+      parent,
+      dependencyType,
+      dependencyRange,
+      isCycle,
+      packageName: visitedNode,
+    };
+
+    if (isCycle) {
+      let newBranch = [...branch.slice(i), existingGroup];
+
+      let cycle = newBranch.map(({ dependencyType, packageName }) => {
+        return [dependencyType, packageName];
+      });
+
+      cycles[cycle.flat().slice(1).join(' < ')] = existingGroup;
+    }
+
+    return;
+  }
+
+  let {
+    newGroup,
+    newBranch,
+  } = createPackageNode({
+    packageName: _package.packageName,
+    dependencyType,
+    dependencyRange,
+    parent,
+    branch,
+  });
+
+  visitedNodes[_package.packageName] = newGroup.packageName;
+
+  for (let dependencyType of dependencyTypes) {
+    if (!shouldDetectDevDependencies && dependencyType === 'devDependencies') {
+      continue;
+    }
+
+    let dependencies = _package[dependencyType];
+
+    for (let packageName of Object.keys(dependencies).sort()) {
+      let dependencyRange = dependencies[packageName];
+      let _package = packages[packageName];
+
+      _getCycles({
+        packages,
+        _package,
+        dependencyType,
+        dependencyRange,
+        parent: newGroup,
+        branch: newBranch,
+        visitedNodes,
+        cycles,
+        shouldDetectDevDependencies,
+      });
+    }
+  }
+}
+
+function getCycles(workspaceMeta, {
+  shouldDetectDevDependencies,
+} = {}) {
+  let cycles = {};
+  let visitedNodes = {};
+  let { packages } = workspaceMeta;
+
+  for (let packageName of Object.keys(packages).sort()) {
+    let _package = packages[packageName];
+
+    _getCycles({
+      packages,
+      _package,
+      branch: [],
+      visitedNodes,
+      cycles,
+      shouldDetectDevDependencies,
+    });
+  }
+
+  return Object.keys(cycles).sort();
+}
+
+Object.assign(module.exports, {
+  getCycles,
+});

package/src/detect-circular-references.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const buildDepGraph = require('./build-dep-graph');
+const { getCycles } = require('./cycle');
+const {
+  getWorkspaceCwd,
+} = require('./git');
+
+const { builder } = require('../bin/commands/cycles');
+
+async function detectCircularReferences({
+  cwd = process.cwd(),
+  shouldDetectDevDependencies = builder['detect-dev-dependencies'].default,
+} = {}) {
+  let workspaceCwd = await getWorkspaceCwd(cwd);
+
+  let workspaceMeta = await buildDepGraph({ workspaceCwd });
+
+  let cycles = getCycles(workspaceMeta, {
+    shouldDetectDevDependencies,
+  });
+
+  return cycles;
+}
+
+module.exports = detectCircularReferences;