@nx/vitest 23.2.0-beta.2 → 23.2.0-beta.3

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

@@ -15,6 +15,27 @@ export interface VitestPluginOptions {
      * - 'run': Tests run once and exit
      */
     testMode?: 'watch' | 'run';
+    /**
+     * How atomized test files (the `ciTargetName` targets) are discovered.
+     * - 'glob' (default): enumerate specs with a glob that mirrors Vitest's own
+     *   resolution instead of booting Vitest per project. Booting Vitest starts a
+     *   Vite dev server and runs the config's plugin hooks, so the glob is faster
+     *   during graph creation. The glob reads the Nx workspace file index, so
+     *   files ignored by `.gitignore`/`.nxignore` are never enumerated even when
+     *   Vitest itself would run them.
+     * - 'vitest': always enumerate through Vitest.
+     *
+     * Configs a glob cannot reproduce faithfully still boot Vitest automatically
+     * even under 'glob': `test.projects`/`test.workspace` (inline or an
+     * auto-loaded `vitest.workspace.*`/`vitest.projects.*` sibling file), plugins
+     * with a `configureVitest` hook, `test.changed`/`test.related`, enabled
+     * browser `instances` that set their own include/exclude/includeSource/dir,
+     * and `include`, `exclude`, `includeSource`, or `typecheck` include/exclude
+     * patterns the workspace glob reads differently (absolute paths, a trailing
+     * `/`, or an `!(...)` extglob, each optionally negated).
+     * @default 'glob'
+     */
+    discoverTestFiles?: 'glob' | 'vitest';
 }
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.

package/dist/src/plugins/plugin.js

@@ -6,10 +6,12 @@ const devkit_1 = require("@nx/devkit");
 const js_1 = require("@nx/js");
 const internal_2 = require("@nx/js/internal");
 const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
 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 plugins_1 = require("nx/src/utils/plugins");
