@nx/plugin 23.2.0-canary.20260717-dc22f7e → 23.2.0-canary.20260722-6a072a2

package/dist/src/generators/e2e-project/e2e.d.ts

@@ -1,4 +1,4 @@
-import { type GeneratorCallback, type Tree } from '@nx/devkit';
+import { Tree, type GeneratorCallback } from '@nx/devkit';
 import type { Schema } from './schema';
 export declare function e2eProjectGenerator(host: Tree, schema: Schema): Promise<GeneratorCallback>;
 export declare function e2eProjectGeneratorInternal(host: Tree, schema: Schema): Promise<GeneratorCallback>;

package/dist/src/generators/e2e-project/e2e.js

@@ -9,6 +9,7 @@ const jest_1 = require("@nx/jest");
 const js_1 = require("@nx/js");
 const internal_2 = require("@nx/js/internal");
 const path_1 = require("path");
+const versions_1 = require("../../utils/versions");
 async function normalizeOptions(host, options) {
     const linter = await (0, internal_2.normalizeLinterOption)(host, options.linter);
     const projectName = options.rootProject ? 'e2e' : `${options.pluginName}-e2e`;
@@ -112,6 +113,112 @@ async function addJest(host, options) {
     }
     return jestTask;
 }
+async function addVitest(host, options) {
+    const projectConfiguration = {
+        name: options.projectName,
+        root: options.projectRoot,
+        projectType: 'application',
+        sourceRoot: `${options.projectRoot}/src`,
+        implicitDependencies: [options.pluginName],
+    };
+    if (options.isTsSolutionSetup) {
+        (0, devkit_1.writeJson)(host, (0, devkit_1.joinPathFragments)(options.projectRoot, 'package.json'), {
+            name: options.projectName,
+            version: '0.0.1',
+            private: true,
+        });
+        (0, devkit_1.updateProjectConfiguration)(host, options.projectName, projectConfiguration);
+    }
+    else {
+        projectConfiguration.targets = {};
+        (0, devkit_1.addProjectConfiguration)(host, options.projectName, projectConfiguration);
+    }
+    (0, devkit_1.ensurePackage)('@nx/vitest', versions_1.nxVersion);
+    // Use `require` rather than a dynamic `import()`: `ensurePackage` makes the
+    // on-demand-installed package resolvable via CJS resolution only, so a true
+    // ESM dynamic import cannot see the temp install.
+    const { configurationGenerator: vitestConfigurationGenerator, } = require('@nx/vitest/generators');
+    const vitestTask = await vitestConfigurationGenerator(host, {
+        project: options.projectName,
+        testTarget: 'e2e',
+        skipFormat: true,
+        addPlugin: options.addPlugin,
+        testEnvironment: 'node',
+        coverageProvider: 'none',
+    });
+    (0, internal_2.addLocalRegistryScripts)(host);
+    // Vitest has no `globalTeardown` option. Its `globalSetup` file must export
+    // both `setup` and `teardown`, so wire the local registry scripts through a
+    // wrapper module. Without the teardown, the verdaccio process started in
+    // setup outlives the test run.
+    const vitestGlobalSetupPath = 'tools/scripts/vitest-global-setup.ts';
+    if (!host.exists(vitestGlobalSetupPath)) {
+        host.write(vitestGlobalSetupPath, `/**
+ * This script adapts the local registry scripts to vitest's globalSetup
+ * lifecycle: vitest calls the exported setup and teardown functions around
+ * the test run.
+ */
+
+export { default as setup } from './start-local-registry';
+export { default as teardown } from './stop-local-registry';
+`);
+    }
+    // Add globalSetup to vitest config
+    // Check for both .mts and .ts extensions (mts is checked first as it's the default created by @nx/vitest)
+    const vitestConfigExtensions = ['mts', 'ts'];
+    let vitestConfigPath;
+    for (const ext of vitestConfigExtensions) {
+        const configPath = (0, devkit_1.joinPathFragments)(options.projectRoot, `vitest.config.${ext}`);
+        if (host.exists(configPath)) {
+            vitestConfigPath = configPath;
+            break;
+        }
+    }
+    if (vitestConfigPath) {
+        let vitestConfig = host.read(vitestConfigPath, 'utf-8');
+        const globalSetupPath = (0, path_1.join)((0, devkit_1.offsetFromRoot)(options.projectRoot), vitestGlobalSetupPath);
+        // Insert globalSetup in the test config
+        // Look for 'test: {' and insert our properties right after the opening brace
+        const testConfigRegex = /(test:\s*\{\s*)/;
+        const match = testConfigRegex.exec(vitestConfig);
+        if (match) {
+            // Extract the indentation from the next line to maintain consistent formatting
+            const afterMatch = vitestConfig.slice(match.index + match[0].length);
+            const nextLineMatch = afterMatch.match(/\n(\s*)/);
+            const indent = nextLineMatch ? nextLineMatch[1] : '    ';
+            vitestConfig = vitestConfig.replace(testConfigRegex, `$1\n${indent}globalSetup: '${globalSetupPath}',`);
+            host.write(vitestConfigPath, vitestConfig);
+        }
+        else {
+            // If we can't find the test config block, log a warning
+            throw new Error(`Could not find test configuration block in ${vitestConfigPath}. Please manually add the globalSetup property.`);
+        }
+    }
+    else {
+        // This should not happen as the vitest configuration generator should create the config file
+        throw new Error(`Could not find Vitest config for project ${options.projectName} at ${options.projectRoot}`);
+    }
+    const project = (0, devkit_1.readProjectConfiguration)(host, options.projectName);
+    project.targets ??= {};
+    if (project.targets.e2e) {
+        const e2eTarget = project.targets.e2e;
+        project.targets.e2e = {
+            ...e2eTarget,
+            dependsOn: [`^build`],
+            options: {
+                ...e2eTarget.options,
+                pool: 'forks',
+                poolOptions: {
+                    forks: {
+                        singleFork: true,
+                    },
+                },
+            },
+        };
+        (0, devkit_1.updateProjectConfiguration)(host, options.projectName, project);
+    }
+    return vitestTask;
+}
 async function addLintingToApplication(tree, options) {
     const lintTask = await (0, eslint_1.lintProjectGenerator)(tree, {
         linter: options.linter,
@@ -119,7 +226,7 @@ async function addLintingToApplication(tree, options) {
         tsConfigPaths: [
             (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.app.json'),
         ],
-        unitTestRunner: 'jest',
+        unitTestRunner: options.testRunner ?? 'jest',
         skipFormat: true,
         setParserOptionsProject: false,
         addPlugin: options.addPlugin,
@@ -145,11 +252,19 @@ async function e2eProjectGeneratorInternal(host, schema) {
     const tasks = [];
     validatePlugin(host, schema.pluginName);
     const options = await normalizeOptions(host, schema);
+    // Default to jest if no testRunner is specified
+    options.testRunner = options.testRunner ?? 'jest';
     addFiles(host, options);
     tasks.push(await (0, js_1.setupVerdaccio)(host, {
         skipFormat: true,
     }));
-    tasks.push(await addJest(host, options));
+    // Add test runner based on the testRunner option
+    if (options.testRunner === 'vitest') {
+        tasks.push(await addVitest(host, options));
+    }
+    else {
+        tasks.push(await addJest(host, options));
+    }
     updatePluginPackageJson(host, options);
     if (options.linter !== 'none') {
         tasks.push(await addLintingToApplication(host, {

package/dist/src/generators/e2e-project/files/src/__simplePluginName__.spec.ts__tmpl__

@@ -8,14 +8,14 @@ describe('<%= pluginName %>', () => {
   beforeAll(() => {
     projectDirectory = createTestProject();
 
-    // The plugin has been built and published to a local registry in the jest globalSetup
+    // The plugin has been built and published to a local registry in the globalSetup
     // Install the plugin built with the latest source code into the test repo
     execSync(`<%= packageManagerCommands.addDev %> <%= pluginPackageName %>@e2e`, {
       cwd: projectDirectory,
       stdio: 'inherit',
       env: process.env,
     });
-  });
+  }, 30_000);
 
   afterAll(() => {
     if (projectDirectory) {

package/dist/src/generators/e2e-project/schema.d.ts

@@ -6,6 +6,7 @@ export interface Schema {
   projectDirectory?: string;
   pluginOutputPath?: string;
   jestConfig?: string;
+  testRunner?: 'jest' | 'vitest';
   linter?: Linter | LinterType;
   skipFormat?: boolean;
   rootProject?: boolean;

package/dist/src/generators/e2e-project/schema.json

@@ -30,6 +30,12 @@
       "type": "string",
       "description": "Jest config file."
     },
+    "testRunner": {
+      "type": "string",
+      "enum": ["jest", "vitest"],
+      "description": "Test runner to use for the e2e tests.",
+      "default": "jest"
+    },
     "linter": {
       "description": "The tool to use for running lint checks.",
       "type": "string",

package/dist/src/generators/plugin/plugin.js

@@ -83,6 +83,11 @@ async function pluginGeneratorInternal(host, schema) {
         '@nx/devkit': nxVersion,
     }, {
         [options.unitTestRunner === 'vitest' ? '@nx/vitest' : '@nx/jest']: nxVersion,
+        ...(options.e2eTestRunner === 'vitest'
+            ? { '@nx/vitest': nxVersion }
+            : options.e2eTestRunner === 'jest'
+                ? { '@nx/jest': nxVersion }
+                : {}),
         '@nx/js': nxVersion,
         '@nx/plugin': nxVersion,
     }));
@@ -103,6 +108,7 @@ async function pluginGeneratorInternal(host, schema) {
             linter: options.linter,
             useProjectJson: options.useProjectJson,
             addPlugin: options.addPlugin,
+            testRunner: options.e2eTestRunner,
         }));
     }
     if (options.linter === 'eslint' && !options.skipLintChecks) {

package/dist/src/generators/plugin/schema.d.ts

@@ -7,7 +7,7 @@ export interface Schema {
   skipTsConfig?: boolean; // default is false
   skipFormat?: boolean; // default is false
   skipLintChecks?: boolean; // default is false
-  e2eTestRunner?: 'jest' | 'none';
+  e2eTestRunner?: 'jest' | 'vitest' | 'none';
   e2eProjectDirectory?: string;
   tags?: string;
   unitTestRunner?: 'jest' | 'vitest' | 'none';

package/dist/src/generators/plugin/schema.json

@@ -67,7 +67,7 @@
     },
     "e2eTestRunner": {
       "type": "string",
-      "enum": ["jest", "none"],
+      "enum": ["jest", "vitest", "none"],
       "description": "Test runner to use for end to end (E2E) tests.",
       "default": "none"
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/plugin",
-  "version": "23.2.0-canary.20260717-dc22f7e",
+  "version": "23.2.0-canary.20260722-6a072a2",
   "private": false,
   "description": "This plugin is used to create Nx plugins! It contains generators for generating common plugin features like generators, executors, migrations and more.",
   "repository": {
@@ -36,13 +36,21 @@
   },
   "dependencies": {
     "tslib": "^2.3.0",
-    "@nx/devkit": "23.2.0-canary.20260717-dc22f7e",
-    "@nx/jest": "23.2.0-canary.20260717-dc22f7e",
-    "@nx/js": "23.2.0-canary.20260717-dc22f7e",
-    "@nx/eslint": "23.2.0-canary.20260717-dc22f7e"
+    "@nx/devkit": "23.2.0-canary.20260722-6a072a2",
+    "@nx/jest": "23.2.0-canary.20260722-6a072a2",
+    "@nx/js": "23.2.0-canary.20260722-6a072a2",
+    "@nx/eslint": "23.2.0-canary.20260722-6a072a2"
   },
   "devDependencies": {
-    "nx": "23.2.0-canary.20260717-dc22f7e"
+    "nx": "23.2.0-canary.20260722-6a072a2"
+  },
+  "peerDependencies": {
+    "@nx/vitest": "23.2.0-canary.20260722-6a072a2"
+  },
+  "peerDependenciesMeta": {
+    "@nx/vitest": {
+      "optional": true
+    }
   },
   "publishConfig": {
     "access": "public"