@nx/eslint 19.3.0-beta.0 → 19.3.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/eslint",
-  "version": "19.3.0-beta.0",
+  "version": "19.3.0-beta.1",
   "private": false,
   "description": "The ESLint plugin for Nx contains executors, generators and utilities used for linting JavaScript/TypeScript projects within an Nx workspace.",
   "repository": {
@@ -35,12 +35,12 @@
     "eslint": "^8.0.0 || ^9.0.0"
   },
   "dependencies": {
-    "@nx/devkit": "19.3.0-beta.0",
-    "@nx/js": "19.3.0-beta.0",
+    "@nx/devkit": "19.3.0-beta.1",
+    "@nx/js": "19.3.0-beta.1",
     "semver": "^7.5.3",
     "tslib": "^2.3.0",
     "typescript": "~5.4.2",
-    "@nx/linter": "19.3.0-beta.0"
+    "@nx/linter": "19.3.0-beta.1"
   },
   "peerDependenciesMeta": {
     "@zkochan/js-yaml": {

package/src/executors/lint/lint.impl.js

@@ -77,15 +77,24 @@ async function run(options, context) {
     catch (err) {
         if (err.message.includes('You must therefore provide a value for the "parserOptions.project" property for @typescript-eslint/parser')) {
             const ruleName = err.message.match(/rule '([^']+)':/)?.[1];
-            let eslintConfigPathForError = `for ${projectName}`;
-            if (context.projectsConfigurations?.projects?.[projectName]?.root) {
-                const { root } = context.projectsConfigurations.projects[projectName];
-                eslintConfigPathForError = `\`${root}/.eslintrc.json\``;
+            const reportedFile = err.message.match(/Occurred while linting (.+)$/)?.[1];
+            let eslintConfigPathForError = `for the project "${projectName}"`;
+            if (eslintConfigPath) {
+                eslintConfigPathForError = `"${path_1.posix.relative(context.root, eslintConfigPath)}"`;
+            }
+            else {
+                const configPathForfile = hasFlatConfig
+                    ? (0, config_file_1.findFlatConfigFile)(projectRoot, context.root)
+                    : (0, config_file_1.findOldConfigFile)(reportedFile ?? projectRoot, context.root);
+                if (configPathForfile) {
+                    eslintConfigPathForError = `"${path_1.posix.relative(context.root, configPathForfile)}"`;
+                }
             }
             console.error(`
-Error: You have attempted to use ${ruleName ? `the lint rule ${ruleName}` : 'a lint rule'} which requires the full TypeScript type-checker to be available, but you do not have \`parserOptions.project\` configured to point at your project tsconfig.json files in the relevant TypeScript file "overrides" block of your project ESLint config ${eslintConfigPath || eslintConfigPathForError}
+Error: You have attempted to use ${ruleName ? `the lint rule "${ruleName}"` : 'a lint rule'} which requires the full TypeScript type-checker to be available, but you do not have "parserOptions.project" configured to point at your project tsconfig.json files in the relevant TypeScript file "overrides" block of your ESLint config ${eslintConfigPathForError}
+${reportedFile ? `Occurred while linting ${reportedFile}` : ''}
 
-Please see https://nx.dev/guides/eslint for full guidance on how to resolve this issue.
+Please see https://nx.dev/recipes/tips-n-tricks/eslint for full guidance on how to resolve this issue.
 `);
             return {
                 success: false,

package/src/plugins/plugin.js

@@ -2,24 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodes = exports.createNodesV2 = void 0;
 const devkit_1 = require("@nx/devkit");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const file_hasher_1 = require("nx/src/hasher/file-hasher");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
 const globs_1 = require("nx/src/utils/globs");
 const workspace_context_1 = require("nx/src/utils/workspace-context");
+const semver_1 = require("semver");
 const config_file_1 = require("../utils/config-file");
 const resolve_eslint_class_1 = require("../utils/resolve-eslint-class");
-const semver_1 = require("semver");
-const cache_directory_1 = require("nx/src/utils/cache-directory");
-const file_hasher_1 = require("nx/src/hasher/file-hasher");
-const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
 const DEFAULT_EXTENSIONS = ['ts', 'tsx', 'js', 'jsx', 'html', 'vue'];
-const ESLINT_CONFIG_GLOB = (0, globs_1.combineGlobPatterns)([
+const PROJECT_CONFIG_FILENAMES = ['project.json', 'package.json'];
+const ESLINT_CONFIG_GLOB_V1 = (0, globs_1.combineGlobPatterns)(config_file_1.ESLINT_CONFIG_FILENAMES.map((f) => `**/${f}`));
+const ESLINT_CONFIG_GLOB_V2 = (0, globs_1.combineGlobPatterns)([
     ...config_file_1.ESLINT_CONFIG_FILENAMES.map((f) => `**/${f}`),
-    config_file_1.baseEsLintConfigFile,
-    config_file_1.baseEsLintFlatConfigFile,
+    ...PROJECT_CONFIG_FILENAMES.map((f) => `**/${f}`),
 ]);
 function readTargetsCache(cachePath) {
-    return (0, node_fs_1.existsSync)(cachePath) ? (0, devkit_1.readJsonFile)(cachePath) : {};
+    return process.env.NX_CACHE_PROJECT_GRAPH !== 'false' && (0, node_fs_1.existsSync)(cachePath)
+        ? (0, devkit_1.readJsonFile)(cachePath)
+        : {};
 }
 function writeTargetsToCache(cachePath, results) {
     (0, devkit_1.writeJsonFile)(cachePath, results);
@@ -32,11 +35,9 @@ const internalCreateNodes = async (configFilePath, options, context, projectsCac
     context.configFiles = context.configFiles ?? [];
     // Create a Set of all the directories containing eslint configs, and a
     // list of globs to exclude from child projects
-    const eslintRoots = new Set();
     const nestedEslintRootPatterns = [];
     for (const configFile of context.configFiles) {
         const eslintRootDir = (0, node_path_1.dirname)(configFile);
-        eslintRoots.add(eslintRootDir);
         if (eslintRootDir !== configDir && isSubDir(configDir, eslintRootDir)) {
             nestedEslintRootPatterns.push(`${eslintRootDir}/**/*`);
         }
@@ -47,7 +48,6 @@ const internalCreateNodes = async (configFilePath, options, context, projectsCac
     const excludePatterns = dedupedProjectRoots.map((root) => `${root}/**/*`);
     const ESLint = await (0, resolve_eslint_class_1.resolveESLintClass)((0, config_file_1.isFlatConfig)(configFilePath));
     const eslintVersion = ESLint.version;
-    const childProjectRoots = new Set();
     const projects = {};
     await Promise.all(dedupedProjectRoots.map(async (childProjectRoot, index) => {
         // anything after is either a nested project or a sibling project, can be excluded
@@ -66,18 +66,80 @@ const internalCreateNodes = async (configFilePath, options, context, projectsCac
         const eslint = new ESLint({
             cwd: (0, node_path_1.join)(context.workspaceRoot, childProjectRoot),
         });
+        let hasNonIgnoredLintableFiles = false;
         for (const file of lintableFiles) {
             if (!(await eslint.isPathIgnored((0, node_path_1.join)(context.workspaceRoot, file)))) {
-                childProjectRoots.add(childProjectRoot);
+                hasNonIgnoredLintableFiles = true;
                 break;
             }
         }
-        const uniqueChildProjectRoots = Array.from(childProjectRoots);
-        const projectsForRoot = getProjectsUsingESLintConfig(configFilePath, uniqueChildProjectRoots, eslintVersion, options, context);
-        if (Object.keys(projectsForRoot).length > 0) {
-            Object.assign(projects, projectsForRoot);
-            // Store those projects into the cache;
-            projectsCache[hash] = projectsForRoot;
+        if (!hasNonIgnoredLintableFiles) {
+            // No lintable files in the project, store in the cache and skip further processing
+            projectsCache[hash] = {};
+            return;
+        }
+        const project = getProjectUsingESLintConfig(configFilePath, childProjectRoot, eslintVersion, options, context);
+        if (project) {
+            projects[childProjectRoot] = project;
+            // Store project into the cache
+            projectsCache[hash] = { [childProjectRoot]: project };
+        }
+        else {
+            // No project found, store in the cache
+            projectsCache[hash] = {};
+        }
+    }));
+    return {
+        projects,
+    };
+};
+let collectingLintableFilesPromise;
+const internalCreateNodesV2 = async (configFilePath, options, context, eslintConfigFiles, allProjectRoots, projectRootsByEslintRoots, lintableFilesPerProjectRoot, projectsCache) => {
+    const configDir = (0, node_path_1.dirname)(configFilePath);
+    const ESLint = await (0, resolve_eslint_class_1.resolveESLintClass)((0, config_file_1.isFlatConfig)(configFilePath));
+    const eslintVersion = ESLint.version;
+    const projects = {};
+    await Promise.all(projectRootsByEslintRoots.get(configDir).map(async (projectRoot) => {
+        const parentConfigs = eslintConfigFiles.filter((eslintConfig) => isSubDir(projectRoot, (0, node_path_1.dirname)(eslintConfig)));
+        const hash = await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, {
+            configFiles: eslintConfigFiles,
+            nxJsonConfiguration: context.nxJsonConfiguration,
+            workspaceRoot: context.workspaceRoot,
+        }, [...parentConfigs, (0, node_path_1.join)(projectRoot, '.eslintignore')]);
+        if (projectsCache[hash]) {
+            // We can reuse the projects in the cache.
+            Object.assign(projects, projectsCache[hash]);
+            return;
+        }
+        if (!lintableFilesPerProjectRoot.size) {
+            collectingLintableFilesPromise ??= collectLintableFilesByProjectRoot(lintableFilesPerProjectRoot, allProjectRoots, options, context);
+            await collectingLintableFilesPromise;
+            collectingLintableFilesPromise = null;
+        }
+        const eslint = new ESLint({
+            cwd: (0, node_path_1.join)(context.workspaceRoot, projectRoot),
+        });
+        let hasNonIgnoredLintableFiles = false;
+        for (const file of lintableFilesPerProjectRoot.get(projectRoot) ?? []) {
+            if (!(await eslint.isPathIgnored((0, node_path_1.join)(context.workspaceRoot, file)))) {
+                hasNonIgnoredLintableFiles = true;
+                break;
+            }
+        }
+        if (!hasNonIgnoredLintableFiles) {
+            // No lintable files in the project, store in the cache and skip further processing
+            projectsCache[hash] = {};
+            return;
+        }
+        const project = getProjectUsingESLintConfig(configFilePath, projectRoot, eslintVersion, options, context);
+        if (project) {
+            projects[projectRoot] = project;
+            // Store project into the cache
+            projectsCache[hash] = { [projectRoot]: project };
+        }
+        else {
+            // No project found, store in the cache
+            projectsCache[hash] = {};
         }
     }));
     return {
@@ -85,13 +147,16 @@ const internalCreateNodes = async (configFilePath, options, context, projectsCac
     };
 };
 exports.createNodesV2 = [
-    ESLINT_CONFIG_GLOB,
+    ESLINT_CONFIG_GLOB_V2,
     async (configFiles, options, context) => {
+        options = normalizeOptions(options);
         const optionsHash = (0, file_hasher_1.hashObject)(options);
         const cachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `eslint-${optionsHash}.hash`);
         const targetsCache = readTargetsCache(cachePath);
+        const { eslintConfigFiles, projectRoots, projectRootsByEslintRoots } = splitConfigFiles(configFiles);
+        const lintableFilesPerProjectRoot = new Map();
         try {
-            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => internalCreateNodes(configFile, options, context, targetsCache), configFiles, options, context);
+            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => internalCreateNodesV2(configFile, options, context, eslintConfigFiles, projectRoots, projectRootsByEslintRoots, lintableFilesPerProjectRoot, targetsCache), eslintConfigFiles, options, context);
         }
         finally {
             writeTargetsToCache(cachePath, targetsCache);
@@ -99,43 +164,95 @@ exports.createNodesV2 = [
     },
 ];
 exports.createNodes = [
-    ESLINT_CONFIG_GLOB,
+    ESLINT_CONFIG_GLOB_V1,
     (configFilePath, options, context) => {
         devkit_1.logger.warn('`createNodes` is deprecated. Update your plugin to utilize createNodesV2 instead. In Nx 20, this will change to the createNodesV2 API.');
         return internalCreateNodes(configFilePath, options, context, {});
     },
 ];
-function getProjectsUsingESLintConfig(configFilePath, childProjectRoots, eslintVersion, options, context) {
-    const projects = {};
+function splitConfigFiles(configFiles) {
+    const eslintConfigFiles = [];
+    const projectRoots = new Set();
+    for (const configFile of configFiles) {
+        if (PROJECT_CONFIG_FILENAMES.includes((0, node_path_1.basename)(configFile))) {
+            projectRoots.add((0, node_path_1.dirname)(configFile));
+        }
+        else {
+            eslintConfigFiles.push(configFile);
+        }
+    }
+    const uniqueProjectRoots = Array.from(projectRoots);
+    const projectRootsByEslintRoots = groupProjectRootsByEslintRoots(eslintConfigFiles, uniqueProjectRoots);
+    return {
+        eslintConfigFiles,
+        projectRoots: uniqueProjectRoots,
+        projectRootsByEslintRoots,
+    };
+}
+function groupProjectRootsByEslintRoots(eslintConfigFiles, projectRoots) {
+    const projectRootsByEslintRoots = new Map();
+    for (const eslintConfig of eslintConfigFiles) {
+        projectRootsByEslintRoots.set((0, node_path_1.dirname)(eslintConfig), []);
+    }
+    for (const projectRoot of projectRoots) {
+        const eslintRoot = getRootForDirectory(projectRoot, projectRootsByEslintRoots);
+        if (eslintRoot) {
+            projectRootsByEslintRoots.get(eslintRoot).push(projectRoot);
+        }
+    }
+    return projectRootsByEslintRoots;
+}
+async function collectLintableFilesByProjectRoot(lintableFilesPerProjectRoot, projectRoots, options, context) {
+    const lintableFiles = await (0, workspace_context_1.globWithWorkspaceContext)(context.workspaceRoot, [
+        `**/*.{${options.extensions.join(',')}}`,
+    ]);
+    for (const projectRoot of projectRoots) {
+        lintableFilesPerProjectRoot.set(projectRoot, []);
+    }
+    for (const file of lintableFiles) {
+        const projectRoot = getRootForDirectory((0, node_path_1.dirname)(file), lintableFilesPerProjectRoot);
+        if (projectRoot) {
+            lintableFilesPerProjectRoot.get(projectRoot).push(file);
+        }
+    }
+}
+function getRootForDirectory(directory, roots) {
+    let currentPath = (0, node_path_1.normalize)(directory);
+    while (currentPath !== (0, node_path_1.dirname)(currentPath)) {
+        if (roots.has(currentPath)) {
+            return currentPath;
+        }
+        currentPath = (0, node_path_1.dirname)(currentPath);
+    }
+    return roots.has(currentPath) ? currentPath : null;
+}
+function getProjectUsingESLintConfig(configFilePath, projectRoot, eslintVersion, options, context) {
     const rootEslintConfig = [
         config_file_1.baseEsLintConfigFile,
         config_file_1.baseEsLintFlatConfigFile,
         ...config_file_1.ESLINT_CONFIG_FILENAMES,
     ].find((f) => (0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, f)));
     // Add a lint target for each child project without an eslint config, with the root level config as an input
-    for (const projectRoot of childProjectRoots) {
-        let standaloneSrcPath;
-        if (projectRoot === '.' &&
-            (0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot, 'package.json'))) {
-            if ((0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot, 'src'))) {
-                standaloneSrcPath = 'src';
-            }
-            else if ((0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot, 'lib'))) {
-                standaloneSrcPath = 'lib';
-            }
+    let standaloneSrcPath;
+    if (projectRoot === '.' &&
+        (0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot, 'package.json'))) {
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot, 'src'))) {
+            standaloneSrcPath = 'src';
         }
-        if (projectRoot === '.' && !standaloneSrcPath) {
-            continue;
+        else if ((0, node_fs_1.existsSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot, 'lib'))) {
+            standaloneSrcPath = 'lib';
         }
-        const eslintConfigs = [configFilePath];
-        if (rootEslintConfig && !eslintConfigs.includes(rootEslintConfig)) {
-            eslintConfigs.unshift(rootEslintConfig);
-        }
-        projects[projectRoot] = {
-            targets: buildEslintTargets(eslintConfigs, eslintVersion, projectRoot, context.workspaceRoot, options, standaloneSrcPath),
-        };
     }
-    return projects;
+    if (projectRoot === '.' && !standaloneSrcPath) {
+        return null;
+    }
+    const eslintConfigs = [configFilePath];
+    if (rootEslintConfig && !eslintConfigs.includes(rootEslintConfig)) {
+        eslintConfigs.unshift(rootEslintConfig);
+    }
+    return {
+        targets: buildEslintTargets(eslintConfigs, eslintVersion, projectRoot, context.workspaceRoot, options, standaloneSrcPath),
+    };
 }
 function buildEslintTargets(eslintConfigs, eslintVersion, projectRoot, workspaceRoot, options, standaloneSrcPath) {
     const isRootProject = projectRoot === '.';
@@ -172,16 +289,17 @@ function buildEslintTargets(eslintConfigs, eslintVersion, projectRoot, workspace
     return targets;
 }
 function normalizeOptions(options) {
-    options ??= {};
-    options.targetName ??= 'lint';
+    const normalizedOptions = {
+        targetName: options.targetName ?? 'lint',
+    };
     // Normalize user input for extensions (strip leading . characters)
     if (Array.isArray(options.extensions)) {
-        options.extensions = options.extensions.map((f) => f.replace(/^\.+/, ''));
+        normalizedOptions.extensions = options.extensions.map((f) => f.replace(/^\.+/, ''));
     }
     else {
-        options.extensions = DEFAULT_EXTENSIONS;
+        normalizedOptions.extensions = DEFAULT_EXTENSIONS;
     }
-    return options;
+    return normalizedOptions;
 }
 /**
  * Determines if `child` is a subdirectory of `parent`. This is a simplified

package/src/utils/config-file.js

@@ -27,31 +27,32 @@ exports.isFlatConfig = isFlatConfig;
 // https://eslint.org/docs/latest/use/configure/configuration-files#configuration-file-resolution
 function findFlatConfigFile(directory, workspaceRoot) {
     let currentDir = (0, path_1.resolve)(workspaceRoot, directory);
-    if (currentDir === workspaceRoot) {
-        return getConfigFileInDirectory(currentDir, exports.ESLINT_FLAT_CONFIG_FILENAMES);
-    }
-    while (currentDir !== workspaceRoot) {
+    while (true) {
         const configFilePath = getConfigFileInDirectory(currentDir, exports.ESLINT_FLAT_CONFIG_FILENAMES);
         if (configFilePath) {
             return configFilePath;
         }
+        if (currentDir === workspaceRoot) {
+            break;
+        }
         currentDir = (0, path_1.dirname)(currentDir);
     }
     return null;
 }
 exports.findFlatConfigFile = findFlatConfigFile;
 function findOldConfigFile(filePathOrDirectory, workspaceRoot) {
-    let currentDir = (0, fs_1.statSync)(filePathOrDirectory).isDirectory()
-        ? filePathOrDirectory
-        : (0, path_1.dirname)(filePathOrDirectory);
-    if (currentDir === workspaceRoot) {
-        return getConfigFileInDirectory(currentDir, exports.ESLINT_OLD_CONFIG_FILENAMES);
+    let currentDir = (0, path_1.resolve)(workspaceRoot, filePathOrDirectory);
+    if (!(0, fs_1.statSync)(currentDir).isDirectory()) {
+        currentDir = (0, path_1.dirname)(currentDir);
     }
-    while (currentDir !== workspaceRoot) {
+    while (true) {
         const configFilePath = getConfigFileInDirectory(currentDir, exports.ESLINT_OLD_CONFIG_FILENAMES);
         if (configFilePath) {
             return configFilePath;
         }
+        if (currentDir === workspaceRoot) {
+            break;
+        }
         currentDir = (0, path_1.dirname)(currentDir);
     }
     return null;