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

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

@@ -0,0 +1,480 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const devkit_1 = require("@nx/devkit");
+const fileutils_1 = require("nx/src/utils/fileutils");
+const graph_utils_1 = require("../utils/graph-utils");
+const runtime_lint_utils_1 = require("../utils/runtime-lint-utils");
+const utils_1 = require("@typescript-eslint/utils");
+const path_1 = require("path");
+const ast_utils_1 = require("../utils/ast-utils");
+const project_graph_utils_1 = require("../utils/project-graph-utils");
+const utils_2 = require("@typescript-eslint/utils");
+exports.RULE_NAME = 'enforce-module-boundaries';
+exports.default = utils_2.ESLintUtils.RuleCreator(() => `https://github.com/nrwl/nx/blob/${devkit_1.NX_VERSION}/docs/generated/packages/eslint-plugin/documents/enforce-module-boundaries.md`)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Ensure that module boundaries are respected within the monorepo`,
+            recommended: 'recommended',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    enforceBuildableLibDependency: { type: 'boolean' },
+                    allowCircularSelfDependency: { type: 'boolean' },
+                    checkDynamicDependenciesExceptions: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                    banTransitiveDependencies: { type: 'boolean' },
+                    checkNestedExternalImports: { type: 'boolean' },
+                    allow: { type: 'array', items: { type: 'string' } },
+                    buildTargets: { type: 'array', items: { type: 'string' } },
+                    depConstraints: {
+                        type: 'array',
+                        items: {
+                            oneOf: [
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        sourceTag: { type: 'string' },
+                                        onlyDependOnLibsWithTags: {
+                                            type: 'array',
+                                            items: { type: 'string' },
+                                        },
+                                        allowedExternalImports: {
+                                            type: 'array',
+                                            items: { type: 'string' },
+                                        },
+                                        bannedExternalImports: {
+                                            type: 'array',
+                                            items: { type: 'string' },
+                                        },
+                                        notDependOnLibsWithTags: {
+                                            type: 'array',
+                                            items: { type: 'string' },
+                                        },
+                                    },
+                                    additionalProperties: false,
+                                },
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        allSourceTags: {
+                                            type: 'array',
+                                            items: { type: 'string' },
+                                            minItems: 2,
+                                        },
+                                        onlyDependOnLibsWithTags: {
+                                            type: 'array',
+                                            items: { type: 'string' },
+                                        },
+                                        allowedExternalImports: {
+                                            type: 'array',
+                                            items: { type: 'string' },
+                                        },
+                                        bannedExternalImports: {
+                                            type: 'array',
+                                            items: { type: 'string' },
+                                        },
+                                        notDependOnLibsWithTags: {
+                                            type: 'array',
+                                            items: { type: 'string' },
+                                        },
+                                    },
+                                    additionalProperties: false,
+                                },
+                            ],
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            noRelativeOrAbsoluteImportsAcrossLibraries: `Projects cannot be imported by a relative or absolute path, and must begin with a npm scope`,
+            noRelativeOrAbsoluteExternals: `External resources cannot be imported using a relative or absolute path`,
+            noCircularDependencies: `Circular dependency between "{{sourceProjectName}}" and "{{targetProjectName}}" detected: {{path}}\n\nCircular file chain:\n{{filePaths}}`,
+            noSelfCircularDependencies: `Projects should use relative imports to import from other files within the same project. Use "./path/to/file" instead of import from "{{imp}}"`,
+            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: `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 "{{imp}}"`,
+            nestedBannedExternalImportsViolation: `A project tagged with "{{sourceTag}}" is not allowed to import "{{imp}}". Nested import found at {{childProjectName}}`,
+            noTransitiveDependencies: `Transitive dependencies are not allowed. Only packages defined in the "package.json" can be imported`,
+            onlyTagsConstraintViolation: `A project tagged with "{{sourceTag}}" can only depend on libs tagged with {{tags}}`,
+            emptyOnlyTagsConstraintViolation: 'A project tagged with "{{sourceTag}}" cannot depend on any libs with tags',
+            notTagsConstraintViolation: `A project tagged with "{{sourceTag}}" can not depend on libs tagged with {{tags}}\n\nViolation detected in:\n{{projects}}`,
+        },
+    },
+    defaultOptions: [
+        {
+            allow: [],
+            buildTargets: ['build'],
+            depConstraints: [],
+            enforceBuildableLibDependency: false,
+            allowCircularSelfDependency: false,
+            checkDynamicDependenciesExceptions: [],
+            banTransitiveDependencies: false,
+            checkNestedExternalImports: false,
+        },
+    ],
+    create(context, [{ allow, buildTargets, depConstraints, enforceBuildableLibDependency, allowCircularSelfDependency, checkDynamicDependenciesExceptions, banTransitiveDependencies, checkNestedExternalImports, },]) {
+        /**
+         * Globally cached info about workspace
+         */
+        const projectPath = (0, devkit_1.normalizePath)(global.projectPath || devkit_1.workspaceRoot);
+        const fileName = (0, devkit_1.normalizePath)(context.getFilename());
+        const { projectGraph, projectRootMappings, projectFileMap, targetProjectLocator, } = (0, project_graph_utils_1.readProjectGraph)(exports.RULE_NAME);
+        if (!projectGraph) {
+            return {};
+        }
+        const workspaceLayout = global.workspaceLayout;
+        function run(node) {
+            // Ignoring ExportNamedDeclarations like:
+            // export class Foo {}
+            if (!node.source) {
+                return;
+            }
+            // accept only literals because template literals have no value
+            if (node.source.type !== utils_1.AST_NODE_TYPES.Literal) {
+                return;
+            }
+            const imp = node.source.value;
+            // whitelisted import
+            if (allow.some((a) => (0, runtime_lint_utils_1.matchImportWithWildcard)(a, imp))) {
+                return;
+            }
+            const sourceFilePath = (0, runtime_lint_utils_1.getSourceFilePath)(fileName, projectPath);
+            const sourceProject = (0, runtime_lint_utils_1.findProject)(projectGraph, projectRootMappings, sourceFilePath);
+            // If source is not part of an nx workspace, return.
+            if (!sourceProject) {
+                return;
+            }
+            // check for relative and absolute imports
+            const isAbsoluteImportIntoAnotherProj = (0, runtime_lint_utils_1.isAbsoluteImportIntoAnotherProject)(imp, workspaceLayout);
+            let targetProject;
+            if (isAbsoluteImportIntoAnotherProj) {
+                targetProject = (0, runtime_lint_utils_1.findProject)(projectGraph, projectRootMappings, imp);
+            }
+            else {
+                targetProject = (0, runtime_lint_utils_1.getTargetProjectBasedOnRelativeImport)(imp, projectPath, projectGraph, projectRootMappings, sourceFilePath);
+            }
+            if ((targetProject && sourceProject !== targetProject) ||
+                isAbsoluteImportIntoAnotherProj) {
+                context.report({
+                    node,
+                    messageId: 'noRelativeOrAbsoluteImportsAcrossLibraries',
+                    fix(fixer) {
+                        if (targetProject) {
+                            const indexTsPaths = (0, ast_utils_1.getBarrelEntryPointProjectNode)(targetProject);
+                            if (indexTsPaths && indexTsPaths.length > 0) {
+                                const specifiers = node.specifiers;
+                                if (!specifiers || specifiers.length === 0) {
+                                    return;
+                                }
+                                const imports = specifiers
+                                    .filter((s) => s.type === 'ImportSpecifier')
+                                    .map((s) => s.imported.name);
+                                // process each potential entry point and try to find the imports
+                                const importsToRemap = [];
+                                for (const entryPointPath of indexTsPaths) {
+                                    for (const importMember of imports) {
+                                        const importPath = (0, ast_utils_1.getRelativeImportPath)(importMember, (0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, entryPointPath.path), sourceProject.data.sourceRoot);
+                                        // we cannot remap, so leave it as is
+                                        if (importPath) {
+                                            importsToRemap.push({
+                                                member: importMember,
+                                                importPath: entryPointPath.importScope,
+                                            });
+                                        }
+                                    }
+                                }
+                                const adjustedRelativeImports = (0, runtime_lint_utils_1.groupImports)(importsToRemap);
+                                if (adjustedRelativeImports !== '') {
+                                    return fixer.replaceTextRange(node.range, adjustedRelativeImports);
+                                }
+                            }
+                        }
+                    },
+                });
+                return;
+            }
+            targetProject =
+                targetProject ||
+                    (0, runtime_lint_utils_1.findProjectUsingImport)(projectGraph, targetProjectLocator, sourceFilePath, imp);
+            if (!targetProject) {
+                // non-project imports cannot use relative or absolute paths
+                if ((0, fileutils_1.isRelativePath)(imp) || imp.startsWith('/')) {
+                    context.report({
+                        node,
+                        messageId: 'noRelativeOrAbsoluteExternals',
+                    });
+                }
+                // If target is not found (including node internals) we bail early
+                return;
+            }
+            // 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 (!allowCircularSelfDependency &&
+                    !(0, fileutils_1.isRelativePath)(imp) &&
+                    !(0, runtime_lint_utils_1.belongsToDifferentNgEntryPoint)(imp, sourceFilePath, sourceProject.data.root)) {
+                    context.report({
+                        node,
+                        messageId: 'noSelfCircularDependencies',
+                        data: {
+                            imp,
+                        },
+                        fix(fixer) {
+                            // imp has form of @myorg/someproject/some/path
+                            const indexTsPaths = (0, ast_utils_1.getBarrelEntryPointByImportScope)(imp);
+                            if (indexTsPaths.length > 0) {
+                                const specifiers = node.specifiers;
+                                if (!specifiers || specifiers.length === 0) {
+                                    return;
+                                }
+                                // imported JS functions to remap
+                                const imports = specifiers
+                                    .filter((s) => s.type === 'ImportSpecifier')
+                                    .map((s) => s.imported.name);
+                                // process each potential entry point and try to find the imports
+                                const importsToRemap = [];
+                                for (const entryPointPath of indexTsPaths) {
+                                    for (const importMember of imports) {
+                                        const importPath = (0, ast_utils_1.getRelativeImportPath)(importMember, (0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, entryPointPath), sourceProject.data.sourceRoot);
+                                        if (importPath) {
+                                            // resolve the import path
+                                            const relativePath = (0, path_1.relative)((0, path_1.dirname)(fileName), (0, path_1.dirname)(importPath));
+                                            // the string we receive from elsewhere might not have a leading './' here despite still being a relative path
+                                            // we'd like to ensure it's a normalized relative form starting from ./ or ../
+                                            const ensureRelativeForm = (path) => path.startsWith('./') || path.startsWith('../')
+                                                ? path
+                                                : `./${path}`;
+                                            // if the string is empty, it's the current file
+                                            const importPathResolved = relativePath === ''
+                                                ? `./${(0, path_1.basename)(importPath)}`
+                                                : ensureRelativeForm((0, devkit_1.joinPathFragments)(relativePath, (0, path_1.basename)(importPath)));
+                                            importsToRemap.push({
+                                                member: importMember,
+                                                // remove .ts or .tsx from the end of the file path
+                                                importPath: importPathResolved.replace(/.tsx?$/, ''),
+                                            });
+                                        }
+                                    }
+                                }
+                                const adjustedRelativeImports = (0, runtime_lint_utils_1.groupImports)(importsToRemap);
+                                if (adjustedRelativeImports !== '') {
+                                    return fixer.replaceTextRange(node.range, adjustedRelativeImports);
+                                }
+                            }
+                        },
+                    });
+                }
+                return;
+            }
+            // project => npm package
+            if (targetProject.type === 'npm') {
+                if (banTransitiveDependencies &&
+                    !(0, runtime_lint_utils_1.isDirectDependency)(sourceProject, targetProject)) {
+                    context.report({
+                        node,
+                        messageId: 'noTransitiveDependencies',
+                    });
+                }
+                const constraint = (0, runtime_lint_utils_1.hasBannedImport)(sourceProject, targetProject, depConstraints, imp);
+                if (constraint) {
+                    context.report({
+                        node,
+                        messageId: 'bannedExternalImportsViolation',
+                        data: {
+                            sourceTag: (0, runtime_lint_utils_1.isComboDepConstraint)(constraint)
+                                ? constraint.allSourceTags.join('" and "')
+                                : constraint.sourceTag,
+                            imp,
+                        },
+                    });
+                }
+                return;
+            }
+            // check constraints between libs and apps
+            // check for circular dependency
+            const circularPath = (0, graph_utils_1.checkCircularPath)(projectGraph, sourceProject, targetProject);
+            if (circularPath.length !== 0) {
+                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.
+                const spacer = '  ';
+                context.report({
+                    node,
+                    messageId: 'noCircularDependencies',
+                    data: {
+                        sourceProjectName: sourceProject.name,
+                        targetProjectName: targetProject.name,
+                        path: circularPath.reduce((acc, v) => `${acc} -> ${v.name}`, sourceProject.name),
+                        filePaths: circularFilePath
+                            .map((files) => files.length > 1
+                            ? `[${files
+                                .map((f) => `\n${spacer}${spacer}${f}`)
+                                .join(',')}\n${spacer}]`
+                            : files[0])
+                            .reduce((acc, files) => `${acc}\n- ${files}`, `- ${sourceFilePath}`),
+                    },
+                });
+                return;
+            }
+            // cannot import apps
+            if (targetProject.type === 'app' && !(0, runtime_lint_utils_1.appIsMFERemote)(targetProject)) {
+                context.report({
+                    node,
+                    messageId: 'noImportsOfApps',
+                });
+                return;
+            }
+            // cannot import e2e projects
+            if (targetProject.type === 'e2e') {
+                context.report({
+                    node,
+                    messageId: 'noImportsOfE2e',
+                });
+                return;
+            }
+            // buildable-lib is not allowed to import non-buildable-lib
+            if (enforceBuildableLibDependency === true &&
+                sourceProject.type === 'lib' &&
+                targetProject.type === 'lib') {
+                if ((0, runtime_lint_utils_1.hasBuildExecutor)(sourceProject, buildTargets) &&
+                    !(0, runtime_lint_utils_1.hasBuildExecutor)(targetProject, buildTargets)) {
+                    context.report({
+                        node,
+                        messageId: 'noImportOfNonBuildableLibraries',
+                    });
+                    return;
+                }
+            }
+            // if we import a library using loadChildren, we should not import it using es6imports
+            if (!checkDynamicDependenciesExceptions.some((a) => (0, runtime_lint_utils_1.matchImportWithWildcard)(a, imp)) &&
+                (0, runtime_lint_utils_1.hasStaticImportOfDynamicResource)(node, 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',
+                });
+                return;
+            }
+            // check that dependency constraints are satisfied
+            if (depConstraints.length > 0) {
+                const constraints = (0, runtime_lint_utils_1.findConstraintsFor)(depConstraints, sourceProject);
+                // when no constrains found => error. Force the user to provision them.
+                if (constraints.length === 0) {
+                    context.report({
+                        node,
+                        messageId: 'projectWithoutTagsCannotHaveDependencies',
+                    });
+                    return;
+                }
+                const transitiveExternalDeps = checkNestedExternalImports
+                    ? (0, runtime_lint_utils_1.findTransitiveExternalDependencies)(projectGraph, targetProject)
+                    : [];
+                for (let constraint of constraints) {
+                    if (constraint.onlyDependOnLibsWithTags &&
+                        constraint.onlyDependOnLibsWithTags.length &&
+                        (0, runtime_lint_utils_1.hasNoneOfTheseTags)(targetProject, constraint.onlyDependOnLibsWithTags)) {
+                        context.report({
+                            node,
+                            messageId: 'onlyTagsConstraintViolation',
+                            data: {
+                                sourceTag: (0, runtime_lint_utils_1.isComboDepConstraint)(constraint)
+                                    ? constraint.allSourceTags.join('" and "')
+                                    : constraint.sourceTag,
+                                tags: (0, runtime_lint_utils_1.stringifyTags)(constraint.onlyDependOnLibsWithTags),
+                            },
+                        });
+                        return;
+                    }
+                    if (constraint.onlyDependOnLibsWithTags &&
+                        constraint.onlyDependOnLibsWithTags.length === 0 &&
+                        targetProject.data.tags.length !== 0) {
+                        context.report({
+                            node,
+                            messageId: 'emptyOnlyTagsConstraintViolation',
+                            data: {
+                                sourceTag: (0, runtime_lint_utils_1.isComboDepConstraint)(constraint)
+                                    ? constraint.allSourceTags.join('" and "')
+                                    : constraint.sourceTag,
+                            },
+                        });
+                        return;
+                    }
+                    if (constraint.notDependOnLibsWithTags &&
+                        constraint.notDependOnLibsWithTags.length) {
+                        const projectPaths = (0, runtime_lint_utils_1.findDependenciesWithTags)(targetProject, constraint.notDependOnLibsWithTags, projectGraph);
+                        if (projectPaths.length > 0) {
+                            context.report({
+                                node,
+                                messageId: 'notTagsConstraintViolation',
+                                data: {
+                                    sourceTag: (0, runtime_lint_utils_1.isComboDepConstraint)(constraint)
+                                        ? constraint.allSourceTags.join('" and "')
+                                        : constraint.sourceTag,
+                                    tags: (0, runtime_lint_utils_1.stringifyTags)(constraint.notDependOnLibsWithTags),
+                                    projects: projectPaths
+                                        .map((projectPath) => `- ${projectPath.map((p) => p.name).join(' -> ')}`)
+                                        .join('\n'),
+                                },
+                            });
+                            return;
+                        }
+                    }
+                    if (checkNestedExternalImports &&
+                        constraint.bannedExternalImports &&
+                        constraint.bannedExternalImports.length) {
+                        const matches = (0, runtime_lint_utils_1.hasBannedDependencies)(transitiveExternalDeps, projectGraph, constraint, imp);
+                        if (matches.length > 0) {
+                            matches.forEach(([target, violatingSource, constraint]) => {
+                                context.report({
+                                    node,
+                                    messageId: 'nestedBannedExternalImportsViolation',
+                                    data: {
+                                        sourceTag: (0, runtime_lint_utils_1.isComboDepConstraint)(constraint)
+                                            ? constraint.allSourceTags.join('" and "')
+                                            : constraint.sourceTag,
+                                        childProjectName: violatingSource.name,
+                                        imp,
+                                    },
+                                });
+                            });
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            ImportDeclaration(node) {
+                run(node);
+            },
+            ImportExpression(node) {
+                run(node);
+            },
+            ExportAllDeclaration(node) {
+                run(node);
+            },
+            ExportNamedDeclaration(node) {
+                run(node);
+            },
+        };
+    },
+});

package/src/rules/nx-plugin-checks.d.ts

@@ -0,0 +1,21 @@
+import type { AST } from 'jsonc-eslint-parser';
+import type { TSESLint } from '@typescript-eslint/utils';
+type Options = [
+    {
+        generatorsJson?: string;
+        executorsJson?: string;
+        migrationsJson?: string;
+        packageJson?: string;
+        allowedVersionStrings: string[];
+    }
+];
+export type MessageIds = 'missingRequiredSchema' | 'invalidSchemaPath' | 'missingImplementation' | 'invalidImplementationPath' | 'invalidImplementationModule' | 'unableToReadImplementationExports' | 'invalidVersion' | 'missingVersion' | 'noGeneratorsOrSchematicsFound' | 'noExecutorsOrBuildersFound' | 'valueShouldBeObject';
+export declare const RULE_NAME = "nx-plugin-checks";
+declare const _default: TSESLint.RuleModule<MessageIds, Options, TSESLint.RuleListener>;
+export default _default;
+export declare function checkCollectionFileNode(baseNode: AST.JSONObjectExpression, mode: 'migration' | 'generator' | 'executor', context: TSESLint.RuleContext<MessageIds, Options>): void;
+export declare function checkCollectionNode(baseNode: AST.JSONObjectExpression, mode: 'migration' | 'generator' | 'executor', context: TSESLint.RuleContext<MessageIds, Options>): void;
+export declare function validateEntry(baseNode: AST.JSONObjectExpression, key: string, mode: 'migration' | 'generator' | 'executor', context: TSESLint.RuleContext<MessageIds, Options>): void;
+export declare function validateImplemenationNode(implementationNode: AST.JSONProperty, key: string, context: TSESLint.RuleContext<MessageIds, Options>): void;
+export declare function validatePackageGroup(baseNode: AST.JSONObjectExpression, context: TSESLint.RuleContext<MessageIds, Options>): void;
+export declare function validateVersionJsonExpression(node: AST.JSONExpression, context: TSESLint.RuleContext<MessageIds, Options>): string | boolean;