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

package/src/utils/graph-utils.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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,
+    matrix: null,
+    adjList: null,
+};
+function buildMatrix(graph) {
+    const nodes = Object.keys(graph.nodes);
+    const nodesLength = nodes.length;
+    const adjList = {};
+    const matrix = {};
+    // create matrix value set
+    for (let i = 0; i < nodesLength; i++) {
+        const v = nodes[i];
+        adjList[v] = [];
+        // meeroslav: turns out this is 10x faster than spreading the pre-generated initMatrixValues
+        matrix[v] = {};
+    }
+    const projectsWithDependencies = Object.keys(graph.dependencies);
+    for (let i = 0; i < projectsWithDependencies.length; i++) {
+        const dependencies = graph.dependencies[projectsWithDependencies[i]];
+        for (let j = 0; j < dependencies.length; j++) {
+            const dependency = dependencies[j];
+            if (graph.nodes[dependency.target]) {
+                adjList[dependency.source].push(dependency.target);
+            }
+        }
+    }
+    const traverse = (s, v) => {
+        matrix[s][v] = true;
+        const adjListLength = adjList[v].length;
+        for (let i = 0; i < adjListLength; i++) {
+            const adj = adjList[v][i];
+            if (!matrix[s][adj]) {
+                traverse(s, adj);
+            }
+        }
+    };
+    for (let i = 0; i < nodesLength; i++) {
+        const v = nodes[i];
+        traverse(v, v);
+    }
+    return {
+        matrix,
+        adjList,
+    };
+}
+function getPath(graph, sourceProjectName, targetProjectName) {
+    if (sourceProjectName === targetProjectName)
+        return [];
+    if (reach.graph !== graph) {
+        const { matrix, adjList } = buildMatrix(graph);
+        reach.graph = graph;
+        reach.matrix = matrix;
+        reach.adjList = adjList;
+    }
+    const adjList = reach.adjList;
+    let path = [];
+    const queue = [[sourceProjectName, path]];
+    const visited = [sourceProjectName];
+    while (queue.length > 0) {
+        const [current, p] = queue.pop();
+        path = [...p, current];
+        if (current === targetProjectName)
+            break;
+        if (!adjList[current])
+            break;
+        adjList[current]
+            .filter((adj) => visited.indexOf(adj) === -1)
+            .filter((adj) => reach.matrix[adj][targetProjectName])
+            .forEach((adj) => {
+            visited.push(adj);
+            queue.push([adj, [...path]]);
+        });
+    }
+    if (path.length > 1) {
+        return path.map((n) => graph.nodes[n]);
+    }
+    else {
+        return [];
+    }
+}
+exports.getPath = getPath;
+function pathExists(graph, sourceProjectName, targetProjectName) {
+    if (sourceProjectName === targetProjectName)
+        return true;
+    if (reach.graph !== graph) {
+        const { matrix, adjList } = buildMatrix(graph);
+        reach.graph = graph;
+        reach.matrix = matrix;
+        reach.adjList = adjList;
+    }
+    return !!reach.matrix[sourceProjectName][targetProjectName];
+}
+exports.pathExists = pathExists;
+function checkCircularPath(graph, sourceProject, targetProject) {
+    if (!graph.nodes[targetProject.name])
+        return [];
+    return getPath(graph, targetProject.name, sourceProject.name);
+}
+exports.checkCircularPath = checkCircularPath;
+function findFilesInCircularPath(projectFileMap, circularPath) {
+    const filePathChain = [];
+    for (let i = 0; i < circularPath.length - 1; i++) {
+        const next = circularPath[i + 1].name;
+        const files = projectFileMap[circularPath[i].name] || [];
+        filePathChain.push(files
+            .filter((file) => file.deps && file.deps.find((d) => (0, project_graph_1.fileDataDepTarget)(d) === next))
+            .map((file) => file.file));
+    }
+    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,4 @@
+import { PackageJson } from 'nx/src/utils/package-json';
+export declare function getAllDependencies(packageJson: PackageJson): Record<string, string>;
+export declare function getProductionDependencies(packageJsonPath: string): Record<string, string>;
+export declare function getPackageJson(path: string): PackageJson;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageJson = exports.getProductionDependencies = exports.getAllDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+const runtime_lint_utils_1 = require("./runtime-lint-utils");
+function getAllDependencies(packageJson) {
+    return {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+        ...packageJson.peerDependencies,
+        ...packageJson.optionalDependencies,
+    };
+}
+exports.getAllDependencies = getAllDependencies;
+function getProductionDependencies(packageJsonPath) {
+    if (!globalThis.projPackageJsonDeps ||
+        !globalThis.projPackageJsonDeps[packageJsonPath] ||
+        !(0, runtime_lint_utils_1.isTerminalRun)()) {
+        const packageJson = getPackageJson(packageJsonPath);
+        globalThis.projPackageJsonDeps = globalThis.projPackageJsonDeps || {};
+        globalThis.projPackageJsonDeps[packageJsonPath] = {
+            ...packageJson.dependencies,
+            ...packageJson.peerDependencies,
+            ...packageJson.optionalDependencies,
+        };
+    }
+    return globalThis.projPackageJsonDeps[packageJsonPath];
+}
+exports.getProductionDependencies = getProductionDependencies;
+function getPackageJson(path) {
+    if ((0, fs_1.existsSync)(path)) {
+        return (0, devkit_1.readJsonFile)(path);
+    }
+    return {};
+}
+exports.getPackageJson = getPackageJson;

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

@@ -0,0 +1,10 @@
+import { ProjectFileMap, ProjectGraph } from '@nx/devkit';
+import { ProjectRootMappings } from 'nx/src/project-graph/utils/find-project-for-path';
+import { TargetProjectLocator } from '@nx/js/src/internal';
+export declare function ensureGlobalProjectGraph(ruleName: string): void;
+export declare function readProjectGraph(ruleName: string): {
+    projectGraph: ProjectGraph;
+    projectFileMap: ProjectFileMap;
+    projectRootMappings: ProjectRootMappings;
+    targetProjectLocator: TargetProjectLocator;
+};

package/src/utils/project-graph-utils.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readProjectGraph = exports.ensureGlobalProjectGraph = void 0;
+const devkit_1 = require("@nx/devkit");
+const runtime_lint_utils_1 = require("./runtime-lint-utils");
+const chalk = require("chalk");
+const find_project_for_path_1 = require("nx/src/project-graph/utils/find-project-for-path");
+const configuration_1 = require("nx/src/config/configuration");
+const internal_1 = require("@nx/js/src/internal");
+const nx_deps_cache_1 = require("nx/src/project-graph/nx-deps-cache");
+function ensureGlobalProjectGraph(ruleName) {
+    /**
+     * Only reuse graph when running from terminal
+     * Enforce every IDE change to get a fresh nxdeps.json
+     */
+    if (!globalThis.projectGraph ||
+        !globalThis.projectRootMappings ||
+        !globalThis.projectFileMap ||
+        !(0, runtime_lint_utils_1.isTerminalRun)()) {
+        const nxJson = (0, configuration_1.readNxJson)();
+        globalThis.workspaceLayout = nxJson.workspaceLayout;
+        /**
+         * Because there are a number of ways in which the rule can be invoked (executor vs ESLint CLI vs IDE Plugin),
+         * the ProjectGraph may or may not exist by the time the lint rule is invoked for the first time.
+         */
+        try {
+            const projectGraph = (0, devkit_1.readCachedProjectGraph)();
+            globalThis.projectGraph = projectGraph;
+            globalThis.projectRootMappings = (0, find_project_for_path_1.createProjectRootMappings)(projectGraph.nodes);
+            globalThis.projectFileMap = (0, nx_deps_cache_1.readFileMapCache)().fileMap.projectFileMap;
+            globalThis.targetProjectLocator = new internal_1.TargetProjectLocator(projectGraph.nodes, projectGraph.externalNodes);
+        }
+        catch {
+            const WARNING_PREFIX = `${chalk.reset.keyword('orange')('warning')}`;
+            const RULE_NAME_SUFFIX = `${chalk.reset.dim(`@nx/${ruleName}`)}`;
+            process.stdout
+                .write(`${WARNING_PREFIX} No cached ProjectGraph is available. The rule will be skipped.
+          If you encounter this error as part of running standard \`nx\` commands then please open an issue on https://github.com/nrwl/nx
+          ${RULE_NAME_SUFFIX}\n`);
+        }
+    }
+}
+exports.ensureGlobalProjectGraph = ensureGlobalProjectGraph;
+function readProjectGraph(ruleName) {
+    ensureGlobalProjectGraph(ruleName);
+    return {
+        projectGraph: globalThis.projectGraph,
+        projectFileMap: globalThis.projectFileMap,
+        projectRootMappings: globalThis.projectRootMappings,
+        targetProjectLocator: globalThis.targetProjectLocator,
+    };
+}
+exports.readProjectGraph = readProjectGraph;

package/src/utils/runtime-lint-utils.d.ts

@@ -0,0 +1,88 @@
+import { ProjectGraph, ProjectGraphDependency, ProjectGraphExternalNode, ProjectGraphProjectNode } from '@nx/devkit';
+import { ProjectRootMappings } from 'nx/src/project-graph/utils/find-project-for-path';
+import { TargetProjectLocator } from '@nx/js/src/internal';
+import { TSESTree } from '@typescript-eslint/utils';
+export type Deps = {
+    [projectName: string]: ProjectGraphDependency[];
+};
+type SingleSourceTagConstraint = {
+    sourceTag: string;
+    onlyDependOnLibsWithTags?: string[];
+    notDependOnLibsWithTags?: string[];
+    allowedExternalImports?: string[];
+    bannedExternalImports?: string[];
+};
+type ComboSourceTagConstraint = {
+    allSourceTags: string[];
+    onlyDependOnLibsWithTags?: string[];
+    notDependOnLibsWithTags?: string[];
+    allowedExternalImports?: string[];
+    bannedExternalImports?: string[];
+};
+export type DepConstraint = SingleSourceTagConstraint | ComboSourceTagConstraint;
+export declare function stringifyTags(tags: string[]): string;
+export declare function hasNoneOfTheseTags(proj: ProjectGraphProjectNode, tags: string[]): boolean;
+export declare function isComboDepConstraint(depConstraint: DepConstraint): depConstraint is ComboSourceTagConstraint;
+/**
+ * Check if any of the given tags is included in the project
+ * @param proj ProjectGraphProjectNode
+ * @param tags
+ * @returns
+ */
+export declare function findDependenciesWithTags(targetProject: ProjectGraphProjectNode, tags: string[], graph: ProjectGraph): ProjectGraphProjectNode[][];
+export declare function matchImportWithWildcard(allowableImport: string, extractedImport: string): boolean;
+export declare function isRelative(s: string): boolean;
+export declare function getTargetProjectBasedOnRelativeImport(imp: string, projectPath: string, projectGraph: ProjectGraph, projectRootMappings: ProjectRootMappings, sourceFilePath: string): ProjectGraphProjectNode | undefined;
+export declare function findProject(projectGraph: ProjectGraph, projectRootMappings: ProjectRootMappings, sourceFilePath: string): ProjectGraphProjectNode;
+export declare function isAbsoluteImportIntoAnotherProject(imp: string, workspaceLayout?: {
+    libsDir: string;
+    appsDir: string;
+}): boolean;
+export declare function findProjectUsingImport(projectGraph: ProjectGraph, targetProjectLocator: TargetProjectLocator, filePath: string, imp: string): ProjectGraphProjectNode | ProjectGraphExternalNode;
+export declare function findConstraintsFor(depConstraints: DepConstraint[], sourceProject: ProjectGraphProjectNode): DepConstraint[];
+export declare function hasStaticImportOfDynamicResource(node: TSESTree.ImportDeclaration | TSESTree.ImportExpression | TSESTree.ExportAllDeclaration | TSESTree.ExportNamedDeclaration, graph: ProjectGraph, sourceProjectName: string, targetProjectName: string): boolean;
+export declare function getSourceFilePath(sourceFileName: string, projectPath: string): string;
+export declare function hasBannedImport(source: ProjectGraphProjectNode, target: ProjectGraphExternalNode, depConstraints: DepConstraint[], imp: string): DepConstraint | undefined;
+/**
+ * Find all unique (transitive) external dependencies of given project
+ * @param graph
+ * @param source
+ * @returns
+ */
+export declare function findTransitiveExternalDependencies(graph: ProjectGraph, source: ProjectGraphProjectNode): ProjectGraphDependency[];
+/**
+ * Check if
+ * @param externalDependencies
+ * @param graph
+ * @param depConstraint
+ * @returns
+ */
+export declare function hasBannedDependencies(externalDependencies: ProjectGraphDependency[], graph: ProjectGraph, depConstraint: DepConstraint, imp: string): Array<[ProjectGraphExternalNode, ProjectGraphProjectNode, DepConstraint]> | undefined;
+export declare function isDirectDependency(source: ProjectGraphProjectNode, target: ProjectGraphExternalNode): boolean;
+/**
+ * Verifies whether the given node has a builder target
+ * @param projectGraph the node to verify
+ * @param buildTargets the list of targets to check for
+ */
+export declare function hasBuildExecutor(projectGraph: ProjectGraphProjectNode, buildTargets?: string[]): boolean;
+export declare function isTerminalRun(): boolean;
+/**
+ * Takes an array of imports and tries to group them, so rather than having
+ * `import { A } from './some-location'` and `import { B } from './some-location'` you get
+ * `import { A, B } from './some-location'`
+ * @param importsToRemap
+ * @returns
+ */
+export declare function groupImports(importsToRemap: {
+    member: string;
+    importPath: string;
+}[]): string;
+/**
+ * Checks if source file belongs to a secondary entry point different than the import one
+ */
+export declare function belongsToDifferentNgEntryPoint(importExpr: string, filePath: string, projectRoot: string): boolean;
+/**
+ * Returns true if the given project contains MFE config with "exposes:" section
+ */
+export declare function appIsMFERemote(project: ProjectGraphProjectNode): boolean;
+export {};