@nx/eslint-plugin 19.7.0-beta.3 → 19.7.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/eslint-plugin",
-  "version": "19.7.0-beta.3",
+  "version": "19.7.0-beta.4",
   "private": false,
   "description": "The eslint-plugin package is an ESLint plugin that contains a collection of recommended ESLint rule configurations which you can extend from in your own ESLint configs, as well as an Nx-specific lint rule called enforce-module-boundaries.",
   "repository": {
@@ -34,8 +34,8 @@
     }
   },
   "dependencies": {
-    "@nx/devkit": "19.7.0-beta.3",
-    "@nx/js": "19.7.0-beta.3",
+    "@nx/devkit": "19.7.0-beta.4",
+    "@nx/js": "19.7.0-beta.4",
     "@typescript-eslint/type-utils": "^7.16.0",
     "@typescript-eslint/utils": "^7.16.0",
     "chalk": "^4.1.0",
@@ -43,7 +43,7 @@
     "jsonc-eslint-parser": "^2.1.0",
     "semver": "^7.5.3",
     "tslib": "^2.3.0",
-    "@nrwl/eslint-plugin-nx": "19.7.0-beta.3"
+    "@nrwl/eslint-plugin-nx": "19.7.0-beta.4"
   },
   "publishConfig": {
     "access": "public"

package/src/rules/enforce-module-boundaries.d.ts

@@ -7,6 +7,7 @@ type Options = [
         depConstraints: DepConstraint[];
         enforceBuildableLibDependency: boolean;
         allowCircularSelfDependency: boolean;
+        ignoredCircularDependencies: Array<[string, string]>;
         checkDynamicDependenciesExceptions: string[];
         banTransitiveDependencies: boolean;
         checkNestedExternalImports: boolean;

package/src/rules/enforce-module-boundaries.js

@@ -30,6 +30,15 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => `https://github.com/nrwl
                         type: 'array',
                         items: { type: 'string' },
                     },
+                    ignoredCircularDependencies: {
+                        type: 'array',
+                        items: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            minItems: 2,
+                            maxItems: 2,
+                        },
+                    },
                     banTransitiveDependencies: { type: 'boolean' },
                     checkNestedExternalImports: { type: 'boolean' },
                     allow: { type: 'array', items: { type: 'string' } },
@@ -121,11 +130,12 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => `https://github.com/nrwl
             enforceBuildableLibDependency: false,
             allowCircularSelfDependency: false,
             checkDynamicDependenciesExceptions: [],
+            ignoredCircularDependencies: [],
             banTransitiveDependencies: false,
             checkNestedExternalImports: false,
         },
     ],
