@nx/cypress 0.0.0-pr-22179-271588f

package/src/generators/init/init.d.ts

@@ -0,0 +1,6 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { Schema } from './schema';
+export declare function addPlugin(tree: Tree): void;
+export declare function cypressInitGenerator(tree: Tree, options: Schema): Promise<GeneratorCallback>;
+export declare function cypressInitGeneratorInternal(tree: Tree, options: Schema): Promise<GeneratorCallback>;
+export default cypressInitGenerator;

package/src/generators/init/init.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cypressInitGeneratorInternal = exports.cypressInitGenerator = exports.addPlugin = void 0;
+const devkit_1 = require("@nx/devkit");
+const update_package_scripts_1 = require("@nx/devkit/src/utils/update-package-scripts");
+const plugin_1 = require("../../plugins/plugin");
+const versions_1 = require("../../utils/versions");
+function setupE2ETargetDefaults(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (!nxJson.namedInputs) {
+        return;
+    }
+    // E2e targets depend on all their project's sources + production sources of dependencies
+    nxJson.targetDefaults ??= {};
+    const productionFileSet = !!nxJson.namedInputs?.production;
+    nxJson.targetDefaults.e2e ??= {};
+    nxJson.targetDefaults.e2e.cache ??= true;
+    nxJson.targetDefaults.e2e.inputs ??= [
+        'default',
+        productionFileSet ? '^production' : '^default',
+    ];
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+function updateDependencies(tree, options) {
+    const tasks = [];
+    tasks.push((0, devkit_1.removeDependenciesFromPackageJson)(tree, ['@nx/cypress'], []));
+    tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+        ['@nx/cypress']: versions_1.nxVersion,
+        cypress: versions_1.cypressVersion,
+    }, undefined, options.keepExistingVersions));
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+function addPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.plugins ??= [];
+    for (const plugin of nxJson.plugins) {
+        if (typeof plugin === 'string'
+            ? plugin === '@nx/cypress/plugin'
+            : plugin.plugin === '@nx/cypress/plugin') {
+            return;
+        }
+    }
+    nxJson.plugins.push({
+        plugin: '@nx/cypress/plugin',
+        options: {
+            targetName: 'e2e',
+            componentTestingTargetName: 'component-test',
+        },
+    });
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+exports.addPlugin = addPlugin;
+function updateProductionFileset(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const productionFileset = nxJson.namedInputs?.production;
+    if (productionFileset) {
+        nxJson.namedInputs.production = Array.from(new Set([
+            ...productionFileset,
+            '!{projectRoot}/cypress/**/*',
+            '!{projectRoot}/**/*.cy.[jt]s?(x)',
+            '!{projectRoot}/cypress.config.[jt]s',
+        ]));
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+async function cypressInitGenerator(tree, options) {
+    return cypressInitGeneratorInternal(tree, { addPlugin: false, ...options });
+}
+exports.cypressInitGenerator = cypressInitGenerator;
+async function cypressInitGeneratorInternal(tree, options) {
+    updateProductionFileset(tree);
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    options.addPlugin ??=
+        process.env.NX_ADD_PLUGINS !== 'false' &&
+            nxJson.useInferencePlugins !== false;
+    if (options.addPlugin) {
+        addPlugin(tree);
+    }
+    else {
+        setupE2ETargetDefaults(tree);
+    }
+    let installTask = () => { };
+    if (!options.skipPackageJson) {
+        installTask = updateDependencies(tree, options);
+    }
+    if (options.updatePackageScripts) {
+        global.NX_CYPRESS_INIT_GENERATOR_RUNNING = true;
+        await (0, update_package_scripts_1.updatePackageScripts)(tree, plugin_1.createNodes);
+        global.NX_CYPRESS_INIT_GENERATOR_RUNNING = false;
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return installTask;
+}
+exports.cypressInitGeneratorInternal = cypressInitGeneratorInternal;
+exports.default = cypressInitGenerator;

package/src/generators/init/schema.d.ts

@@ -0,0 +1,7 @@
+export interface Schema {
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  keepExistingVersions?: boolean;
+  updatePackageScripts?: boolean;
+  addPlugin?: boolean;
+}

package/src/generators/init/schema.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxCypressInit",
+  "cli": "nx",
+  "title": "Add Cypress Configuration to the workspace",
+  "description": "Add Cypress Configuration to the workspace.",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add dependencies to `package.json`.",
+      "x-priority": "internal"
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Keep existing dependencies versions",
+      "default": false
+    },
+    "updatePackageScripts": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Update `package.json` scripts with inferred targets",
+      "default": false
+    }
+  }
+}

