monorepo-next 9.1.1 → 9.2.0

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.0",
   "description": "Detach monorepo packages from normal linking",
   "bin": {
     "next": "bin/next.js"

package/src/cycle.js

@@ -0,0 +1,140 @@
+'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;
+    }
+
+    for (let [packageName, dependencyRange] of Object.entries(_package[dependencyType])) {
+      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 _package of Object.values(packages)) {
+    _getCycles({
+      packages,
+      _package,
+      branch: [],
+      visitedNodes,
+      cycles,
+      shouldDetectDevDependencies,
+    });
+  }
+
+  return Object.keys(cycles);
+}
+
+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;