-    create(context, [{ allow, buildTargets, depConstraints, enforceBuildableLibDependency, allowCircularSelfDependency, checkDynamicDependenciesExceptions, banTransitiveDependencies, checkNestedExternalImports, },]) {
+    create(context, [{ allow, buildTargets, depConstraints, enforceBuildableLibDependency, allowCircularSelfDependency, checkDynamicDependenciesExceptions, ignoredCircularDependencies, banTransitiveDependencies, checkNestedExternalImports, },]) {
         /**
          * Globally cached info about workspace
          */
@@ -136,6 +146,7 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => `https://github.com/nrwl
             return {};
         }
         const workspaceLayout = global.workspaceLayout;
+        const expandedIgnoreCircularDependencies = (0, graph_utils_1.expandIgnoredCircularDependencies)(ignoredCircularDependencies, projectGraph);
         function run(node) {
             // Ignoring ExportNamedDeclarations like:
             // export class Foo {}
@@ -236,7 +247,8 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => `https://github.com/nrwl
             }
             // we only allow relative paths within the same project
             // and if it's not a secondary entrypoint in an angular lib
-            if (sourceProject === targetProject) {
+            if (sourceProject === targetProject &&
+                !(0, graph_utils_1.circularPathHasPair)([sourceProject, targetProject], expandedIgnoreCircularDependencies)) {
                 if (!allowCircularSelfDependency &&
                     !(0, fileutils_1.isRelativePath)(imp) &&
                     !(0, runtime_lint_utils_1.belongsToDifferentNgEntryPoint)(imp, sourceFilePath, sourceProject.data.root)) {
@@ -320,7 +332,8 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => `https://github.com/nrwl
             // check constraints between libs and apps
             // check for circular dependency
             const circularPath = (0, graph_utils_1.checkCircularPath)(projectGraph, sourceProject, targetProject);
-            if (circularPath.length !== 0) {
+            if (circularPath.length !== 0 &&
+                !(0, graph_utils_1.circularPathHasPair)(circularPath, expandedIgnoreCircularDependencies)) {
                 const circularFilePath = (0, graph_utils_1.findFilesInCircularPath)(projectFileMap, circularPath);
                 // spacer text used for indirect dependencies when printing one line per file.
                 // without this, we can end up with a very long line that does not display well in the terminal.

package/src/utils/graph-utils.d.ts

@@ -2,5 +2,7 @@ import type { FileData, ProjectFileMap, ProjectGraph, ProjectGraphProjectNode }
 export declare function getPath(graph: ProjectGraph, sourceProjectName: string, targetProjectName: string): Array<ProjectGraphProjectNode>;
 export declare function pathExists(graph: ProjectGraph, sourceProjectName: string, targetProjectName: string): boolean;
 export declare function checkCircularPath(graph: ProjectGraph, sourceProject: ProjectGraphProjectNode, targetProject: ProjectGraphProjectNode): ProjectGraphProjectNode[];
+export declare function circularPathHasPair(circularPath: ProjectGraphProjectNode[], ignored: Map<string, Set<string>>): boolean;
 export declare function findFilesInCircularPath(projectFileMap: ProjectFileMap, circularPath: ProjectGraphProjectNode[]): Array<string[]>;
 export declare function findFilesWithDynamicImports(projectFileMap: ProjectFileMap, sourceProjectName: string, targetProjectName: string): FileData[];
+export declare function expandIgnoredCircularDependencies(ignoredCircularDependencies: Array<[string, string]>, projectGraph: ProjectGraph): Map<string, Set<string>>;

package/src/utils/graph-utils.js

@@ -3,9 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPath = getPath;
 exports.pathExists = pathExists;
 exports.checkCircularPath = checkCircularPath;
+exports.circularPathHasPair = circularPathHasPair;
 exports.findFilesInCircularPath = findFilesInCircularPath;
 exports.findFilesWithDynamicImports = findFilesWithDynamicImports;
+exports.expandIgnoredCircularDependencies = expandIgnoredCircularDependencies;
 const project_graph_1 = require("nx/src/config/project-graph");
+const find_matching_projects_1 = require("nx/src/utils/find-matching-projects");
 const reach = {
     graph: null,
     matrix: null,
@@ -103,6 +106,19 @@ function checkCircularPath(graph, sourceProject, targetProject) {
         return [];
     return getPath(graph, targetProject.name, sourceProject.name);
 }
+function circularPathHasPair(circularPath, ignored) {
+    if (circularPath.length < 2)
+        return false;
+    for (let i = 0; i < circularPath.length - 1; i++) {
+        const dependencyIsIgnored = ignored
+            .get(circularPath[i].name)
+            ?.has(circularPath[i + 1].name);
+        if (dependencyIsIgnored) {
+            return true;
+        }
+    }
+    return false;
+}
 function findFilesInCircularPath(projectFileMap, circularPath) {
     const filePathChain = [];
     for (let i = 0; i < circularPath.length - 1; i++) {
@@ -126,3 +142,29 @@ function findFilesWithDynamicImports(projectFileMap, sourceProjectName, targetPr
     });
     return files;
 }
+function expandIgnoredCircularDependencies(ignoredCircularDependencies, projectGraph) {
+    const allowed = new Map();
+    for (const [a, b] of ignoredCircularDependencies) {
+        const setA = new Set((0, find_matching_projects_1.findMatchingProjects)([a], projectGraph.nodes));
+        const setB = new Set((0, find_matching_projects_1.findMatchingProjects)([b], projectGraph.nodes));
+        for (const projectA of setA) {
+            if (!allowed.has(projectA)) {
+                allowed.set(projectA, new Set());
+            }
+            const currentSetA = allowed.get(projectA);
+            for (const projectB of setB) {
+                currentSetA.add(projectB);
+            }
+        }
+        for (const projectB of setB) {
+            if (!allowed.has(projectB)) {
+                allowed.set(projectB, new Set());
+            }
+            const currentSetB = allowed.get(projectB);
+            for (const projectA of setA) {
+                currentSetB.add(projectA);
+            }
+        }
+    }
+    return allowed;
+}