package/src/generators/migrate-to-cypress-11/conversion.util.d.ts

@@ -0,0 +1,39 @@
+import { ProjectConfiguration, Tree } from '@nx/devkit';
+export declare function findCypressConfigs(tree: Tree, projectConfig: ProjectConfiguration, target: string, config: string): {
+    cypressConfigPathJson: string;
+    cypressConfigPathTs: string;
+};
+/**
+ * update the existing cypress.json config to the new cypress.config.ts structure.
+ * return both the old and new configs
+ */
+export declare function createNewCypressConfig(tree: Tree, projectConfig: ProjectConfiguration, cypressConfigPathJson: string): {
+    cypressConfigTs: Record<string, any>;
+    cypressConfigJson: Record<string, any>;
+};
+export declare function createSupportFileImport(oldSupportFilePath: string, newSupportFilePath: string, projectSourceRoot: string): {
+    oldImportPathLeaf: string;
+    newImportPathLeaf: string;
+};
+export declare function updateProjectPaths(tree: Tree, projectConfig: ProjectConfiguration, { cypressConfigTs, cypressConfigJson, }: {
+    cypressConfigTs: Record<string, any>;
+    cypressConfigJson: Record<string, any>;
+}): void;
+export declare function updateImports(tree: Tree, filePath: string, oldImportPath: string, newImportPath: string): void;
+export declare function writeNewConfig(tree: Tree, cypressConfigPathTs: string, cypressConfigs: {
+    cypressConfigTs: Record<string, any>;
+    cypressConfigJson: Record<string, any>;
+}): void;
+export declare function addConfigToTsConfig(tree: Tree, tsconfigPath: string, cypressConfigPath: string): void;
+export declare function updatePluginFile(tree: Tree, projectConfig: ProjectConfiguration, cypressConfigs: {
+    cypressConfigTs: Record<string, any>;
+    cypressConfigJson: Record<string, any>;
+}): {
+    cypressConfigTs: Record<string, any>;
+    cypressConfigJson: Record<string, any>;
+} | {
+    cypressConfigTs: {
+        e2e: any;
+    };
+    cypressConfigJson: Record<string, any>;
+};

