@nx/oxlint 23.2.0-beta.10 → 23.2.0-beta.12

package/README.md

@@ -7,9 +7,9 @@
 
 <div style="text-align: center;">
 
-[![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)]()
+[![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)](<>)
 [![NPM Version](https://badge.fury.io/js/nx.svg)](https://www.npmjs.com/package/nx)
-[![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)]()
+[![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)](<>)
 [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
 [![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
 [![Nx Sandboxing](https://staging.nx.app/workspaces/62d013ea0852fe0a2df74438/sandbox-badge.svg)](https://nx.dev/docs/features/ci-features/sandboxing)

package/dist/index.d.ts

@@ -1 +1 @@
-export { createNodes, createNodesV2, type OxlintPluginOptions, } from './src/plugins/plugin.js';
+export { createDependencies, createNodes, createNodesV2, type OxlintPluginOptions, } from './src/plugins/plugin.js';

package/dist/index.js

@@ -1,3 +1,3 @@
 // The graph plugin only — this is what `nx.json` names as `@nx/oxlint`.
 // Generators live in `./generators`.
-export { createNodes, createNodesV2, } from './src/plugins/plugin.js';
+export { createDependencies, createNodes, createNodesV2, } from './src/plugins/plugin.js';

package/dist/src/plugins/plugin.d.ts

@@ -1,6 +1,14 @@
-import { CreateNodes } from '@nx/devkit';
+import { CreateDependencies, CreateNodes } from '@nx/devkit';
 export interface OxlintPluginOptions {
     targetName?: string;
 }
 export declare const createNodes: CreateNodes<OxlintPluginOptions>;
 export declare const createNodesV2: CreateNodes<OxlintPluginOptions>;
+/**
+ * A config's `jsPlugins` produce the lint results, so every project linted
+ * under that config depends on them. Resolving the specifiers here, against the
+ * finished node set, is what makes a workspace plugin a project edge and an npm
+ * plugin an external edge; `^default` then hashes both. Implicit, because the
+ * config may not be a file of the depending project.
+ */
+export declare const createDependencies: CreateDependencies<OxlintPluginOptions>;

package/dist/src/plugins/plugin.js

@@ -1,5 +1,5 @@
-import { buildPackageJsonPatterns, buildPackageJsonWorkspacesMatcher, calculateHashesForCreateNodes, combineGlobPatterns, globWithWorkspaceContext, hashObject, PluginCache, workspaceDataDirectory, } from '@nx/devkit/internal';
-import { createNodesFromFiles, detectPackageManager, getPackageManagerCommand, readJsonFile, } from '@nx/devkit';
+import { buildPackageJsonPatterns, buildPackageJsonWorkspacesMatcher, calculateHashesForCreateNodes, combineGlobPatterns, globWithWorkspaceContext, hashObject, PluginCache, TargetProjectLocator, workspaceDataDirectory, } from '@nx/devkit/internal';
+import { createNodesFromFiles, DependencyType, detectPackageManager, getPackageManagerCommand, readJsonFile, validateDependency, } from '@nx/devkit';
 import { getLockFileName, getRootTsConfigFileName } from '@nx/js';
 import { walkTsconfigExtendsChain, } from '@nx/js/internal';
 import { execFileSync } from 'node:child_process';
@@ -32,7 +32,7 @@ const OXLINT_CONFIG_GLOB = combineGlobPatterns([
     ...OXLINT_CONFIG_FILENAMES.map((f) => `**/${f}`),
     ...PROJECT_CONFIG_FILENAMES.map((f) => `**/${f}`),
 ]);
-const internalCreateNodes = async (configFilePath, options, context, projectRootsByOxlintRoots, getLintableFilesPerProjectRoot, configChainsByConfig, tsconfigChainsByProjectRoot, projectsCache, hashByRoot, pmc, rootConfig) => {
+const internalCreateNodes = async (configFilePath, options, context, projectRootsByOxlintRoots, getLintableFilesPerProjectRoot, configChainsByConfig, jsPluginSpecifiersByConfig, tsconfigChainsByProjectRoot, projectsCache, hashByRoot, pmc, rootConfig) => {
     const configDir = dirname(configFilePath);
     // Collect each project root's contribution in parallel, but write them into
     // `projects` afterwards in input order so insertion order (and therefore
@@ -53,7 +53,7 @@ const internalCreateNodes = async (configFilePath, options, context, projectRoot
             projectsCache.set(hash, {});
             return null;
         }
-        const project = getProjectUsingOxlintConfig(configFilePath, projectRoot, options, context, pmc, configChainsByConfig, tsconfigChainsByProjectRoot.get(projectRoot) ?? [], rootConfig);
+        const project = getProjectUsingOxlintConfig(configFilePath, projectRoot, options, context, pmc, configChainsByConfig, jsPluginSpecifiersByConfig, tsconfigChainsByProjectRoot.get(projectRoot) ?? [], rootConfig);
         if (project) {
             const entry = { [projectRoot]: project };
             projectsCache.set(hash, entry);
@@ -90,7 +90,7 @@ export const createNodes = [
         // Workspace-global and invariant for the whole run, so it is resolved once
         // here rather than re-stat'ed for every project.
         const rootConfig = OXLINT_CONFIG_FILENAMES.find((file) => existsSync(join(context.workspaceRoot, file)));
-        const configChainsByConfig = collectConfigChains(oxlintConfigFiles, context.workspaceRoot);
+        const { chains: configChainsByConfig, jsPluginSpecifiersByConfig } = collectConfigChains(oxlintConfigFiles, context.workspaceRoot);
         const tsconfigChainsByProjectRoot = collectTsconfigChainsByProjectRoot(projectRoots, context.workspaceRoot);
         // Stats the workspace root, so detect once for both uses below — and after
         // the bail, so a workspace with no Oxlint config never pays for it.
@@ -106,10 +106,17 @@ export const createNodes = [
             });
             // Deduped: every chain ends at the same root config, and each duplicate
             // is another whole-workspace glob for the hasher.
+            const allConfigs = [
+                ...governingConfigs,
+                ...governingConfigs.flatMap((config) => configChainsByConfig.get(config) ?? []),
+            ];
             return [
                 ...new Set([
-                    ...governingConfigs,
-                    ...governingConfigs.flatMap((config) => configChainsByConfig.get(config) ?? []),
+                    ...allConfigs,
+                    ...allConfigs.flatMap((config) => localJsPluginFiles(config, jsPluginSpecifiersByConfig.get(config) ?? [])),
+                    // Change which files Oxlint considers lintable, and therefore
+                    // whether a target is inferred at all.
+                    ...ancestorEslintignorePaths(root),
                     lockFilePattern,
                     ...(tsconfigChainsByProjectRoot.get(root) ?? []),
                 ]),
@@ -117,7 +124,7 @@ export const createNodes = [
         }));
         const hashByRoot = new Map(projectRoots.map((r, i) => [r, hashes[i]]));
         try {
-            return await createNodesFromFiles((configFile, fileOptions, fileContext) => internalCreateNodes(configFile, fileOptions, fileContext, projectRootsByOxlintRoots, getLintableFilesPerProjectRoot, configChainsByConfig, tsconfigChainsByProjectRoot, targetsCache, hashByRoot, pmc, rootConfig), oxlintConfigFiles, options, context);
+            return await createNodesFromFiles((configFile, fileOptions, fileContext) => internalCreateNodes(configFile, fileOptions, fileContext, projectRootsByOxlintRoots, getLintableFilesPerProjectRoot, configChainsByConfig, jsPluginSpecifiersByConfig, tsconfigChainsByProjectRoot, targetsCache, hashByRoot, pmc, rootConfig), oxlintConfigFiles, options, context);
         }
         finally {
             targetsCache.writeToDisk();
@@ -125,6 +132,98 @@ export const createNodes = [
     },
 ];
 export const createNodesV2 = createNodes;
+/**
+ * A config's `jsPlugins` produce the lint results, so every project linted
+ * under that config depends on them. Resolving the specifiers here, against the
+ * finished node set, is what makes a workspace plugin a project edge and an npm
+ * plugin an external edge; `^default` then hashes both. Implicit, because the
+ * config may not be a file of the depending project.
+ */
+export const createDependencies = (_options, context) => {
+    // Walked rather than flattened: this runs on every graph build, and a copy
+    // of the whole file map is the wrong price for finding a few config files.
+    const oxlintConfigFiles = [];
+    const collect = (files) => {
+        for (const { file } of files) {
+            if (OXLINT_CONFIG_FILENAMES.includes(basename(file))) {
+                oxlintConfigFiles.push(file);
+            }
+        }
+    };
+    for (const files of Object.values(context.fileMap.projectFileMap)) {
+        collect(files);
+    }
+    collect(context.fileMap.nonProjectFiles);
+    if (oxlintConfigFiles.length === 0) {
+        return [];
+    }
+    const { chains, jsPluginSpecifiersByConfig } = collectConfigChains(oxlintConfigFiles, context.workspaceRoot);
+    const configsWithPlugins = [...jsPluginSpecifiersByConfig].filter(([, specifiers]) => specifiers.length > 0);
+    if (configsWithPlugins.length === 0) {
+        return [];
+    }
+    const nodes = {};
+    for (const [name, data] of Object.entries(context.projects)) {
+        nodes[name] = { name, type: null, data };
+    }
+    // Own resolution cache: the locator's shared default one is never
+    // invalidated, so a plugin resolved before `install` would stay unresolved
+    // for the life of the plugin worker.
+    const locator = new TargetProjectLocator(nodes, context.externalNodes, new Map());
+    // Resolution is relative to the config, so it is the same for every project
+    // that config governs.
+    const targetsByConfig = new Map();
+    const resolveTargets = (config) => {
+        let targets = targetsByConfig.get(config);
+        if (!targets) {
+            targets = [];
+            for (const specifier of jsPluginSpecifiersByConfig.get(config) ?? []) {
+                const target = locator.findProjectFromImport(specifier, config);
+                if (target) {
+                    targets.push(target);
+                }
+            }
+            targetsByConfig.set(config, targets);
+        }
+        return targets;
+    };
+    const dependencies = [];
+    for (const [name, project] of Object.entries(context.projects)) {
+        if (!Object.values(project.targets ?? {}).some((target) => target.metadata?.technologies?.includes('oxlint'))) {
+            continue;
+        }
+        // Own directory and every ancestor, plus their `extends` chains — the
+        // same set `createNodes` hashes. A plugin project that depends on a
+        // project it lints closes a cycle here; that is a real circularity, and
+        // the docs say so.
+        const governingConfigs = oxlintConfigFiles.filter((config) => {
+            const configDir = dirname(config);
+            return configDir === project.root || isSubDir(configDir, project.root);
+        });
+        const configs = new Set([
+            ...governingConfigs,
+            ...governingConfigs.flatMap((config) => chains.get(config) ?? []),
+        ]);
+        const targets = new Set();
+        for (const config of configs) {
+            for (const target of resolveTargets(config)) {
+                if (target !== name) {
+                    targets.add(target);
+                }
+            }
+        }
+        for (const target of targets) {
+            const dependency = {
+                source: name,
+                target,
+                type: DependencyType.implicit,
+            };
+            validateDependency(dependency, context);
+            dependencies.push(dependency);
+        }
+    }
+    return dependencies;
+};
 function splitConfigFiles(configFiles, workspaceRoot) {
     const oxlintConfigFiles = [];
     const packageJsonFiles = [];
@@ -186,9 +285,13 @@ function splitConfigFiles(configFiles, workspaceRoot) {
  * Oxlint resolves entries relative to the referencing config and only tracks the
  * chain for its LSP, so Nx walks it here or caching goes stale. TypeScript
  * configs are not statically readable, so only the file itself is tracked.
+ *
+ * Also collects each config's raw `jsPlugins` specifiers. `createDependencies`
+ * resolves them to graph nodes; `createNodes` only needs the local files.
  */
 function collectConfigChains(oxlintConfigFiles, workspaceRoot) {
     const result = new Map();
+    const jsPluginSpecifiersByConfig = new Map();
     // Shared across configs so the common root config is read once. `null` records
     // a failed read, so a bad file is not retried per referrer.
     const jsonCache = new Map();
@@ -201,6 +304,25 @@ function collectConfigChains(oxlintConfigFiles, workspaceRoot) {
         }
         return exists;
     };
+    const recordJsPluginSpecifiers = (relativeConfigPath, jsPlugins) => {
+        if (jsPluginSpecifiersByConfig.has(relativeConfigPath)) {
+            return;
+        }
+        const specifiers = [];
+        if (Array.isArray(jsPlugins)) {
+            for (const entry of jsPlugins) {
+                const specifier = typeof entry === 'string'
+                    ? entry
+                    : typeof entry?.specifier === 'string'
+                        ? entry.specifier
+                        : undefined;
+                if (specifier) {
+                    specifiers.push(specifier);
+                }
+            }
+        }
+        jsPluginSpecifiersByConfig.set(relativeConfigPath, specifiers);
+    };
     const readConfig = (relativeConfigPath) => {
         if (jsonCache.has(relativeConfigPath)) {
             return jsonCache.get(relativeConfigPath);
@@ -216,6 +338,8 @@ function collectConfigChains(oxlintConfigFiles, workspaceRoot) {
             catch {
                 // A malformed config drops its chain from the task inputs rather than
                 // failing graph construction, matching `readCachedJson` in @nx/js.
+                // `oxlint.config.ts`/`.mts` land here too: their chains and jsPlugins
+                // are out of scope, so they get neither file inputs nor graph edges.
                 json = null;
             }
         }
@@ -234,6 +358,7 @@ function collectConfigChains(oxlintConfigFiles, workspaceRoot) {
                 return;
             }
             const json = readConfig(relativeConfigPath);
+            recordJsPluginSpecifiers(relativeConfigPath, json?.jsPlugins);
             if (!Array.isArray(json?.extends)) {
                 return;
             }
@@ -256,7 +381,25 @@ function collectConfigChains(oxlintConfigFiles, workspaceRoot) {
         walk(configFile);
         result.set(configFile, extended);
     }
-    return result;
+    return { chains: result, jsPluginSpecifiersByConfig };
+}
+/**
+ * Workspace-relative paths of a config's relative-path `jsPlugins`. Declared as
+ * file inputs because such a file may sit outside every project (`tools/x.js`
+ * at the root), where no graph edge can reach it.
+ */
+function localJsPluginFiles(relativeConfigPath, specifiers) {
+    const files = [];
+    for (const specifier of specifiers) {
+        if (!specifier.startsWith('.')) {
+            continue;
+        }
+        const resolved = normalize(join(dirname(relativeConfigPath), specifier));
+        if (resolved !== '..' && !resolved.startsWith('../')) {
+            files.push(resolved);
+        }
+    }
+    return files;
 }
 /**
  * Per project root, the `extends`-reachable tsconfig files that live OUTSIDE the
@@ -372,6 +515,24 @@ async function collectLintableFilesByProjectRoot(projectRoots, context) {
     }
     return lintableFilesPerProjectRoot;
 }
+/**
+ * `.eslintignore` candidates in every ancestor directory of the project root,
+ * workspace root included. The project's own directory is excluded — files
+ * there are covered by the `default` input — except at the workspace root,
+ * which is its own ancestor and so keeps its `.eslintignore`.
+ */
+function ancestorEslintignorePaths(projectRoot) {
+    const result = [];
+    let dir = projectRoot === '.' ? '.' : dirname(projectRoot);
+    while (true) {
+        result.push(dir === '.' ? '.eslintignore' : `${dir}/.eslintignore`);
+        if (dir === '.') {
+            break;
+        }
+        dir = dirname(dir);
+    }
+    return result;
+}
 // Only the keys are read, so the value type is left open for both callers.
 function getRootForDirectory(directory, roots) {
     let currentPath = normalize(directory);
@@ -383,7 +544,7 @@ function getRootForDirectory(directory, roots) {
     }
     return roots.has(currentPath) ? currentPath : null;
 }
-function getProjectUsingOxlintConfig(configFilePath, projectRoot, options, context, pmc, configChainsByConfig, tsconfigChainOutsideProjectRoot, rootConfig) {
+function getProjectUsingOxlintConfig(configFilePath, projectRoot, options, context, pmc, configChainsByConfig, jsPluginSpecifiersByConfig, tsconfigChainOutsideProjectRoot, rootConfig) {
     let standaloneSrcPath;
     if (projectRoot === '.' &&
         existsSync(join(context.workspaceRoot, projectRoot, 'package.json'))) {
@@ -410,6 +571,7 @@ function getProjectUsingOxlintConfig(configFilePath, projectRoot, options, conte
     ];
     const isRootProject = projectRoot === '.';
     const lintPath = isRootProject && standaloneSrcPath ? `./${standaloneSrcPath}` : '.';
+    const jsPluginFiles = new Set(configInputs.flatMap((config) => localJsPluginFiles(config, jsPluginSpecifiersByConfig.get(config) ?? [])));
     const targetConfig = {
         command: `oxlint ${lintPath}`,
         options: { cwd: projectRoot },
@@ -418,6 +580,11 @@ function getProjectUsingOxlintConfig(configFilePath, projectRoot, options, conte
             'default',
             '^default',
             ...configInputs.map((config) => `{workspaceRoot}/${config}`),
+            ...[...jsPluginFiles].map((file) => `{workspaceRoot}/${file}`),
+            // Oxlint layers .eslintignore files from every ancestor of a linted
+            // file; the project's own is covered by `default`. Declared even when
+            // absent, like the extends chain.
+            ...ancestorEslintignorePaths(projectRoot).map((file) => `{workspaceRoot}/${file}`),
             ...tsconfigChainOutsideProjectRoot.map((file) => `{workspaceRoot}/${file}`),
             { externalDependencies: ['oxlint'] },
         ],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nx/oxlint",
   "description": "Experimental. The Oxlint plugin for Nx contains generators and utilities used for linting JavaScript/TypeScript projects within an Nx workspace.",
-  "version": "23.2.0-beta.10",
+  "version": "23.2.0-beta.12",
   "type": "module",
   "files": [
     "dist",
@@ -69,9 +69,9 @@
   "generators": "./generators.json",
   "dependencies": {
     "tslib": "^2.3.0",
-    "@nx/devkit": "23.2.0-beta.10",
-    "@nx/eslint-plugin": "23.2.0-beta.10",
-    "@nx/js": "23.2.0-beta.10"
+    "@nx/devkit": "23.2.0-beta.12",
+    "@nx/eslint-plugin": "23.2.0-beta.12",
+    "@nx/js": "23.2.0-beta.12"
   },
   "peerDependencies": {
     "oxlint": "^1.43.0"
@@ -85,6 +85,6 @@
     "node": "^20.19.0 || >=22.12.0"
   },
   "devDependencies": {
-    "nx": "23.2.0-beta.10"
+    "nx": "23.2.0-beta.12"
   }
 }