@nx/eslint-plugin 16.4.0-beta.9 → 16.5.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/eslint-plugin",
-  "version": "16.4.0-beta.9",
+  "version": "16.5.0-beta.0",
   "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": {
@@ -33,14 +33,15 @@
     }
   },
   "dependencies": {
-    "@nrwl/eslint-plugin-nx": "16.4.0-beta.9",
-    "@nx/devkit": "16.4.0-beta.9",
-    "@nx/js": "16.4.0-beta.9",
+    "@nrwl/eslint-plugin-nx": "16.5.0-beta.0",
+    "@nx/devkit": "16.5.0-beta.0",
+    "@nx/js": "16.5.0-beta.0",
     "@typescript-eslint/type-utils": "^5.58.0",
     "@typescript-eslint/utils": "^5.58.0",
     "chalk": "^4.1.0",
     "confusing-browser-globals": "^1.0.9",
-    "semver": "7.3.4"
+    "jsonc-eslint-parser": "^2.1.0",
+    "semver": "7.5.3"
   },
   "publishConfig": {
     "access": "public"
@@ -49,5 +50,5 @@
     "migrations": "./migrations.json"
   },
   "types": "./src/index.d.ts",
-  "gitHead": "b7fbc25d5be1789d42805e2254cf4a6070889157"
+  "gitHead": "376d656cfc7f6390ff1cd6d9de348baf7bccbf33"
 }

package/src/index.js

@@ -10,6 +10,7 @@ const angular_1 = require("./configs/angular");
 const angular_template_1 = require("./configs/angular-template");
 const enforce_module_boundaries_1 = require("./rules/enforce-module-boundaries");
 const nx_plugin_checks_1 = require("./rules/nx-plugin-checks");
+const dependency_checks_1 = require("./rules/dependency-checks");
 // Resolve any custom rules that might exist in the current workspace
 const resolve_workspace_rules_1 = require("./resolve-workspace-rules");
 module.exports = {
@@ -23,5 +24,5 @@ module.exports = {
         angular: angular_1.default,
         'angular-template': angular_template_1.default,
     },
-    rules: Object.assign({ [enforce_module_boundaries_1.RULE_NAME]: enforce_module_boundaries_1.default, [nx_plugin_checks_1.RULE_NAME]: nx_plugin_checks_1.default }, resolve_workspace_rules_1.workspaceRules),
+    rules: Object.assign({ [enforce_module_boundaries_1.RULE_NAME]: enforce_module_boundaries_1.default, [nx_plugin_checks_1.RULE_NAME]: nx_plugin_checks_1.default, [dependency_checks_1.RULE_NAME]: dependency_checks_1.default }, resolve_workspace_rules_1.workspaceRules),
 };

package/src/rules/dependency-checks.d.ts

@@ -0,0 +1,14 @@
+export type Options = [
+    {
+        buildTargets?: string[];
+        checkMissingDependencies?: boolean;
+        checkObsoleteDependencies?: boolean;
+        checkVersionMismatches?: boolean;
+        checkMissingPackageJson?: boolean;
+        ignoredDependencies?: string[];
+    }
+];
+export type MessageIds = 'missingDependency' | 'obsoleteDependency' | 'versionMismatch' | 'missingDependencySection';
+export declare const RULE_NAME = "dependency-checks";
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export default _default;

