@nx/eslint-plugin 0.0.0-pr-22179-271588f

package/src/rules/dependency-checks.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const path_1 = require("path");
+const semver_1 = require("semver");
+const devkit_1 = require("@nx/devkit");
+const find_npm_dependencies_1 = require("@nx/js/src/utils/find-npm-dependencies");
+const project_graph_utils_1 = require("../utils/project-graph-utils");
+const runtime_lint_utils_1 = require("../utils/runtime-lint-utils");
+const package_json_utils_1 = require("../utils/package-json-utils");
+const utils_1 = require("@typescript-eslint/utils");
+exports.RULE_NAME = 'dependency-checks';
+exports.default = utils_1.ESLintUtils.RuleCreator(() => `https://github.com/nrwl/nx/blob/${devkit_1.NX_VERSION}/docs/generated/packages/eslint-plugin/documents/dependency-checks.md`)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Checks dependencies in project's package.json for version mismatches`,
+            recommended: 'recommended',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    buildTargets: { type: 'array', items: { type: 'string' } },
+                    ignoredDependencies: { type: 'array', items: { type: 'string' } },
+                    ignoredFiles: { type: 'array', items: { type: 'string' } },
+                    checkMissingDependencies: { type: 'boolean' },
+                    checkObsoleteDependencies: { type: 'boolean' },
+                    checkVersionMismatches: { type: 'boolean' },
+                    includeTransitiveDependencies: { type: 'boolean' },
+                    useLocalPathsForWorkspaceDependencies: { type: 'boolean' },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            missingDependency: `The "{{projectName}}" project uses the following packages, but they are missing from "{{section}}":{{packageNames}}`,
+            obsoleteDependency: `The "{{packageName}}" package is not used by "{{projectName}}" project.`,
+            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: [],
+            ignoredFiles: [],
+            includeTransitiveDependencies: false,
+            useLocalPathsForWorkspaceDependencies: false,
+        },
+    ],
+    create(context, [{ buildTargets, ignoredDependencies, ignoredFiles, checkMissingDependencies, checkObsoleteDependencies, checkVersionMismatches, includeTransitiveDependencies, useLocalPathsForWorkspaceDependencies, },]) {
+        if (!context.parserServices.isJSON) {
+            return {};
+        }
+        const fileName = (0, devkit_1.normalizePath)(context.getFilename());
+        // support only package.json
+        if (!fileName.endsWith('/package.json')) {
+            return {};
+        }
+        const sourceFilePath = (0, runtime_lint_utils_1.getSourceFilePath)(fileName, devkit_1.workspaceRoot);
+        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) => sourceProject.data.targets?.[t]);
+        if (!buildTarget) {
+            return {};
+        }
+        const rootPackageJson = (0, package_json_utils_1.getPackageJson)((0, path_1.join)(devkit_1.workspaceRoot, 'package.json'));
+        const npmDependencies = (0, find_npm_dependencies_1.findNpmDependencies)(devkit_1.workspaceRoot, sourceProject, projectGraph, projectFileMap, buildTarget, // TODO: What if child library has a build target different from the parent?
+        {
+            includeTransitiveDependencies,
+            ignoredFiles,
+            useLocalPathsForWorkspaceDependencies,
+        });
+        const expectedDependencyNames = Object.keys(npmDependencies);
+        const projPackageJsonPath = (0, path_1.join)(devkit_1.workspaceRoot, sourceProject.data.root, 'package.json');
+        const projPackageJsonDeps = (0, package_json_utils_1.getProductionDependencies)(projPackageJsonPath);
+        const rootPackageJsonDeps = (0, package_json_utils_1.getAllDependencies)(rootPackageJson);
+        function validateMissingDependencies(node) {
+            if (!checkMissingDependencies) {
+                return;
+            }
+            const missingDeps = expectedDependencyNames.filter((d) => !projPackageJsonDeps[d] && !ignoredDependencies.includes(d));
+            if (missingDeps.length) {
+                context.report({
+                    node: node,
+                    messageId: 'missingDependency',
+                    data: {
+                        packageNames: missingDeps.map((d) => `\n    - ${d}`).join(''),
+                        section: node.key.value,
+                        projectName: sourceProject.name,
+                    },
+                    fix(fixer) {
+                        missingDeps.forEach((d) => {
+                            projPackageJsonDeps[d] =
+                                rootPackageJsonDeps[d] || npmDependencies[d];
+                        });
+                        const deps = node.value.properties;
+                        const mappedDeps = missingDeps
+                            .map((d) => `\n    "${d}": "${projPackageJsonDeps[d]}"`)
+                            .join(',');
+                        if (deps.length) {
+                            return fixer.insertTextAfter(deps[deps.length - 1], `,${mappedDeps}`);
+                        }
+                        else {
+                            return fixer.insertTextAfterRange([node.value.range[0] + 1, node.value.range[1] - 1], `${mappedDeps}\n  `);
+                        }
+                    },
+                });
+            }
+        }
+        function validateVersionMatchesInstalled(node, packageName, packageRange) {
+            if (!checkVersionMismatches) {
+                return;
+            }
+            if (npmDependencies[packageName].startsWith('file:') ||
+                packageRange.startsWith('file:') ||
+                npmDependencies[packageName] === '*' ||
+                packageRange === '*' ||
+                (0, semver_1.satisfies)(npmDependencies[packageName], packageRange, {
+                    includePrerelease: true,
+                })) {
+                return;
+            }
+            context.report({
+                node: node,
+                messageId: 'versionMismatch',
+                data: {
+                    packageName: packageName,
+                    version: npmDependencies[packageName],
+                },
+                fix: (fixer) => fixer.replaceText(node, `"${packageName}": "${rootPackageJsonDeps[packageName] || npmDependencies[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] + (isLastProperty ? 0 : 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,
+                            ]);
+                        }
+                    }
+                },
+            });
+        }
+        function validateDependenciesSectionExistance(node) {
+            if (!expectedDependencyNames.length ||
+                !expectedDependencyNames.some((d) => !ignoredDependencies.includes(d))) {
+                return;
+            }
+            if (!node.properties ||
+                !node.properties.some((p) => ['dependencies', 'peerDependencies', '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] || npmDependencies[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=/^(peer|optional)?dependencies$/i]'](node) {
+                validateMissingDependencies(node);
+            },
+            ['JSONExpressionStatement > JSONObjectExpression > JSONProperty[key.value=/^(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)) {
+                    validateVersionMatchesInstalled(node, packageName, packageRange);
+                }
+                else {
+                    reportObsoleteDependency(node, packageName);
+                }
+            },
+            ['JSONExpressionStatement > JSONObjectExpression'](node) {
+                validateDependenciesSectionExistance(node);
+            },
+        };
+    },
+});

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

@@ -0,0 +1,18 @@
+import { DepConstraint } from '../utils/runtime-lint-utils';
+import { ESLintUtils } from '@typescript-eslint/utils';
+type Options = [
+    {
+        allow: string[];
+        buildTargets: string[];
+        depConstraints: DepConstraint[];
+        enforceBuildableLibDependency: boolean;
+        allowCircularSelfDependency: boolean;
+        checkDynamicDependenciesExceptions: string[];
+        banTransitiveDependencies: boolean;
+        checkNestedExternalImports: boolean;
+    }
+];
+export type MessageIds = 'noRelativeOrAbsoluteImportsAcrossLibraries' | 'noRelativeOrAbsoluteExternals' | 'noSelfCircularDependencies' | 'noCircularDependencies' | 'noImportsOfApps' | 'noImportsOfE2e' | 'noImportOfNonBuildableLibraries' | 'noImportsOfLazyLoadedLibraries' | 'projectWithoutTagsCannotHaveDependencies' | 'bannedExternalImportsViolation' | 'nestedBannedExternalImportsViolation' | 'noTransitiveDependencies' | 'onlyTagsConstraintViolation' | 'emptyOnlyTagsConstraintViolation' | 'notTagsConstraintViolation';
+export declare const RULE_NAME = "enforce-module-boundaries";
+declare const _default: ESLintUtils.RuleModule<MessageIds, Options, ESLintUtils.RuleListener>;
+export default _default;