+const workspace_context_1 = require("nx/src/utils/workspace-context");
 const executor_utils_1 = require("../utils/executor-utils");
 /**
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
@@ -129,9 +131,7 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
     // entirely so it does not register a project rooted at the workspace root (which
     // would, for example, make `nx format` treat the whole workspace as one project).
     const isWorkspaceRoot = projectRoot === '.';
-    // TODO(jack): Remove this cast when @nx/vitest switches to moduleResolution:
-    // "nodenext". Vite 8's rolldown types break vitest's test augmentation.
-    const hasProjectsProperty = Array.isArray(viteBuildConfig?.test?.projects);
+    const hasProjectsProperty = Array.isArray(viteBuildConfig.test?.projects);
     if (isWorkspaceRoot && hasProjectsProperty) {
         return null;
     }
@@ -141,8 +141,7 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
     const targets = {};
     // 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;
+        const isTypecheckEnabled = !!viteBuildConfig.test?.typecheck?.enabled;
         targets[options.testTargetName] = await testTarget(namedInputs, testOutputs, projectRoot, options.testMode, pmc, isTypecheckEnabled, tsconfigInputs);
         if (options.ciTargetName) {
             const groupName = options.ciGroupName ?? (0, plugins_1.deriveGroupNameFromTarget)(options.ciTargetName);
@@ -153,7 +152,24 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
                     [groupName]: targetGroup,
                 },
             };
-            const projectRootRelativeTestPaths = await getTestPathsRelativeToProjectRoot(projectRoot, context.workspaceRoot);
+            // Not normalizing in normalizeOptions since it also affects the options
+            // computed for convert-to-inferred.
+            const useGlobDiscovery = (options.discoverTestFiles ?? 'glob') !== 'vitest';
+            // Both discovery paths read the serve-resolved config: Vitest runs tests
+            // through a Vite server (the `serve` command), so `apply: 'serve'`
+            // plugins and command-sensitive `test` options (include/exclude and
+            // `dir`) are absent from the build resolution used above for outputs.
+            // Resolve under `mode: 'test'` to match Vitest, which defaults the Vite
+            // mode to 'test'; a config that branches on `command`/`mode` would
+            // otherwise enumerate a different spec set here than at test time.
+            const viteServeConfig = await resolveConfig({
+                configFile: absoluteConfigFilePath,
+                mode: 'test',
+            }, 'serve');
+            const projectRootRelativeTestPaths = await getTestPathsRelativeToProjectRoot(projectRoot, context.workspaceRoot, 
+            // Only the glob path reads this config; the opt-out path forces the
+            // runtime by receiving no config, and takes `test.dir` separately.
+            useGlobDiscovery ? viteServeConfig : undefined, viteServeConfig.test?.dir);
             for (const relativePath of projectRootRelativeTestPaths) {
                 if (relativePath.includes('../')) {
                     throw new Error('@nx/vitest attempted to run tests outside of the project root. This is not supported and should not happen. Please open an issue at https://github.com/nrwl/nx/issues/new/choose with the following information:\n\n' +
@@ -403,12 +419,205 @@ function checkIfConfigFileShouldBeProject(projectRoot, context) {
     }
     return true;
 }
-async function getTestPathsRelativeToProjectRoot(projectRoot, workspaceRoot) {
+async function getTestPathsRelativeToProjectRoot(projectRoot, workspaceRoot, viteConfig, 
+// Serve-resolved `test.dir` (the command Vitest runs under). Only used on the
+// opt-out path below, which receives no `viteConfig` to read it from.
+optOutTestDir) {
     const fullProjectRoot = (0, node_path_1.join)(workspaceRoot, projectRoot);
+    // `viteConfig` is resolved only when glob discovery is requested; its absence
+    // means the runtime path was selected (`discoverTestFiles: 'vitest'`).
+    if (viteConfig) {
+        const test = viteConfig.test ?? {};
+        if (!configRequiresVitestRuntime(test, viteConfig, fullProjectRoot)) {
+            return globTestPathsRelativeToProjectRoot(test, workspaceRoot, projectRoot, fullProjectRoot);
+        }
+        return getTestPathsViaVitestRuntime(fullProjectRoot, projectRoot, test.dir);
+    }
+    return getTestPathsViaVitestRuntime(fullProjectRoot, projectRoot, optOutTestDir);
+}
+/**
+ * The directory Vitest enumerates from: `test.dir` when set, else the project
+ * root. Vitest resolves a relative `test.dir` against the working directory,
+ * which for both the `test` and atomized targets is the project root.
+ */
+function resolveTestDir(fullProjectRoot, testDir) {
+    return testDir ? (0, node_path_1.resolve)(fullProjectRoot, testDir) : fullProjectRoot;
+}
+/**
+ * Enumerates a project's test files by mirroring Vitest's own resolution with
+ * a glob. Vitest globs `test.include` and `test.includeSource` (both skipped
+ * when typecheck is enabled with `only`, the latter also kept only when the
+ * file contains an in-source test) plus `test.typecheck.include` (when
+ * typecheck is enabled), each minus the relevant `exclude`, from `test.dir`
+ * when set and the project root otherwise. Defaults come from the installed
+ * Vitest so they track the user's version. Globbing goes through the Nx
+ * workspace context (the daemon-cached file index), so files ignored by
+ * `.gitignore`/`.nxignore` are never candidates. Callers must first confirm the
+ * config is reproducible with a glob via `configRequiresVitestRuntime`.
+ */
+async function globTestPathsRelativeToProjectRoot(test, workspaceRoot, projectRoot, fullProjectRoot) {
+    const { configDefaults } = await (0, executor_utils_1.loadVitestConfigDynamicImport)();
+    const exclude = test.exclude ?? configDefaults.exclude;
+    const typecheck = test.typecheck;
+    const typecheckOnly = !!(typecheck?.enabled && typecheck?.only);
+    // The workspace context matches workspace-relative paths, while the config's
+    // patterns are relative to the directory Vitest enumerates from; anchor them
+    // to it.
+    const scanRoot = test.dir
+        ? (0, devkit_1.normalizePath)((0, node_path_1.relative)(workspaceRoot, resolveTestDir(fullProjectRoot, test.dir)))
+        : projectRoot;
+    // The workspace context only reads `!` at index 0, so a negated pattern has
+    // to be re-prefixed rather than anchored as-is.
+    const anchor = (pattern) => isNegatedPattern(pattern)
+        ? `!${(0, devkit_1.joinPathFragments)(scanRoot, pattern.slice(1))}`
+        : (0, devkit_1.joinPathFragments)(scanRoot, pattern);
+    const globProjectFiles = (include, ignore) => {
+        // The workspace context treats an all-negated (or empty) include set as
+        // "match everything" (it inverts to the exclude set), while Vitest
+        // enumerates nothing. Match Vitest: without a positive entry there is
+        // nothing to enumerate.
+        if (!include.some((pattern) => !isNegatedPattern(pattern))) {
+            return Promise.resolve([]);
+        }
+        return (0, workspace_context_1.globWithWorkspaceContext)(workspaceRoot, include.map(anchor), 
+        // Vitest discards a negated `exclude` entry; forwarding it would turn the
+        // exclude set into an allowlist.
+        ignore.filter((pattern) => !isNegatedPattern(pattern)).map(anchor));
+    };
+    // Regular and type tests are independent walks; run them together.
+    const globJobs = [];
+    // Typecheck enabled with `only` makes Vitest run only type tests, so skip
+    // regular tests.
+    if (!typecheckOnly) {
+        const include = test.include ?? configDefaults.include;
+        globJobs.push(globProjectFiles(include, exclude));
+    }
+    if (typecheck?.enabled) {
+        const include = typecheck.include ?? configDefaults.typecheck.include;
+        const ignore = typecheck.exclude ?? configDefaults.typecheck.exclude;
+        globJobs.push(globProjectFiles(include, ignore));
+    }
+    const matches = new Set();
+    for (const files of await Promise.all(globJobs)) {
+        for (const file of files)
+            matches.add(file);
+    }
+    // In-source tests: only files that actually contain a test are included.
+    // Typecheck enabled with `only` makes Vitest run only type tests, so skip
+    // these too.
+    if (!typecheckOnly && test.includeSource?.length) {
+        const sourceFiles = await globProjectFiles(test.includeSource, exclude);
+        // The candidate set can be the whole `src` tree, so read in bounded
+        // batches; an unbounded Promise.all over every file risks EMFILE.
+        const readConcurrency = 25;
+        for (let i = 0; i < sourceFiles.length; i += readConcurrency) {
+            const inSourceMatches = await Promise.all(sourceFiles.slice(i, i + readConcurrency).map(async (file) => {
+                // Vitest tolerates unreadable in-source candidates and skips them;
+                // match that so a permission error or TOCTOU race can't abort graph
+                // creation.
+                try {
+                    const content = await (0, promises_1.readFile)((0, node_path_1.join)(workspaceRoot, file), 'utf-8');
+                    return content.includes('import.meta.vitest') ? file : null;
+                }
+                catch {
+                    return null;
+                }
+            }));
+            for (const file of inSourceMatches) {
+                if (file)
+                    matches.add(file);
+            }
+        }
+    }
+    // The workspace context returns workspace-relative paths, so re-relativize
+    // them to the project root. An `include` pattern (`../lib2/**`) or an
+    // out-of-project `test.dir` can land outside the project root, so drop what
+    // does, matching the runtime path.
+    return [...matches]
+        .map((file) => (0, devkit_1.normalizePath)((0, node_path_1.relative)(projectRoot, file)))
+        .filter((file) => !file.startsWith('../'))
+        .sort();
+}
+// Vitest reads a leading `!` as a negation, except when it opens an extglob
+// (`!(...)`), which the runtime gate routes away before discovery reaches here.
+function isNegatedPattern(pattern) {
+    return pattern.startsWith('!') && !pattern.startsWith('!(');
+}
+/**
+ * Whether the workspace context resolves a pattern differently than Vitest.
+ * Anchoring rewrites an absolute pattern into a project-relative one that
+ * enumerates the wrong location; a trailing `/` becomes a recursive directory
+ * match where Vitest (globbing with `expandDirectories: false`) matches
+ * nothing; and `!(...)` converts to an include plus literal exclusions that
+ * reproduces Vitest's extglob only for some shapes. A leading `!` is stripped
+ * first so a negated form of any of these still routes to the runtime.
+ */
+function patternRequiresVitestRuntime(pattern) {
+    const bare = isNegatedPattern(pattern) ? pattern.slice(1) : pattern;
+    return (0, node_path_1.isAbsolute)(bare) || bare.endsWith('/') || bare.includes('!(');
+}
+// Sibling files Vitest 3 auto-loads to define sub-projects even when the config
+// object declares none. Removed in Vitest 4 in favor of inline `test.projects`.
+const vitestWorkspaceFiles = ['vitest.workspace', 'vitest.projects'].flatMap((name) => ['ts', 'mts', 'cts', 'js', 'mjs', 'cjs', 'json'].map((ext) => `${name}.${ext}`));
+/**
+ * Whether a config's test discovery cannot be faithfully reproduced with a
+ * glob, so enumeration must go through Vitest itself.
+ */
+function configRequiresVitestRuntime(
+// `workspace` (removed in Vitest 4) and the CLI-only `changed`/`related`
+// filters are not part of the config-file `InlineConfig` type.
+test, viteConfig, projectDir) {
+    // Multi-project configs resolve include/exclude per sub-project.
+    if (Array.isArray(test?.projects) || test?.workspace)
+        return true;
+    // Vitest 3 auto-loads a `vitest.workspace.*`/`vitest.projects.*` sibling file
+    // to define sub-projects even when the config object declares none; the glob
+    // resolves only the single config, so it cannot reproduce that.
+    if (vitestWorkspaceFiles.some((file) => (0, node_fs_1.existsSync)((0, node_path_1.join)(projectDir, file)))) {
+        return true;
+    }
+    // Vitest filters specs by VCS/graph state, which a glob cannot know.
+    if (test?.changed || test?.related)
+        return true;
+    // Vitest's own defaults carry none of these shapes, so only a config that
+    // spells one out reaches the runtime for this reason.
+    const configuredPatterns = [
+        test?.include,
+        test?.exclude,
+        test?.includeSource,
+        test?.typecheck?.include,
+        test?.typecheck?.exclude,
+    ]
+        .filter(Array.isArray)
+        .flat();
+    if (configuredPatterns.some(patternRequiresVitestRuntime))
+        return true;
+    // Browser mode: an instance can override include/exclude/includeSource, and
+    // `dir` (the base directory Vitest scans), so a top-level glob enumerates a
+    // different spec set than the instance would. Vitest ignores `instances`
+    // while browser mode is off, and the atomized target runs `vitest run <file>`
+    // without a browser flag, so the resolved `enabled` matches the run.
+    const browserInstances = test?.browser?.instances ?? [];
+    if (test?.browser?.enabled &&
+        browserInstances.some((instance) => instance &&
+            (instance.include?.length ||
+                instance.exclude?.length ||
+                instance.includeSource?.length ||
+                instance.dir))) {
+        return true;
+    }
+    // A plugin can inject or reshape projects through this Vitest-only hook.
+    const plugins = viteConfig?.plugins ?? [];
+    return plugins.some((plugin) => plugin && typeof plugin === 'object' && 'configureVitest' in plugin);
+}
+async function getTestPathsViaVitestRuntime(fullProjectRoot, projectRoot, testDir) {
     const { createVitest } = await import('vitest/node');
     const vitest = await createVitest('test', {
         root: fullProjectRoot,
-        dir: fullProjectRoot,
+        // `dir` defaults to `root`, and a relative `test.dir` would resolve against
+        // the working directory, which during graph creation is the workspace root
+        // rather than the project root.
+        dir: resolveTestDir(fullProjectRoot, testDir),
         filesOnly: true,
         watch: false,
     });

package/dist/src/utils/executor-utils.d.ts

@@ -1,2 +1,3 @@
-export declare function loadViteDynamicImport(): Promise<any>;
+export declare function loadViteDynamicImport(): Promise<typeof import('vite')>;
 export declare function loadVitestDynamicImport(): Promise<typeof import('vitest/node')>;
+export declare function loadVitestConfigDynamicImport(): Promise<typeof import('vitest/config')>;

package/dist/src/utils/executor-utils.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadViteDynamicImport = loadViteDynamicImport;
 exports.loadVitestDynamicImport = loadVitestDynamicImport;
-// TODO(jack): Remove this cast when @nx/vitest switches to moduleResolution:
-// "nodenext". Vite 8 ships ESM-only type declarations (.d.mts) not resolvable
-// under moduleResolution: "node".
+exports.loadVitestConfigDynamicImport = loadVitestConfigDynamicImport;
 function loadViteDynamicImport() {
     return Function('return import("vite")')();
 }
 function loadVitestDynamicImport() {
     return Function('return import("vitest/node")')();
 }
+function loadVitestConfigDynamicImport() {
+    return Function('return import("vitest/config")')();
+}

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.2.0-beta.2",
+  "version": "23.2.0-beta.3",
   "type": "commonjs",
   "files": [
     "dist",
@@ -73,13 +73,13 @@
     "tslib": "^2.3.0",
     "semver": "^7.6.3",
     "@phenomnomnominal/tsquery": "~6.2.0",
-    "@nx/devkit": "23.2.0-beta.2",
-    "@nx/js": "23.2.0-beta.2"
+    "@nx/devkit": "23.2.0-beta.3",
+    "@nx/js": "23.2.0-beta.3"
   },
   "peerDependencies": {
     "vitest": "^3.0.0 || ^4.0.0",
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0",
-    "@nx/eslint": "23.2.0-beta.2"
+    "@nx/eslint": "23.2.0-beta.3"
   },
   "peerDependenciesMeta": {
     "@nx/eslint": {
@@ -93,6 +93,6 @@
     }
   },
   "devDependencies": {
-    "nx": "23.2.0-beta.2"
+    "nx": "23.2.0-beta.3"
   }
 }