package/src/generators/migrate-to-cypress-11/conversion.util.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePluginFile = exports.addConfigToTsConfig = exports.writeNewConfig = exports.updateImports = exports.updateProjectPaths = exports.createSupportFileImport = exports.createNewCypressConfig = exports.findCypressConfigs = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+let tsModule;
+let tsquery;
+const validFilesEndingsToUpdate = [
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.cjs',
+];
+function findCypressConfigs(tree, projectConfig, target, config) {
+    const cypressConfigPathJson = projectConfig.targets[target]?.configurations?.[config]?.cypressConfig ||
+        projectConfig.targets[target]?.options?.cypressConfig;
+    // make sure it's a json file, since it could have been updated to ts file from previous configuration migration
+    if (!cypressConfigPathJson || (0, path_1.extname)(cypressConfigPathJson) !== '.json') {
+        return {
+            cypressConfigPathJson: null,
+            cypressConfigPathTs: null,
+        };
+    }
+    const cypressConfigPathTs = (0, devkit_1.joinPathFragments)((0, path_1.dirname)(cypressConfigPathJson), 
+    // create matching ts config for custom cypress config if present
+    cypressConfigPathJson?.endsWith('cypress.json')
+        ? 'cypress.config.ts' //default
+        : `${(0, path_1.basename)(cypressConfigPathJson, (0, path_1.extname)(cypressConfigPathJson))}.config.ts`);
+    return {
+        cypressConfigPathJson,
+        cypressConfigPathTs,
+    };
+}
+exports.findCypressConfigs = findCypressConfigs;
+/**
+ * update the existing cypress.json config to the new cypress.config.ts structure.
+ * return both the old and new configs
+ */
+function createNewCypressConfig(tree, projectConfig, cypressConfigPathJson) {
+    const cypressConfigJson = (0, devkit_1.readJson)(tree, cypressConfigPathJson);
+    const { modifyObstructiveCode = null, // no longer needed in configs
+    integrationFolder = 'src/e2e', // provide the new defaults if the value isn't present
+    supportFile = 'src/support/e2e.ts', ...restOfConfig } = cypressConfigJson;
+    const newIntegrationFolder = tree.exists((0, devkit_1.joinPathFragments)(projectConfig.sourceRoot, 'integration'))
+        ? 'src/e2e'
+        : integrationFolder;
+    const cypressConfigTs = {
+        e2e: {
+            ...restOfConfig,
+            specPattern: `${newIntegrationFolder}/**/*.cy.{js,jsx,ts,tsx}`,
+            // if supportFile is defined (can be false if not using it) and in the default location (or in the new default location),
+            // then use the new default location.
+            // otherwise we will use the existing folder location/falsey value
+            supportFile: (supportFile &&
+                tree.exists((0, devkit_1.joinPathFragments)(projectConfig.sourceRoot, 'support', 'index.ts'))) ||
+                tree.exists((0, devkit_1.joinPathFragments)(projectConfig.sourceRoot, 'support', 'e2e.ts'))
+                ? 'src/support/e2e.ts'
+                : supportFile,
+            // if the default location is used then will update to the new location otherwise keep the custom location
+            // this is used down the line, but won't be in the final config file since it's a deprecated option
+            integrationFolder: newIntegrationFolder,
+        },
+    };
+    return { cypressConfigTs, cypressConfigJson };
+}
+exports.createNewCypressConfig = createNewCypressConfig;
+function createSupportFileImport(oldSupportFilePath, newSupportFilePath, projectSourceRoot) {
+    // need to get the new import path for the support file.
+    // before it was "<relative path>/support/index.ts" and the new path will be "<relative path>/support/e2e.ts"
+    // i.e. take ../support => ../support/e2e.ts
+    // 1. take apps/app-e2e/support/index.ts => support (this cant have a / in it. must grab the leaf for tsquery)
+    // 2. if the leaf value is index.ts then grab the parent directory (i.e. so we have support/index.ts => support)
+    // 3. take apps/app-e2e/support/e2e.ts => support/e2e
+    // apps/app-e2e/support/e2e.ts => support/e2e
+    const newFileExt = (0, path_1.extname)(newSupportFilePath);
+    const newImportPathLeaf = (0, path_1.relative)(projectSourceRoot, newSupportFilePath).replace(newFileExt, '');
+    // apps/app-e2e/support/index.ts => support/index
+    const oldFileExt = (0, path_1.extname)(oldSupportFilePath);
+    const oldImportPathLeaf = (0, path_1.relative)(projectSourceRoot, oldSupportFilePath).replace(oldFileExt, '');
+    // support/index => support
+    const oldRelativeImportPath = (0, path_1.basename)(oldImportPathLeaf, oldFileExt);
+    return {
+        newImportPathLeaf,
+        // don't import from 'support/index' it's just 'support'
+        oldImportPathLeaf: oldRelativeImportPath === 'index'
+            ? (0, path_1.dirname)(oldImportPathLeaf)
+            : oldImportPathLeaf,
+    };
+}
+exports.createSupportFileImport = createSupportFileImport;
+function updateProjectPaths(tree, projectConfig, { cypressConfigTs, cypressConfigJson, }) {
+    const { integrationFolder, supportFile } = cypressConfigTs['e2e'];
+    const oldIntegrationFolder = (0, devkit_1.joinPathFragments)(projectConfig.root, cypressConfigJson.integrationFolder);
+    const newIntegrationFolder = (0, devkit_1.joinPathFragments)(projectConfig.root, integrationFolder);
+    let newSupportFile;
+    let oldSupportFile;
+    let oldImportLeafPath;
+    let newImportLeafPath;
+    let shouldUpdateSupportFileImports = false;
+    // supportFile can be falsey or a string path to the file
+    if (cypressConfigJson.supportFile) {
+        // we need to check the test files to see if
+        // support file import is used and then update it if so
+        shouldUpdateSupportFileImports = true;
+        oldSupportFile = (0, devkit_1.joinPathFragments)(projectConfig.root, cypressConfigJson.supportFile);
+        newSupportFile = (0, devkit_1.joinPathFragments)(projectConfig.root, supportFile);
+        // oldSupportFile might have already been updated
+        // to the new default location so must be guarded for
+        if (oldSupportFile !== newSupportFile && tree.exists(oldSupportFile)) {
+            tree.rename(oldSupportFile, newSupportFile);
+        }
+    }
+    else {
+        shouldUpdateSupportFileImports = false;
+        newSupportFile = supportFile;
+        // rename the default support file even if not in use to keep the system in sync with cypress v10
+        const defaultSupportFile = (0, devkit_1.joinPathFragments)(projectConfig.sourceRoot, 'support', 'index.ts');
+        if (tree.exists(defaultSupportFile)) {
+            const newSupportDefaultPath = (0, devkit_1.joinPathFragments)(projectConfig.sourceRoot, 'support', 'e2e.ts');
+            if (defaultSupportFile !== newSupportDefaultPath &&
+                tree.exists(defaultSupportFile)) {
+                tree.rename(defaultSupportFile, newSupportDefaultPath);
+            }
+        }
+    }
+    if (shouldUpdateSupportFileImports) {
+        const newImportPaths = createSupportFileImport(oldSupportFile, newSupportFile, projectConfig.sourceRoot);
+        oldImportLeafPath = newImportPaths.oldImportPathLeaf;
+        newImportLeafPath = newImportPaths.newImportPathLeaf;
+    }
+    // tree.rename doesn't work on directories must update each file within
+    // the directory to the new directory
+    (0, devkit_1.visitNotIgnoredFiles)(tree, projectConfig.sourceRoot, (path) => {
+        const normalizedPath = (0, devkit_1.normalizePath)(path);
+        if (!normalizedPath.includes(oldIntegrationFolder)) {
+            return;
+        }
+        const fileName = (0, path_1.basename)(normalizedPath);
+        let newPath = normalizedPath.replace(oldIntegrationFolder, newIntegrationFolder);
+        if (fileName.includes('.spec.')) {
+            newPath = newPath.replace('.spec.', '.cy.');
+        }
+        if (newPath !== normalizedPath && tree.exists(normalizedPath)) {
+            tree.rename(normalizedPath, newPath);
+        }
+        // if they weren't using the supportFile then there is no need to update the imports.
+        if (shouldUpdateSupportFileImports &&
+            validFilesEndingsToUpdate.some((e) => path.endsWith(e))) {
+            updateImports(tree, newPath, oldImportLeafPath, newImportLeafPath);
+        }
+    });
+    if (tree.children(oldIntegrationFolder).length === 0) {
+        tree.delete(oldIntegrationFolder);
+    }
+}
+exports.updateProjectPaths = updateProjectPaths;
+function updateImports(tree, filePath, oldImportPath, newImportPath) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    if (!tsquery) {
+        (0, ensure_typescript_1.ensureTypescript)();
+        tsquery = require('@phenomnomnominal/tsquery').tsquery;
+    }
+    const { isCallExpression, isExportDeclaration, isImportDeclaration } = tsModule;
+    const endOfImportSelector = `StringLiteral[value=/${oldImportPath}$/]`;
+    const fileContent = tree.read(filePath, 'utf-8');
+    const newContent = tsquery.replace(fileContent, endOfImportSelector, (node) => {
+        // if node.parent is an CallExpression require() ||ImportDeclaration
+        if (node?.parent &&
+            (isCallExpression(node.parent) ||
+                isImportDeclaration(node.parent) ||
+                isExportDeclaration(node.parent))) {
+            return `'${node.text.replace(oldImportPath, newImportPath)}'`;
+        }
+        return node.text;
+    });
+    tree.write(filePath, newContent);
+}
+exports.updateImports = updateImports;
+function writeNewConfig(tree, cypressConfigPathTs, cypressConfigs) {
+    // remove deprecated configs options
+    const { pluginsFile = false, integrationFolder = '', ...restOfConfig } = cypressConfigs.cypressConfigTs.e2e;
+    const pluginImport = pluginsFile
+        ? `import setupNodeEvents from '${pluginsFile}';`
+        : '';
+    const convertedConfig = JSON.stringify(restOfConfig, null, 2);
+    tree.write(cypressConfigPathTs, (0, devkit_1.stripIndents) `
+import { defineConfig } from 'cypress'
+import { nxE2EPreset } from '@nx/cypress/plugins/cypress-preset';
+${pluginImport}
+
+const cypressJsonConfig = ${convertedConfig}
+export default defineConfig({
+  e2e: {
+    ...nxE2EPreset(__dirname),
+    ...cypressJsonConfig,
+    ${pluginsFile ? 'setupNodeEvents' : ''}
+  }
+})
+`);
+}
+exports.writeNewConfig = writeNewConfig;
+function addConfigToTsConfig(tree, tsconfigPath, cypressConfigPath) {
+    if (tree.exists(tsconfigPath)) {
+        (0, devkit_1.updateJson)(tree, tsconfigPath, (json) => {
+            json.include = Array.from(new Set([
+                ...(json.include || []),
+                (0, path_1.relative)((0, path_1.dirname)(tsconfigPath), cypressConfigPath),
+            ]));
+            return json;
+        }, { expectComments: true });
+    }
+}
+exports.addConfigToTsConfig = addConfigToTsConfig;
+function updatePluginFile(tree, projectConfig, cypressConfigs) {
+    // if ts file change module.exports = to export default
+    // if js file don't do anything
+    // update cypressConfigTs.e2e to remove file extension
+    const pluginsFile = cypressConfigs.cypressConfigTs?.e2e?.pluginsFile;
+    if (!pluginsFile) {
+        return cypressConfigs;
+    }
+    const ext = (0, path_1.extname)(pluginsFile);
+    const updatedCypressConfigs = {
+        ...cypressConfigs,
+        cypressConfigTs: {
+            e2e: {
+                ...cypressConfigs.cypressConfigTs.e2e,
+                pluginsFile: pluginsFile.replace(ext, ''),
+            },
+        },
+    };
+    const pluginFilePath = (0, devkit_1.joinPathFragments)(projectConfig.root, pluginsFile);
+    if (ext === '.ts' && tree.exists(pluginFilePath)) {
+        const pluginFileContent = tree.read(pluginFilePath, 'utf-8');
+        tree.write(pluginFilePath, pluginFileContent
+            .replace('module.exports =', 'export default')
+            .replace(/module\.exports\.(.*?)=/g, 'export const $1='));
+    }
+    return updatedCypressConfigs;
+}
+exports.updatePluginFile = updatePluginFile;