package/src/rules/dependency-checks.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const devkit_1 = require("@nx/devkit");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const project_graph_utils_1 = require("../utils/project-graph-utils");
+const runtime_lint_utils_1 = require("../utils/runtime-lint-utils");
+const path_1 = require("path");
+const internal_1 = require("@nx/js/src/internal");
+const semver_1 = require("semver");
+const js_1 = require("@nx/js");
+const package_json_utils_1 = require("../utils/package-json-utils");
+exports.RULE_NAME = 'dependency-checks';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Checks dependencies in project's package.json for version mismatches`,
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    buildTargets: [{ type: 'string' }],
+                    ignoreDependencies: [{ type: 'string' }],
+                    checkMissingDependencies: { type: 'boolean' },
+                    checkObsoleteDependencies: { type: 'boolean' },
+                    checkVersionMismatches: { type: 'boolean' },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            missingDependency: `The "{{projectName}}" uses the package "{{packageName}}", but it is missing from the project's "package.json".`,
+            obsoleteDependency: `The "{{packageName}}" package is not used by "{{projectName}}".`,
+            versionMismatch: `The version specifier does not contain the installed version of "{{packageName}}" package: {{version}}.`,
+            missingDependencySection: `Dependency sections are missing from the "package.json" but following dependencies were detected:{{dependencies}}`,
+        },
+    },
+    defaultOptions: [
+        {
+            buildTargets: ['build'],
+            checkMissingDependencies: true,
+            checkObsoleteDependencies: true,
+            checkVersionMismatches: true,
+            ignoredDependencies: [],
+        },
+    ],
+    create(context, [{ buildTargets, ignoredDependencies, checkMissingDependencies, checkObsoleteDependencies, checkVersionMismatches, },]) {
+        var _a;
+        if (!context.parserServices.isJSON) {
+            return {};
+        }
+        const fileName = (0, devkit_1.normalizePath)(context.getFilename());
+        // support only package.json
+        if (!fileName.endsWith('/package.json')) {
+            return {};
+        }
+        const projectPath = (0, devkit_1.normalizePath)(globalThis.projectPath || devkit_1.workspaceRoot);
+        const sourceFilePath = (0, runtime_lint_utils_1.getSourceFilePath)(fileName, projectPath);
+        const { projectGraph, projectRootMappings, projectFileMap } = (0, project_graph_utils_1.readProjectGraph)(exports.RULE_NAME);
+        if (!projectGraph) {
+            return {};
+        }
+        const sourceProject = (0, runtime_lint_utils_1.findProject)(projectGraph, projectRootMappings, sourceFilePath);
+        // check if source project exists
+        if (!sourceProject) {
+            return {};
+        }
+        // check if library has a build target
+        const buildTarget = buildTargets.find((t) => { var _a; return (_a = sourceProject.data.targets) === null || _a === void 0 ? void 0 : _a[t]; });
+        if (!buildTarget) {
+            return {};
+        }
+        // gather helper dependencies for @nx/js executors
+        const helperDependencies = (0, js_1.getHelperDependenciesFromProjectGraph)(devkit_1.workspaceRoot, sourceProject.name, projectGraph);
+        // find all dependencies for the project
+        const npmDeps = (0, internal_1.findProjectsNpmDependencies)(sourceProject, projectGraph, buildTarget, {
+            helperDependencies: helperDependencies.map((dep) => dep.target),
+        }, (0, package_json_utils_1.removePackageJsonFromFileMap)(projectFileMap));
+        const projDependencies = Object.assign(Object.assign({}, npmDeps.dependencies), npmDeps.peerDependencies);
+        const expectedDependencyNames = Object.keys(projDependencies);
+        const projPackageJsonPath = (0, path_1.join)(devkit_1.workspaceRoot, sourceProject.data.root, 'package.json');
+        (_a = globalThis.projPackageJsonDeps) !== null && _a !== void 0 ? _a : (globalThis.projPackageJsonDeps = (0, package_json_utils_1.getAllDependencies)(projPackageJsonPath));
+        const projPackageJsonDeps = globalThis.projPackageJsonDeps;
+        const rootPackageJsonDeps = (0, package_json_utils_1.getAllDependencies)((0, path_1.join)(devkit_1.workspaceRoot, 'package.json'));
+        function validateMissingDependencies(node) {
+            if (!checkMissingDependencies) {
+                return;
+            }
+            const missingDeps = expectedDependencyNames.filter((d) => !projPackageJsonDeps[d]);
+            missingDeps.forEach((d) => {
+                if (!ignoredDependencies.includes(d)) {
+                    context.report({
+                        node: node,
+                        messageId: 'missingDependency',
+                        data: { packageName: d, projectName: sourceProject.name },
+                        fix(fixer) {
+                            projPackageJsonDeps[d] =
+                                rootPackageJsonDeps[d] || projDependencies[d];
+                            const deps = node.value.properties;
+                            if (deps.length) {
+                                return fixer.insertTextAfter(deps[deps.length - 1], `,\n    "${d}": "${projPackageJsonDeps[d]}"`);
+                            }
+                            else {
+                                return fixer.replaceTextRange([node.value.range[0] + 1, node.value.range[1] - 1], `\n    "${d}": "${projPackageJsonDeps[d]}"\n  `);
+                            }
+                        },
+                    });
+                }
+            });
+        }
+        function validateVersionMatchesInstalled(node, packageName, packageRange) {
+            if (!checkVersionMismatches) {
+                return;
+            }
+            if (projDependencies[packageName] === '*' ||
+                (0, semver_1.satisfies)(projDependencies[packageName], packageRange)) {
+                return;
+            }
+            context.report({
+                node: node,
+                messageId: 'versionMismatch',
+                data: {
+                    packageName: packageName,
+                    version: projDependencies[packageName],
+                },
+                fix: (fixer) => fixer.replaceText(node, `"${packageName}": "${rootPackageJsonDeps[packageName] || projDependencies[packageName]}"`),
+            });
+        }
+        function reportObsoleteDependency(node, packageName) {
+            if (!checkObsoleteDependencies) {
+                return;
+            }
+            context.report({
+                node: node,
+                messageId: 'obsoleteDependency',
+                data: { packageName: packageName, projectName: sourceProject.name },
+                fix: (fixer) => {
+                    const isLastProperty = node.parent.properties[node.parent.properties.length - 1] === node;
+                    const index = node.parent.properties.findIndex((n) => n === node);
+                    if (index > 0) {
+                        const previousNode = node.parent.properties[index - 1];
+                        return fixer.removeRange([
+                            previousNode.range[1] + 1,
+                            node.range[1] + (isLastProperty ? 0 : 1),
+                        ]);
+                    }
+                    else {
+                        const parent = node.parent;
+                        // it's the only property
+                        if (isLastProperty) {
+                            return fixer.removeRange([
+                                parent.range[0] + 1,
+                                parent.range[1] - 1,
+                            ]);
+                        }
+                        else {
+                            return fixer.removeRange([
+                                parent.range[0] + 1,
+                                node.range[1] + 1,
+                            ]);
+                        }
+                    }
+                    // remove 4 spaces, new line and potential comma from previous line
+                    const shouldRemoveSiblingComma = isLastProperty && node.parent.properties.length > 1;
+                    const leadingChars = 5 + (shouldRemoveSiblingComma ? 1 : 0);
+                    return fixer.removeRange([
+                        node.range[0] - leadingChars,
+                        node.range[1] + (isLastProperty ? 0 : 1),
+                    ]);
+                },
+            });
+        }
+        function validateDependenciesSectionExistance(node) {
+            if (!expectedDependencyNames.length ||
+                !expectedDependencyNames.some((d) => !ignoredDependencies.includes(d))) {
+                return;
+            }
+            if (!node.properties ||
+                !node.properties.some((p) => [
+                    'dependencies',
+                    'peerDependencies',
+                    'devDependencies',
+                    'optionalDependencies',
+                ].includes(p.key.value))) {
+                context.report({
+                    node: node,
+                    messageId: 'missingDependencySection',
+                    data: {
+                        dependencies: expectedDependencyNames
+                            .map((d) => `\n- "${d}"`)
+                            .join(),
+                    },
+                    fix: (fixer) => {
+                        expectedDependencyNames.sort().reduce((acc, d) => {
+                            acc[d] = rootPackageJsonDeps[d] || projDependencies[d];
+                            return acc;
+                        }, projPackageJsonDeps);
+                        const dependencies = Object.keys(projPackageJsonDeps)
+                            .map((d) => `\n    "${d}": "${projPackageJsonDeps[d]}"`)
+                            .join(',');
+                        if (!node.properties.length) {
+                            return fixer.replaceText(node, `{\n  "dependencies": {${dependencies}\n  }\n}`);
+                        }
+                        else {
+                            return fixer.insertTextAfter(node.properties[node.properties.length - 1], `,\n  "dependencies": {${dependencies}\n  }`);
+                        }
+                    },
+                });
+            }
+        }
+        return {
+            ['JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=/^(dev|peer|optional)?dependencies$/i]'](node) {
+                return validateMissingDependencies(node);
+            },
+            ['JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=/^(dev|peer|optional)?dependencies$/i] > JSONObjectExpression > JSONProperty'](node) {
+                const packageName = node.key.value;
+                const packageRange = node.value.value;
+                if (ignoredDependencies.includes(packageName)) {
+                    return;
+                }
+                if (expectedDependencyNames.includes(packageName)) {
+                    return validateVersionMatchesInstalled(node, packageName, packageRange);
+                }
+                else {
+                    return reportObsoleteDependency(node, packageName);
+                }
+            },
+            ['JSONExpressionStatement > JSONObjectExpression'](node) {
+                return validateDependenciesSectionExistance(node);
+            },
+        };
+    },
+});

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

