@nx/vitest 23.3.0-beta.4 → 23.3.0-beta.6

package/dist/src/plugins/plugin.js

@@ -9,6 +9,7 @@ const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const executor_utils_1 = require("../utils/executor-utils");
+const setup_file_inputs_1 = require("./setup-file-inputs");
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
  */
@@ -42,6 +43,7 @@ exports.createNodes = [
             lockfile,
             ...(tsconfigChainsByProjectRoot.get(root) ?? []),
         ]));
+        const setupTsconfigJsonCache = new Map();
         try {
             return await (0, devkit_1.createNodesFromFiles)(async (configFile, _, context, idx) => {
                 const projectRoot = (0, node_path_1.dirname)(configFile);
@@ -50,7 +52,10 @@ exports.createNodes = [
                 // Adding the config file path to the hash ensures that the final hash value is different
                 // for different config files.
                 const hash = hashes[idx] + configFile;
-                if (!targetsCache.has(hash)) {
+                const cachedTargets = targetsCache.get(hash);
+                // Older cache entries predate `setupFileCandidates`.
+                if (cachedTargets === undefined ||
+                    (cachedTargets && !cachedTargets.setupFileCandidates)) {
                     const result = await buildVitestTargets(configFile, projectRoot, normalizedOptions, context, pmc, tsconfigChainsByProjectRoot.get(projectRoot) ?? []);
                     // Cache the result even when it's null (a root orchestrator config)
                     // so the config isn't re-resolved on every project-graph build.
@@ -62,10 +67,12 @@ exports.createNodes = [
                 if (!cached) {
                     return { projects: {} };
                 }
-                const { metadata, targets } = cached;
+                const { metadata, targets, setupFileCandidates } = cached;
                 const project = {
                     root: projectRoot,
-                    targets,
+                    // Resolved on every run: the cache key does not cover setup files
+                    // or their tsconfigs.
+                    targets: withSetupFileInputs(targets, normalizedOptions.testTargetName, setupFileCandidates, projectRoot, context.workspaceRoot, setupTsconfigJsonCache),
                     metadata,
                 };
                 return {
@@ -105,9 +112,25 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
         // vitest/node not available or not needed, ignore
     }
     const { resolveConfig } = await (0, executor_utils_1.loadViteDynamicImport)();
+    // Vite fills a missing `root` with `process.cwd()`, which at graph time is
+    // the workspace root - not where the task runs. Capture what the config
+    // actually authored so a relative path can be resolved the way Vitest will.
+    let authoredViteRoot;
     const viteBuildConfig = await (0, internal_1.retryOnRequireEsmRace)(() => resolveConfig({
         configFile: absoluteConfigFilePath,
         mode: 'development',
+        plugins: [
+            {
+                name: 'nx-capture-authored-vitest-root',
+                enforce: 'post',
+                config: {
+                    order: 'post',
+                    handler(config) {
+                        authoredViteRoot = config.root;
+                    },
+                },
+            },
+        ],
     }, 'build'));
     // A root config that aggregates project configs via `test.projects` is just an
     // orchestrator; the actual tests live in the individual project configs. Skip it
@@ -122,9 +145,11 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
     const { testOutputs, hasTest } = getOutputs(viteBuildConfig, projectRoot, context.workspaceRoot);
     const namedInputs = (0, internal_1.getNamedInputs)(projectRoot, context);
     const targets = {};
+    let setupFileCandidates = [];
     // if file is vitest.config or vite.config has definition for test, create targets for test and/or atomized tests
     if (configFilePath.includes('vitest.config') || hasTest) {
         const isTypecheckEnabled = !!viteBuildConfig.test?.typecheck?.enabled;
+        setupFileCandidates = (0, setup_file_inputs_1.resolveSetupFileCandidates)(viteBuildConfig, projectRoot, context.workspaceRoot, authoredViteRoot);
         targets[options.testTargetName] = await testTarget(namedInputs, testOutputs, projectRoot, options.testMode, pmc, isTypecheckEnabled, tsconfigInputs);
         if (options.ciTargetName) {
             const groupName = options.ciGroupName ?? (0, internal_1.deriveGroupNameFromTarget)(options.ciTargetName);
@@ -288,7 +313,28 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
             }
         }
     }
-    return { targets, metadata };
+    return { targets, metadata, setupFileCandidates };
+}
+function withSetupFileInputs(targets, testTargetName, setupFileCandidates, projectRoot, workspaceRoot, jsonCache) {
+    if (setupFileCandidates.length === 0)
+        return targets;
+    const { files, tsconfigs } = (0, setup_file_inputs_1.collectSetupFileInputs)(setupFileCandidates, projectRoot, workspaceRoot, jsonCache);
+    if (files.length === 0 && tsconfigs.length === 0)
+        return targets;
+    const setupInputs = [
+        ...tsconfigs.map((f) => ({
+            json: `{workspaceRoot}/${f}`,
+            fields: ['compilerOptions'],
+        })),
+        // Whole-file, not just `compilerOptions`: these are sources Vitest
+        // executes, so any change to them changes the run.
+        ...files.map((f) => `{workspaceRoot}/${f}`),
+    ];
+    const inputs = [...targets[testTargetName].inputs, ...setupInputs];
+    return Object.fromEntries(Object.entries(targets).map(([name, target]) => [
+        name,
+        { ...target, inputs },
+    ]));
 }
 async function testTarget(namedInputs, outputs, projectRoot, testMode = 'watch', pmc, isTypecheckEnabled, tsconfigInputs) {
     const command = testMode === 'run' ? 'vitest run' : 'vitest';

package/dist/src/plugins/setup-file-inputs.d.ts

@@ -0,0 +1,24 @@
+import type { RawTsconfigJsonCache } from '@nx/js/internal';
+import type { ResolvedConfig } from 'vite';
+/**
+ * Resolves the files Vitest loads from outside the project root - `setupFiles`
+ * and `globalSetup`. `collectSetupFileInputs` declares the ones that exist,
+ * together with the tsconfigs Vite reads to transform them.
+ *
+ * Reads the build-resolved config, as the inferred target's inputs are built
+ * from it. Setup files contributed by an `apply: 'serve'` plugin are therefore
+ * invisible here - the same build/serve divergence the atomized path documents.
+ *
+ * Solution-style tsconfigs are deliberately not followed. When the nearest
+ * tsconfig of a setup file is a solution file, Vite walks its `references` and
+ * reads every project's tsconfig; declaring those would attach one input per
+ * project in the workspace. Keep the setup file inside a project (or beside a
+ * leaf tsconfig) instead.
+ */
+export declare function resolveSetupFileCandidates(viteConfig: ResolvedConfig, projectRoot: string, workspaceRoot: string, 
+/** `root` as the config authored it, before vite defaults it to `cwd`. */
+authoredViteRoot?: string): string[];
+export declare function collectSetupFileInputs(setupFileCandidates: string[], projectRoot: string, workspaceRoot: string, jsonCache: RawTsconfigJsonCache): {
+    files: string[];
+    tsconfigs: string[];
+};

package/dist/src/plugins/setup-file-inputs.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSetupFileCandidates = resolveSetupFileCandidates;
+exports.collectSetupFileInputs = collectSetupFileInputs;
+const internal_1 = require("@nx/js/internal");
+const js_1 = require("@nx/js");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * Resolves the files Vitest loads from outside the project root - `setupFiles`
+ * and `globalSetup`. `collectSetupFileInputs` declares the ones that exist,
+ * together with the tsconfigs Vite reads to transform them.
+ *
+ * Reads the build-resolved config, as the inferred target's inputs are built
+ * from it. Setup files contributed by an `apply: 'serve'` plugin are therefore
+ * invisible here - the same build/serve divergence the atomized path documents.
+ *
+ * Solution-style tsconfigs are deliberately not followed. When the nearest
+ * tsconfig of a setup file is a solution file, Vite walks its `references` and
+ * reads every project's tsconfig; declaring those would attach one input per
+ * project in the workspace. Keep the setup file inside a project (or beside a
+ * leaf tsconfig) instead.
+ */
+function resolveSetupFileCandidates(viteConfig, projectRoot, workspaceRoot, 
+/** `root` as the config authored it, before vite defaults it to `cwd`. */
+authoredViteRoot) {
+    // At the workspace root everything is already covered by `default`.
+    if (projectRoot === '.')
+        return [];
+    const entries = [
+        viteConfig.test?.setupFiles,
+        viteConfig.test?.globalSetup,
+    ].flatMap((value) => typeof value === 'string' ? [value] : Array.isArray(value) ? value : []);
+    if (entries.length === 0)
+        return [];
+    // Vitest resolves both options against its root, and the inferred target
+    // runs with `cwd` set to the project root - so a config that authors no
+    // root resolves them against the project, not `viteConfig.root` (which vite
+    // has already defaulted to the graph process's cwd). Mirrors
+    // `effectiveVitestRoot` in plugin.ts.
+    const fullProjectRoot = (0, node_path_1.resolve)(workspaceRoot, projectRoot);
+    const authoredRoot = viteConfig.test?.root ?? authoredViteRoot;
+    const configRoot = !authoredRoot
+        ? fullProjectRoot
+        : (0, node_path_1.isAbsolute)(authoredRoot)
+            ? authoredRoot
+            : (0, node_path_1.resolve)(fullProjectRoot, authoredRoot);
+    const candidates = new Set();
+    for (const entry of entries) {
+        const absolutePath = (0, node_path_1.isAbsolute)(entry) ? entry : (0, node_path_1.resolve)(configRoot, entry);
+        const wsRelative = declarable(absolutePath, projectRoot, workspaceRoot);
+        if (wsRelative)
+            candidates.add(wsRelative);
+    }
+    return [...candidates];
+}
+function collectSetupFileInputs(setupFileCandidates, projectRoot, workspaceRoot, jsonCache) {
+    const rootTsConfigName = (0, js_1.getRootTsConfigFileName)();
+    const files = [];
+    const tsconfigs = new Set();
+    for (const file of setupFileCandidates) {
+        const absolutePath = (0, node_path_1.join)(workspaceRoot, file);
+        if (!(0, node_fs_1.existsSync)(absolutePath))
+            continue;
+        files.push(file);
+        // The tsconfig Vite resolves for the file: the nearest one walking up,
+        // plus its extends chain.
+        let dir = (0, node_path_1.dirname)(absolutePath);
+        while (dir.startsWith(workspaceRoot)) {
+            const candidate = (0, node_path_1.join)(dir, 'tsconfig.json');
+            if ((0, node_fs_1.existsSync)(candidate)) {
+                (0, internal_1.walkTsconfigExtendsChain)(candidate, (absPath) => {
+                    const relativePath = declarable(absPath, projectRoot, workspaceRoot);
+                    if (relativePath && relativePath !== rootTsConfigName) {
+                        tsconfigs.add(relativePath);
+                    }
+                    return 'continue';
+                }, { jsonCache });
+                break;
+            }
+            const parent = (0, node_path_1.dirname)(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    return { files, tsconfigs: [...tsconfigs] };
+}
+/** Workspace-relative path, or null when it is not ours to declare. */
+function declarable(absolutePath, projectRoot, workspaceRoot) {
+    const wsRelative = (0, node_path_1.relative)(workspaceRoot, absolutePath).split(node_path_1.sep).join('/');
+    // Outside the workspace → cannot be expressed as an input.
+    if (wsRelative.startsWith('../') || wsRelative === '..')
+        return null;
+    // Inside node_modules → invalidated via the lockfile.
+    if (wsRelative.startsWith('node_modules/') ||
+        wsRelative.includes('/node_modules/'))
+        return null;
+    // Inside the project → covered by `default`.
+    if (wsRelative === projectRoot || wsRelative.startsWith(`${projectRoot}/`))
+        return null;
+    return wsRelative;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nx/vitest",
   "description": "The Nx Plugin for Vitest to enable fast unit testing with Vitest.",
-  "version": "23.3.0-beta.4",
+  "version": "23.3.0-beta.6",
   "type": "commonjs",
   "files": [
     "dist",
@@ -78,16 +78,16 @@
   "executors": "./executors.json",
   "generators": "./generators.json",
   "dependencies": {
+    "@nx/devkit": "23.3.0-beta.6",
+    "@nx/js": "23.3.0-beta.6",
     "tslib": "^2.3.0",
     "semver": "^7.6.3",
-    "@phenomnomnominal/tsquery": "~6.2.0",
-    "@nx/devkit": "23.3.0-beta.4",
-    "@nx/js": "23.3.0-beta.4"
+    "@phenomnomnominal/tsquery": "~6.2.0"
   },
   "peerDependencies": {
+    "@nx/eslint": "23.3.0-beta.6",
     "vitest": "^3.0.0 || ^4.0.0 || ^5.0.0",
-    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0",
-    "@nx/eslint": "23.3.0-beta.4"
+    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
   },
   "peerDependenciesMeta": {
     "@nx/eslint": {
@@ -101,6 +101,6 @@
     }
   },
   "devDependencies": {
-    "nx": "23.3.0-beta.4"
+    "nx": "23.3.0-beta.6"
   }
 }

package/readme-template.md

@@ -0,0 +1,18 @@
+<p style="text-align: center;">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
+    <img alt="Nx - Smart Monorepos · Fast Builds" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+  </picture>
+</p>
+
+{{links}}
+
+<hr>
+
+# Nx: Smart Monorepos · Fast Builds
+
+Get to green PRs in half the time. Nx optimizes your builds, scales your CI, and fixes failed PRs. Built for developers and AI agents.
+
+This package is a [Vitest plugin for Nx](https://nx.dev/nx-api/vitest).
+
+{{content}}