package/src/generators/migrate-to-cypress-11/migrate-to-cypress-11.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export declare function migrateCypressProject(tree: Tree): Promise<() => void>;
+export default migrateCypressProject;

package/src/generators/migrate-to-cypress-11/migrate-to-cypress-11.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateCypressProject = void 0;
+const cypress_version_1 = require("../../utils/cypress-version");
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const conversion_util_1 = require("./conversion.util");
+function migrateCypressExecutorOptions(tree, projectName, target, configuration, previousCypressConfigs) {
+    try {
+        const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+        const { cypressConfigPathJson, cypressConfigPathTs } = (0, conversion_util_1.findCypressConfigs)(tree, projectConfig, target, configuration);
+        if (!cypressConfigPathJson && !cypressConfigPathTs) {
+            return;
+        }
+        // a matching cypress ts file hasn't been made yet. need to migrate.
+        if (tree.exists(cypressConfigPathJson) &&
+            !tree.exists(cypressConfigPathTs)) {
+            let cypressConfigs = (0, conversion_util_1.createNewCypressConfig)(tree, projectConfig, cypressConfigPathJson);
+            cypressConfigs = (0, conversion_util_1.updatePluginFile)(tree, projectConfig, cypressConfigs);
+            (0, conversion_util_1.writeNewConfig)(tree, cypressConfigPathTs, cypressConfigs);
+            previousCypressConfigs.set(cypressConfigPathJson, cypressConfigs);
+            tree.delete(cypressConfigPathJson);
+        }
+        // ts file has been made and matching json file has been removed only need to update the project config
+        if (!tree.exists(cypressConfigPathJson) &&
+            tree.exists(cypressConfigPathTs)) {
+            const cypressConfigs = previousCypressConfigs.get(cypressConfigPathJson);
+            (0, conversion_util_1.updateProjectPaths)(tree, projectConfig, cypressConfigs);
+            (0, conversion_util_1.addConfigToTsConfig)(tree, (configuration
+                ? projectConfig.targets?.[target]?.configurations?.[configuration]
+                    ?.tsConfig
+                : projectConfig.targets?.[target]?.options?.tsConfig) ||
+                (0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.json'), cypressConfigPathTs);
+            if (configuration) {
+                projectConfig.targets[target].configurations[configuration] = {
+                    ...projectConfig.targets[target].configurations[configuration],
+                    cypressConfig: cypressConfigPathTs,
+                };
+            }
+            else {
+                projectConfig.targets[target].options = {
+                    ...projectConfig.targets[target].options,
+                    cypressConfig: cypressConfigPathTs,
+                };
+            }
+            projectConfig.targets[target].options.testingType = 'e2e';
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfig);
+        }
+    }
+    catch (e) {
+        devkit_1.logger.error((0, devkit_1.stripIndents) `
+NX There was an error converting ${projectName}:${target}.
+You can manually update the project by following the migration guide if need be.
+https://nx.dev/cypress/v10-migration-guide
+  `);
+        throw e;
+    }
+}
+async function migrateCypressProject(tree) {
+    (0, cypress_version_1.assertMinimumCypressVersion)(8);
+    if ((0, cypress_version_1.installedCypressVersion)() >= 10) {
+        devkit_1.logger.info('NX This workspace is already using Cypress v10+');
+        return;
+    }
+    // keep history of cypress configs as some workspaces share configs
+    // if we don't have the already migrated configs
+    // it prevents us from being able to rename files for those projects
+    const previousCypressConfigs = new Map();
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/cypress:cypress', (currentValue, projectName, target, configuration) => {
+        migrateCypressExecutorOptions(tree, projectName, target, configuration, previousCypressConfigs);
+    });
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nrwl/cypress:cypress', (currentValue, projectName, target, configuration) => {
+        migrateCypressExecutorOptions(tree, projectName, target, configuration, previousCypressConfigs);
+    });
+    (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
+        json.devDependencies['cypress'] = '^11.2.0';
+        return json;
+    });
+    await (0, devkit_1.formatFiles)(tree);
+    if (tree.exists('cypress.json')) {
+        devkit_1.logger.warn((0, devkit_1.stripIndents) `A root cypress.json file was found. 
+    You should remove this file as it will cause an error when running Cypress.
+    If you want to share options between Cypress projects. 
+    You can create a root ts file and import it into each project's cypress config file.
+    More Info: https://github.com/nrwl/nx/issues/11512#issuecomment-1213420638
+    `);
+    }
+    return () => {
+        (0, devkit_1.installPackagesTask)(tree);
+    };
+}
+exports.migrateCypressProject = migrateCypressProject;
+exports.default = migrateCypressProject;