@@ -64,7 +64,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             noImportsOfApps: 'Imports of apps are forbidden',
             noImportsOfE2e: 'Imports of e2e projects are forbidden',
             noImportOfNonBuildableLibraries: 'Buildable libraries cannot import or export from non-buildable libraries',
-            noImportsOfLazyLoadedLibraries: `Imports of lazy-loaded libraries are forbidden`,
+            noImportsOfLazyLoadedLibraries: `Static imports of lazy-loaded libraries are forbidden.\n\nLibrary "{{targetProjectName}}" is lazy-loaded in these files:\n{{filePaths}}`,
             projectWithoutTagsCannotHaveDependencies: `A project without tags matching at least one constraint cannot depend on any libraries`,
             bannedExternalImportsViolation: `A project tagged with "{{sourceTag}}" is not allowed to import the "{{package}}" package`,
             nestedBannedExternalImportsViolation: `A project tagged with "{{sourceTag}}" is not allowed to import the "{{package}}" package. Nested import found at {{childProjectName}}`,
@@ -312,7 +312,14 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                 node.importKind !== 'type' &&
                 !checkDynamicDependenciesExceptions.some((a) => (0, runtime_lint_utils_1.matchImportWithWildcard)(a, imp)) &&
                 (0, runtime_lint_utils_1.onlyLoadChildren)(projectGraph, sourceProject.name, targetProject.name, [])) {
+                const filesWithLazyImports = (0, graph_utils_1.findFilesWithDynamicImports)(projectFileMap, sourceProject.name, targetProject.name);
                 context.report({
+                    data: {
+                        filePaths: filesWithLazyImports
+                            .map(({ file }) => `- ${file}`)
+                            .join('\n'),
+                        targetProjectName: targetProject.name,
+                    },
                     node,
                     messageId: 'noImportsOfLazyLoadedLibraries',
                 });

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

@@ -1,5 +1,6 @@
-import type { ProjectFileMap, ProjectGraph, ProjectGraphProjectNode } from '@nx/devkit';
+import type { FileData, ProjectFileMap, ProjectGraph, ProjectGraphProjectNode } from '@nx/devkit';
 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 findFilesInCircularPath(projectFileMap: ProjectFileMap, circularPath: ProjectGraphProjectNode[]): Array<string[]>;
+export declare function findFilesWithDynamicImports(projectFileMap: ProjectFileMap, sourceProjectName: string, targetProjectName: string): FileData[];

package/src/utils/graph-utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findFilesInCircularPath = exports.checkCircularPath = exports.pathExists = exports.getPath = void 0;
+exports.findFilesWithDynamicImports = exports.findFilesInCircularPath = exports.checkCircularPath = exports.pathExists = exports.getPath = void 0;
 const project_graph_1 = require("nx/src/config/project-graph");
 const reach = {
     graph: null,
@@ -114,3 +114,16 @@ function findFilesInCircularPath(projectFileMap, circularPath) {
     return filePathChain;
 }
 exports.findFilesInCircularPath = findFilesInCircularPath;
+function findFilesWithDynamicImports(projectFileMap, sourceProjectName, targetProjectName) {
+    const files = [];
+    projectFileMap[sourceProjectName].forEach((file) => {
+        if (!file.deps)
+            return;
+        if (file.deps.some((d) => (0, project_graph_1.fileDataDepTarget)(d) === targetProjectName &&
+            (0, project_graph_1.fileDataDepType)(d) === project_graph_1.DependencyType.dynamic)) {
+            files.push(file);
+        }
+    });
+    return files;
+}
+exports.findFilesWithDynamicImports = findFilesWithDynamicImports;

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

@@ -0,0 +1,3 @@
+import { ProjectFileMap } from '@nx/devkit';
+export declare function getAllDependencies(path: string): Record<string, string>;
+export declare function removePackageJsonFromFileMap(projectFileMap: ProjectFileMap): ProjectFileMap;

package/src/utils/package-json-utils.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removePackageJsonFromFileMap = exports.getAllDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+function getAllDependencies(path) {
+    if ((0, fs_1.existsSync)(path)) {
+        const packageJson = (0, devkit_1.readJsonFile)(path);
+        return Object.assign(Object.assign(Object.assign({}, packageJson.dependencies), packageJson.devDependencies), packageJson.peerDependencies);
+    }
+    return {};
+}
+exports.getAllDependencies = getAllDependencies;
+function removePackageJsonFromFileMap(projectFileMap) {
+    const newFileMap = {};
+    Object.keys(projectFileMap).forEach((key) => {
+        newFileMap[key] = projectFileMap[key].filter((f) => !f.file.endsWith('/package.json'));
+    });
+    return newFileMap;
+}
+exports.removePackageJsonFromFileMap = removePackageJsonFromFileMap;