@nx/vitest 23.1.0 → 23.2.0-beta.1

package/dist/src/executors/test/lib/utils.js

@@ -7,6 +7,7 @@ const devkit_1 = require("@nx/devkit");
 const options_utils_1 = require("../../../utils/options-utils");
 const path_1 = require("path");
 const executor_utils_1 = require("../../../utils/executor-utils");
+const devkit_internals_1 = require("nx/src/devkit-internals");
 async function getOptions(options, context, projectRoot) {
     // Allows ESM to be required in CJS modules. Vite will be published as ESM in the future.
     const { loadConfigFromFile } = await (0, executor_utils_1.loadViteDynamicImport)();
@@ -49,10 +50,18 @@ async function getOptions(options, context, projectRoot) {
     '--': _dashdash, color: _color, w: _w, 
     // Pass through any additional Vitest options
     ...passThroughOptions } = normalizedExtraArgs;
+    // Vitest keeps the UI/browser server alive only in watch mode and has no
+    // --ui -> watch link, so a run-once `nx test --ui` tears the UI down right
+    // after the run. When --ui is requested from an interactive, non-CI terminal,
+    // default watch on so the UI stays open; bare runs and CI stay run-once so
+    // `nx run-many`/`affected` don't hang. An explicit CLI --watch/--no-watch or a
+    // config `test.watch` still takes precedence.
+    const uiRequested = passThroughOptions.ui === true;
+    const watchForUi = uiRequested && !!process.stdin.isTTY && !(0, devkit_internals_1.isCI)();
     return {
-        // Explicitly set watch mode to false if not provided otherwise vitest
-        // will enable watch mode by default for non CI environments
-        watch: watch ?? false,
+        watch: watch ??
+            resolved?.config?.['test']?.watch ??
+            watchForUi,
         // Pass through any additional Vitest options
         ...passThroughOptions,
         // This should not be needed as it's going to be set in vite.config.ts

package/dist/src/generators/configuration/configuration.js

@@ -16,6 +16,7 @@ const version_utils_1 = require("../../utils/version-utils");
 const versions_1 = require("../../utils/versions");
 const assert_supported_vitest_version_1 = require("../../utils/assert-supported-vitest-version");
 const semver_1 = require("semver");
+let ts;
 /**
  * Determines whether to use vitest.config.mts instead of vite.config.mts.
  * Returns true for new non-framework projects that don't already have a vite.config.
@@ -176,15 +177,86 @@ getTestBed().initTestEnvironment(
         const installDependenciesTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, true);
         tasks.push(installDependenciesTask);
     }
-    // Setup workspace config file (https://vitest.dev/guide/workspace.html)
-    if (!isRootProject &&
-        !tree.exists(`vitest.workspace.ts`) &&
-        !tree.exists(`vitest.workspace.js`) &&
-        !tree.exists(`vitest.workspace.json`) &&
-        !tree.exists(`vitest.projects.ts`) &&
-        !tree.exists(`vitest.projects.js`) &&
-        !tree.exists(`vitest.projects.json`)) {
-        tree.write('vitest.workspace.ts', `export default ['**/vite.config.{mjs,js,ts,mts}', '**/vitest.config.{mjs,js,ts,mts}'];`);
+    // Setup the root config aggregating the project configs. Vitest 4 removed
+    // workspace files in favor of inlining the projects into a root vitest.config
+    // via `test.projects` (https://vitest.dev/guide/migration.html#workspace-is-replaced-with-projects).
+    // Emit that shape for vitest 4+ and when the installed version can't be
+    // detected (new installs resolve to v4); vitest 3 keeps the workspace file.
+    if (!isRootProject) {
+        const projectGlobs = `'**/vite.config.{mjs,js,ts,mts}', '**/vitest.config.{mjs,js,ts,mts}'`;
+        const vitestMajorVersion = (0, versions_1.getInstalledVitestMajorVersion)(tree);
+        if (vitestMajorVersion === null || vitestMajorVersion >= 4) {
+            const hasWorkspaceFile = ['ts', 'js', 'json'].some((ext) => tree.exists(`vitest.workspace.${ext}`) ||
+                tree.exists(`vitest.projects.${ext}`));
+            const rootVitestConfig = findRootConfig(tree, 'vitest.config');
+            const rootViteConfig = findRootConfig(tree, 'vite.config');
+            if (hasWorkspaceFile) {
+                // A workspace/projects file already defines the project set and the
+                // vitest 4 migration converts it; leave it untouched.
+            }
+            else if (rootVitestConfig) {
+                // A root vitest.config.* wins vitest's config resolution, so we can
+                // neither add a competing aggregator nor safely rewrite it. Warn when it
+                // doesn't aggregate, or when its shape can't be read statically, since
+                // the new project would otherwise be silently absent from
+                // workspace-level vitest runs.
+                const declaresProjects = rootConfigDeclaresProjects(tree, rootVitestConfig);
+                if (declaresProjects === 'missing') {
+                    devkit_1.logger.warn(`Found a root "${rootVitestConfig}" without a \`test.projects\` entry. ` +
+                        `The "${schema.project}" project won't be part of workspace-level ` +
+                        `vitest runs until you add its config file to \`test.projects\` there.`);
+                }
+                else if (declaresProjects === 'unknown') {
+                    devkit_1.logger.warn(`Found a root "${rootVitestConfig}" whose test setup couldn't be ` +
+                        `analyzed. If the "${schema.project}" project isn't picked up by ` +
+                        `workspace-level vitest runs, add its config file to ` +
+                        `\`test.projects\` there.`);
+                }
+            }
+            else if (rootViteConfig) {
+                // A root vite.config.* is vitest's config today. Writing a
+                // vitest.config.* would win resolution and shadow it, dropping the vite
+                // settings (aliases, plugins) from vitest runs, and projects don't
+                // inherit those from a root aggregator either. Leave it in place.
+                const declaresProjects = rootConfigDeclaresProjects(tree, rootViteConfig);
+                if (declaresProjects === 'missing') {
+                    devkit_1.logger.warn(`Found a root "${rootViteConfig}" without a \`test.projects\` entry. ` +
+                        `The "${schema.project}" project runs through that root config, so ` +
+                        `its own vitest configuration (e.g. \`environment\`, \`setupFiles\`) ` +
+                        `won't apply. Add its config file to a \`test.projects\` entry there ` +
+                        `to run it with its own configuration.`);
+                }
+                else if (declaresProjects === 'unknown') {
+                    devkit_1.logger.warn(`Found a root "${rootViteConfig}" whose test setup couldn't be ` +
+                        `analyzed. If the "${schema.project}" project isn't picked up by ` +
+                        `workspace-level vitest runs, add its config file to ` +
+                        `\`test.projects\` there.`);
+                }
+            }
+            else {
+                // No root config exists, so emit the aggregator. Its projects glob
+                // matches every vite/vitest config, including this file itself and any
+                // root vite.config added later; exclude both so neither is resolved as
+                // an extra project that, carrying no `include`, re-runs every spec via
+                // the default glob.
+                tree.write('vitest.config.ts', `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    projects: [${projectGlobs}, '!vitest.config.{mjs,js,ts,mts}', '!vite.config.{mjs,js,ts,mts}'],
+  },
+});
+`);
+            }
+        }
+        else if (!tree.exists(`vitest.workspace.ts`) &&
+            !tree.exists(`vitest.workspace.js`) &&
+            !tree.exists(`vitest.workspace.json`) &&
+            !tree.exists(`vitest.projects.ts`) &&
+            !tree.exists(`vitest.projects.js`) &&
+            !tree.exists(`vitest.projects.json`)) {
+            tree.write('vitest.workspace.ts', `export default [${projectGlobs}];`);
+        }
     }
     if (!schema.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
@@ -369,4 +441,84 @@ function findTestDefault(td, target) {
     }
     return value;
 }
+function findRootConfig(tree, name) {
+    for (const ext of ['ts', 'mts', 'cts', 'js', 'mjs', 'cjs']) {
+        const candidate = `${name}.${ext}`;
+        if (tree.exists(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+/**
+ * Classifies a root config's default export by whether it already aggregates
+ * projects via `test.projects` (or the vitest 3 `test.workspace`):
+ * - `'declares'`: it aggregates projects.
+ * - `'missing'`: it's a readable object config with no such aggregation.
+ * - `'unknown'`: the shape can't be read statically (dynamic/function configs,
+ *   spreads), where the safe move is to leave the config untouched rather than
+ *   shadow it.
+ */
+function rootConfigDeclaresProjects(tree, configPath) {
+    ts ??= (0, internal_2.ensureTypescript)();
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    let sourceFile;
+    try {
+        sourceFile = tsquery.ast(tree.read(configPath, 'utf-8'));
+    }
+    catch {
+        return 'unknown';
+    }
+    const exportAssignment = sourceFile.statements.find((s) => ts.isExportAssignment(s) && !s.isExportEquals);
+    if (!exportAssignment) {
+        return 'unknown';
+    }
+    let expression = unwrapExpression(exportAssignment.expression);
+    // Unwrap a single-argument config wrapper such as `defineConfig(...)`.
+    if (ts.isCallExpression(expression) &&
+        ts.isIdentifier(expression.expression) &&
+        expression.arguments.length === 1) {
+        expression = unwrapExpression(expression.arguments[0]);
+    }
+    if (!ts.isObjectLiteralExpression(expression)) {
+        return 'unknown';
+    }
+    // A spread could hide a `test` block we can't see.
+    if (expression.properties.some((p) => ts.isSpreadAssignment(p))) {
+        return 'unknown';
+    }
+    const testProperty = findObjectProperty(expression, 'test');
+    if (!testProperty) {
+        return 'missing';
+    }
+    if (!ts.isObjectLiteralExpression(testProperty.initializer)) {
+        return 'unknown';
+    }
+    const testObject = testProperty.initializer;
+    if (testObject.properties.some((p) => ts.isSpreadAssignment(p))) {
+        return 'unknown';
+    }
+    return findObjectProperty(testObject, 'projects') ||
+        findObjectProperty(testObject, 'workspace')
+        ? 'declares'
+        : 'missing';
+}
+function unwrapExpression(expression) {
+    while (ts.isAsExpression(expression) ||
+        ts.isSatisfiesExpression(expression) ||
+        ts.isParenthesizedExpression(expression)) {
+        expression = expression.expression;
+    }
+    return expression;
+}
+function findObjectProperty(objectLiteral, name) {
+    for (const property of objectLiteral.properties) {
+        if (ts.isPropertyAssignment(property) &&
+            (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) &&
+            property.name.text === name) {
+            return property;
+        }
+    }
+    return undefined;
+}
 exports.default = configurationGenerator;

package/dist/src/plugins/plugin.js

@@ -53,9 +53,18 @@ exports.createNodes = [
                 // for different config files.
                 const hash = hashes[idx] + configFile;
                 if (!targetsCache.has(hash)) {
-                    targetsCache.set(hash, await buildVitestTargets(configFile, projectRoot, normalizedOptions, context, pmc, tsconfigChainsByProjectRoot.get(projectRoot) ?? []));
+                    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.
+                    targetsCache.set(hash, result);
                 }
-                const { projectType, metadata, targets } = targetsCache.get(hash);
+                const cached = targetsCache.get(hash);
+                // `buildVitestTargets` returns null for a root orchestrator config
+                // that must not become a project; register no node for it.
+                if (!cached) {
+                    return { projects: {} };
+                }
+                const { projectType, metadata, targets } = cached;
                 const project = {
                     root: projectRoot,
                     targets,
@@ -115,14 +124,16 @@ async function buildVitestTargets(configFilePath, projectRoot, options, context,
         configFile: absoluteConfigFilePath,
         mode: 'development',
     }, 'build');
-    // If this is a root workspace config file with projects property, don't infer targets.
-    // The root config is just an orchestrator - the actual tests live in the individual project configs.
+    // 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
+    // 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);
     if (isWorkspaceRoot && hasProjectsProperty) {
-        return { targets: {}, metadata: {}, projectType: 'library' };
+        return null;
     }
     let metadata = {};
     const { testOutputs, hasTest } = getOutputs(viteBuildConfig, projectRoot, context.workspaceRoot);

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