package/src/generators/migrate-to-cypress-11/schema.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxCypressMigrateTo11",
+  "cli": "nx",
+  "title": "Migrate e2e project to Cypress 11",
+  "description": "Migrate Cypress e2e project from v8/v9 to Cypress v11.",
+  "type": "object",
+  "examples": [
+    {
+      "command": "nx g @nx/cypress:migrate-to-cypress-11",
+      "description": "Migrate existing cypress projects to Cypress v11"
+    }
+  ],
+  "properties": {}
+}

package/src/migrations/update-15-0-0/add-cypress-inputs.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<void>;

package/src/migrations/update-15-0-0/add-cypress-inputs.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+async function default_1(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const { cypressTargets, hasComponentTesting } = getCypressTargetNames(tree);
+    const hasProductionFileset = !!nxJson.namedInputs?.production;
+    if (hasComponentTesting && hasProductionFileset && cypressTargets.size > 0) {
+        const productionFileset = new Set(nxJson.namedInputs.production);
+        for (const exclusion of [
+            '!{projectRoot}/cypress/**/*',
+            '!{projectRoot}/**/*.cy.[jt]s?(x)',
+            '!{projectRoot}/cypress.config.[jt]s',
+        ]) {
+            productionFileset.add(exclusion);
+        }
+        nxJson.namedInputs.production = Array.from(productionFileset);
+    }
+    for (const targetName of cypressTargets) {
+        nxJson.targetDefaults ??= {};
+        const cypressTargetDefaults = (nxJson.targetDefaults[targetName] ??= {});
+        cypressTargetDefaults.inputs ??= [
+            'default',
+            hasProductionFileset ? '^production' : '^default',
+        ];
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;
+function getCypressTargetNames(tree) {
+    const cypressTargets = new Set();
+    let hasComponentTesting = false;
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nrwl/cypress:cypress', (options, __, target) => {
+        cypressTargets.add(target);
+        if (options.testingType === 'component') {
+            hasComponentTesting = true;
+        }
+    });
+    return { cypressTargets, hasComponentTesting };
+}

package/src/migrations/update-15-0-0/update-cy-mount-usage.d.ts

@@ -0,0 +1,5 @@
+import { Tree } from '@nx/devkit';
+export declare function updateCyMountUsage(tree: Tree): Promise<void>;
+export declare function addMountCommand(tree: Tree, projectRoot: string, framework: string): void;
+export declare function updateCyFile(tree: Tree, filePath: string, framework: 'angular' | 'react' | 'react18'): void;
+export default updateCyMountUsage;