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

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

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateCyFile = exports.addMountCommand = exports.updateCyMountUsage = void 0;
+const ct_helpers_1 = require("../../utils/ct-helpers");
+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 semver_1 = require("@nx/devkit/src/utils/semver");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const semver_2 = require("semver");
+async function updateCyMountUsage(tree) {
+    if ((0, cypress_version_1.installedCypressVersion)() < 10) {
+        return;
+    }
+    const projects = (0, devkit_1.getProjects)(tree);
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nrwl/cypress:cypress', (options, projectName) => {
+        if (options.testingType !== 'component' || !options.devServerTarget) {
+            return;
+        }
+        const parsed = (0, devkit_1.parseTargetString)(options.devServerTarget, graph);
+        if (!parsed?.project || !parsed?.target) {
+            return;
+        }
+        const buildProjectConfig = projects.get(parsed.project);
+        const framework = getFramework(tree, parsed.configuration
+            ? buildProjectConfig.targets[parsed.target].configurations[parsed.configuration]
+            : buildProjectConfig.targets[parsed.target]);
+        const ctProjectConfig = projects.get(projectName);
+        addMountCommand(tree, ctProjectConfig.root, framework);
+        (0, devkit_1.visitNotIgnoredFiles)(tree, ctProjectConfig.sourceRoot, (filePath) => {
+            if (ct_helpers_1.CY_FILE_MATCHER.test(filePath)) {
+                updateCyFile(tree, filePath, framework);
+            }
+        });
+    });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.updateCyMountUsage = updateCyMountUsage;
+function addMountCommand(tree, projectRoot, framework) {
+    const commandFilePath = (0, devkit_1.joinPathFragments)(projectRoot, 'cypress', 'support', 'commands.ts');
+    if (!tree.exists(commandFilePath)) {
+        return;
+    }
+    const commandFile = tree.read(commandFilePath, 'utf-8');
+    const mountCommand = tsquery_1.tsquery.query(commandFile, 'CallExpression:has(StringLiteral[value="mount"]) PropertyAccessExpression:has(Identifier[name="add"])');
+    if (mountCommand?.length > 0) {
+        return;
+    }
+    const existingCommands = tsquery_1.tsquery.query(commandFile, 'InterfaceDeclaration:has(Identifier[name="Chainable"]) > MethodSignature, InterfaceDeclaration:has(Identifier[name="Chainable"]) > PropertySignature');
+    const isGlobalDeclaration = tsquery_1.tsquery.query(commandFile, 'ModuleDeclaration > Identifier[name="global"]');
+    const updatedInterface = tsquery_1.tsquery.replace(commandFile, 'ModuleDeclaration:has(Identifier[name="Cypress"])', (node) => {
+        const newModuleDelcaration = `declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace Cypress {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    interface Chainable<Subject> {
+      ${existingCommands.map((c) => c.getText()).join('\n')}
+      mount: typeof mount;
+    }
+  }
+}`;
+        /*
+         * this is to prevent the change being applied twice since
+         * declare global { 1
+         *   interface Cypress { 2
+         *   }
+         * }
+         * matches twice.
+         * i.e. if there is no global declaration, then add it
+         * or if the node is the global declaration, then add it,
+         * but not to the cypress module declaration inside the global declaration
+         */
+        if (isGlobalDeclaration?.length === 0 ||
+            node.name.getText() === 'global') {
+            return newModuleDelcaration;
+        }
+    });
+    const updatedCommandFile = `import { mount } from 'cypress/${framework}'\n${updatedInterface}\nCypress.Commands.add('mount', mount);`;
+    tree.write(commandFilePath, updatedCommandFile);
+}
+exports.addMountCommand = addMountCommand;
+function getFramework(tree, target) {
+    if (target.executor === '@nrwl/angular:webpack-browser' ||
+        target.executor === '@angular-devkit/build-angular:browser') {
+        return 'angular';
+    }
+    const pkgJson = (0, devkit_1.readJson)(tree, 'package.json');
+    const reactDomVersion = pkgJson?.dependencies?.['react-dom'];
+    const hasReact18 = reactDomVersion &&
+        (0, semver_2.gte)((0, semver_1.checkAndCleanWithSemver)('react-dom', reactDomVersion), '18.0.0');
+    if (hasReact18) {
+        return 'react18';
+    }
+    return 'react';
+}
+function updateCyFile(tree, filePath, framework) {
+    if (!tree.exists(filePath)) {
+        return;
+    }
+    const contents = tree.read(filePath, 'utf-8');
+    const withCyMount = tsquery_1.tsquery.replace(contents, ':matches(CallExpression>Identifier[name="mount"])', (node) => {
+        return `cy.mount`;
+    });
+    const withUpdatedImports = tsquery_1.tsquery.replace(withCyMount, ':matches(ImportDeclaration, VariableStatement):has(Identifier[name="mount"]):has(StringLiteral[value="cypress/react"], StringLiteral[value="cypress/angular"], StringLiteral[value="cypress/react18"])', (node) => {
+        switch (framework) {
+            case 'angular':
+                return `import { MountConfig } from 'cypress/angular';`;
+            case 'react18':
+            case 'react':
+                return ' '; // have to return non falsy string to remove the node
+            default:
+                return node.getText().replace('mount', '');
+        }
+    });
+    tree.write(filePath, withUpdatedImports);
+}
+exports.updateCyFile = updateCyFile;
+exports.default = updateCyMountUsage;

package/src/migrations/update-15-1-0/cypress-11.d.ts

@@ -0,0 +1,6 @@
+import { Tree } from '@nx/devkit';
+export declare function updateToCypress11(tree: Tree): Promise<() => void>;
+export declare function updateMountHookUsage(tree: Tree, filePath: string): void;
+export declare function updateUnmountUsage(tree: Tree, filePath: string): void;
+export declare function updateProviderUsage(tree: Tree, filePath: string): void;
+export default updateToCypress11;

package/src/migrations/update-15-1-0/cypress-11.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateProviderUsage = exports.updateUnmountUsage = exports.updateMountHookUsage = exports.updateToCypress11 = void 0;
+const ct_helpers_1 = require("../../utils/ct-helpers");
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const path_1 = require("path");
+const ts = require("typescript");
+const cypress_version_1 = require("../../utils/cypress-version");
+const versions_1 = require("../../utils/versions");
+async function updateToCypress11(tree) {
+    const installedVersion = (0, cypress_version_1.installedCypressVersion)();
+    if (installedVersion < 10) {
+        return;
+    }
+    const projects = (0, devkit_1.getProjects)(tree);
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nrwl/cypress:cypress', (options, projectName, targetName, configurationName) => {
+        if (options.testingType !== 'component' ||
+            !(options.cypressConfig && tree.exists(options.cypressConfig))) {
+            return;
+        }
+        const projectConfig = projects.get(projectName);
+        const commandsFile = (0, devkit_1.joinPathFragments)(projectConfig.root, 'cypress', 'support', 'commands.ts');
+        const framework = getFramework(tree.exists(commandsFile)
+            ? tree.read(commandsFile, 'utf-8')
+            : tree.read(options.cypressConfig, 'utf-8'));
+        (0, devkit_1.visitNotIgnoredFiles)(tree, projectConfig.sourceRoot, (filePath) => {
+            if (!ct_helpers_1.CY_FILE_MATCHER.test(filePath)) {
+                return;
+            }
+            const frameworkFromFile = getFramework(tree.read(filePath, 'utf-8'));
+            if (framework === 'react' || frameworkFromFile === 'react') {
+                updateUnmountUsage(tree, filePath);
+                updateMountHookUsage(tree, filePath);
+            }
+            if (framework === 'angular' || frameworkFromFile === 'angular') {
+                updateProviderUsage(tree, filePath);
+            }
+        });
+    });
+    const installTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { cypress: versions_1.cypressVersion });
+    await (0, devkit_1.formatFiles)(tree);
+    return () => {
+        installTask();
+    };
+}
+exports.updateToCypress11 = updateToCypress11;
+function updateMountHookUsage(tree, filePath) {
+    const originalContents = tree.read(filePath, 'utf-8');
+    const commentedMountHook = tsquery_1.tsquery.replace(originalContents, ':matches(ImportDeclaration, VariableStatement):has(Identifier[name="mountHook"]):has(StringLiteral[value="cypress/react"], StringLiteral[value="cypress/react18"])', (node) => {
+        return `/** TODO: mountHook is deprecate. 
+* Use a wrapper component instead. 
+* See post for details: https://www.cypress.io/blog/2022/11/04/upcoming-changes-to-component-testing/#reactmounthook-removed 
+* */\n${node.getText()}`;
+    });
+    tree.write(filePath, commentedMountHook);
+}
+exports.updateMountHookUsage = updateMountHookUsage;
+function updateUnmountUsage(tree, filePath) {
+    const reactDomImport = (0, path_1.extname)(filePath).includes('ts')
+        ? `import ReactDom from 'react-dom'`
+        : `const ReactDom = require('react-dom')`;
+    const originalContents = tree.read(filePath, 'utf-8');
+    const updatedImports = tsquery_1.tsquery.replace(originalContents, ':matches(ImportDeclaration, VariableStatement):has(Identifier[name="unmount"]):has(StringLiteral[value="cypress/react"], StringLiteral[value="cypress/react18"])', (node) => {
+        return `${node.getText().replace('unmount', 'getContainerEl')}
+${reactDomImport}`;
+    });
+    const updatedUnmountApi = tsquery_1.tsquery.replace(updatedImports, 'ExpressionStatement > CallExpression:has(Identifier[name="unmount"])', (node) => {
+        if (node.expression.getText() === 'unmount') {
+            return `cy.then(() => ReactDom.unmountComponentAtNode(getContainerEl()))`;
+        }
+    });
+    tree.write(filePath, updatedUnmountApi);
+}
+exports.updateUnmountUsage = updateUnmountUsage;
+function updateProviderUsage(tree, filePath) {
+    const originalContents = tree.read(filePath, 'utf-8');
+    const isTestBedImported = tsquery_1.tsquery.query(originalContents, ':matches(ImportDeclaration, VariableStatement):has(Identifier[name="TestBed"]):has(StringLiteral[value="@angular/core/testing"])')?.length > 0;
+    let updatedProviders = tsquery_1.tsquery.replace(originalContents, 'CallExpression:has(PropertyAccessExpression:has(Identifier[name="mount"]))', (node) => {
+        const expressionName = node.expression.getText();
+        if (expressionName === 'cy.mount' && node?.arguments?.length > 1) {
+            const component = node.arguments[0].getText();
+            if (ts.isObjectLiteralExpression(node.arguments[1])) {
+                const providers = node.arguments[1]?.properties
+                    ?.find((p) => p.name?.getText() === 'providers')
+                    ?.getText();
+                const noProviders = tsquery_1.tsquery.replace(node.getText(), 'PropertyAssignment:has(Identifier[name="providers"])', (n) => {
+                    // set it to undefined so we don't run into a hanging comma causing invalid syntax
+                    return 'providers: undefined';
+                });
+                return `TestBed.overrideComponent(${component}, { add: { ${providers} }});\n${noProviders}`;
+            }
+            else {
+                return `TestBed.overrideComponent(${component}, {add: { providers: ${node.arguments[1].getText()}.providers}});\n${node.getText()}`;
+            }
+        }
+    });
+    tree.write(filePath, `${isTestBedImported
+        ? ''
+        : "import {TestBed} from '@angular/core/testing';\n"}${updatedProviders}`);
+}
+exports.updateProviderUsage = updateProviderUsage;
+function getFramework(contents) {
+    if (contents.includes('cypress/react') || contents.includes('@nrwl/react')) {
+        return 'react';
+    }
+    if (contents.includes('cypress/angular') ||
+        contents.includes('@nrwl/angular')) {
+        return 'angular';
+    }
+    return null;
+}
+exports.default = updateToCypress11;

package/src/migrations/update-15-5-0/helpers.d.ts

@@ -0,0 +1,3 @@
+import type { Node } from 'typescript';
+export declare function isAlreadyCommented(node: Node): boolean;
+export declare const BANNED_COMMANDS: string[];

package/src/migrations/update-15-5-0/helpers.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BANNED_COMMANDS = exports.isAlreadyCommented = void 0;
+function isAlreadyCommented(node) {
+    return node.getFullText().includes('TODO(@nrwl/cypress)');
+}
+exports.isAlreadyCommented = isAlreadyCommented;
+exports.BANNED_COMMANDS = [
+    'as',
+    'children',
+    'closest',
+    'contains',
+    'debug',
+    'document',
+    'eq',
+    'filter',
+    'find',
+    'first',
+    'focused',
+    'get',
+    'hash',
+    'its',
+    'last',
+    'location',
+    'next',
+    'nextAll',
+    'not',
+    'parent',
+    'parents',
+    'parentsUntil',
+    'prev',
+    'prevUntil',
+    'root',
+    'shadow',
+    'siblings',
+    'title',
+    'url',
+    'window',
+];

package/src/migrations/update-15-5-0/update-to-cypress-12.d.ts

@@ -0,0 +1,24 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+export declare function updateToCypress12(tree: Tree): GeneratorCallback;
+export declare function turnOffTestIsolation(tree: Tree, configPath: string): void;
+/**
+ * Leave a comment on all apis that have been removed andsuperseded by cy.intercept
+ * stating they these API are now removed and need to update.
+ * cy.route, cy.server, Cypress.Server.defaults
+ **/
+export declare function shouldUseCyIntercept(tree: Tree, filePath: string): void;
+/**
+ * Leave a comment on all apis that have been removed and superseded by cy.session
+ * stating they these API are now removed and need to update.
+ * Cypress.Cookies.defaults & Cypress.Cookies.preserveOnce
+ **/
+export declare function shouldUseCySession(tree: Tree, filePath: string): void;
+/**
+ * leave a comment about nested cy commands in a cy.should callback
+ * */
+export declare function shouldNotUseCyInShouldCB(tree: Tree, filePath: string): void;
+/**
+ * leave a comment on all usages of overriding built-ins that are now banned
+ * */
+export declare function shouldNotOverrideCommands(tree: Tree, filePath: string): void;
+export default updateToCypress12;

package/src/migrations/update-15-5-0/update-to-cypress-12.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldNotOverrideCommands = exports.shouldNotUseCyInShouldCB = exports.shouldUseCySession = exports.shouldUseCyIntercept = exports.turnOffTestIsolation = exports.updateToCypress12 = void 0;
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const typescript_1 = require("typescript");
+const cypress_version_1 = require("../../utils/cypress-version");
+const helpers_1 = require("./helpers");
+const JS_TS_FILE_MATCHER = /\.[jt]sx?$/;
+function updateToCypress12(tree) {
+    if ((0, cypress_version_1.installedCypressVersion)() < 11) {
+        return;
+    }
+    const projects = (0, devkit_1.getProjects)(tree);
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nrwl/cypress:cypress', (options, projectName, targetName, configName) => {
+        if (!(options.cypressConfig && tree.exists(options.cypressConfig))) {
+            return;
+        }
+        const projectConfig = projects.get(projectName);
+        turnOffTestIsolation(tree, options.cypressConfig);
+        (0, devkit_1.visitNotIgnoredFiles)(tree, projectConfig.root, (filePath) => {
+            if (!JS_TS_FILE_MATCHER.test(filePath)) {
+                return;
+            }
+            shouldUseCyIntercept(tree, filePath);
+            shouldUseCySession(tree, filePath);
+            shouldNotUseCyInShouldCB(tree, filePath);
+            shouldNotOverrideCommands(tree, filePath);
+        });
+    });
+    console.warn((0, devkit_1.stripIndents) `Cypress 12 has lots of breaking changes that might subtly break your tests.
+This migration marked known issues that need to be manually migrated, 
+but there can still be runtime based errors that were not detected.
+Please consult the offical Cypress v12 migration guide for more info on these changes and the next steps.
+https://docs.cypress.io/guides/references/migration-guide
+      `);
+    (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
+        json.devDependencies.cypress = '^12.2.0';
+        return json;
+    });
+    return () => {
+        (0, devkit_1.installPackagesTask)(tree);
+    };
+}
+exports.updateToCypress12 = updateToCypress12;
+function turnOffTestIsolation(tree, configPath) {
+    const config = tree.read(configPath, 'utf-8');
+    const isTestIsolationSet = tsquery_1.tsquery.query(config, 'ExportAssignment ObjectLiteralExpression > PropertyAssignment:has(Identifier[name="testIsolation"])');
+    if (isTestIsolationSet.length > 0) {
+        return;
+    }
+    const testIsolationProperty = `/**
+    * TODO(@nrwl/cypress): In Cypress v12,the testIsolation option is turned on by default. 
+    * This can cause tests to start breaking where not indended.
+    * You should consider enabling this once you verify tests do not depend on each other
+    * More Info: https://docs.cypress.io/guides/references/migration-guide#Test-Isolation
+    **/
+    testIsolation: false,`;
+    const updated = tsquery_1.tsquery.replace(config, 'ExportAssignment ObjectLiteralExpression > PropertyAssignment:has(Identifier[name="e2e"])', (node) => {
+        if ((0, typescript_1.isObjectLiteralExpression)(node.initializer)) {
+            const listOfProperties = node.initializer.properties
+                .map((j) => j.getText())
+                .join(',\n    ');
+            return `e2e: {
+    ${listOfProperties},
+    ${testIsolationProperty}
+ }`;
+        }
+        return `e2e: {
+    ...${node.initializer.getText()},
+    ${testIsolationProperty}
+  }`;
+    });
+    tree.write(configPath, updated);
+}
+exports.turnOffTestIsolation = turnOffTestIsolation;
+/**
+ * Leave a comment on all apis that have been removed andsuperseded by cy.intercept
+ * stating they these API are now removed and need to update.
+ * cy.route, cy.server, Cypress.Server.defaults
+ **/
+function shouldUseCyIntercept(tree, filePath) {
+    const content = tree.read(filePath, 'utf-8');
+    const markedRemovedCommands = tsquery_1.tsquery.replace(content, ':matches(PropertyAccessExpression:has(Identifier[name="cy"]):has(Identifier[name="server"], Identifier[name="route"]), PropertyAccessExpression:has(Identifier[name="defaults"]):has(Identifier[name="Cypress"], Identifier[name="Server"]))', (node) => {
+        if ((0, helpers_1.isAlreadyCommented)(node)) {
+            return;
+        }
+        const expression = node.expression.getText().trim();
+        // prevent extra chaining i.e. cy.route().as() will return 2 results
+        // cy.route and cy.route().as
+        // only need the first 1 so skip any extra chaining
+        if (expression === 'cy' || expression === 'Cypress.Server') {
+            return `// TODO(@nrwl/cypress): this command has been removed, use cy.intercept instead. https://docs.cypress.io/guides/references/migration-guide#cy-server-cy-route-and-Cypress-Server-defaults
+${node.getText()}`;
+        }
+    });
+    tree.write(filePath, markedRemovedCommands);
+}
+exports.shouldUseCyIntercept = shouldUseCyIntercept;
+/**
+ * Leave a comment on all apis that have been removed and superseded by cy.session
+ * stating they these API are now removed and need to update.
+ * Cypress.Cookies.defaults & Cypress.Cookies.preserveOnce
+ **/
+function shouldUseCySession(tree, filePath) {
+    const content = tree.read(filePath, 'utf-8');
+    const markedRemovedCommands = tsquery_1.tsquery.replace(content, ':matches(PropertyAccessExpression:has(Identifier[name="defaults"]):has(Identifier[name="Cypress"], Identifier[name="Cookies"]), PropertyAccessExpression:has(Identifier[name="preserveOnce"]):has(Identifier[name="Cypress"], Identifier[name="Cookies"]))', (node) => {
+        if ((0, helpers_1.isAlreadyCommented)(node)) {
+            return;
+        }
+        const expression = node.expression.getText().trim();
+        // prevent grabbing other Cypress.<something>.defaults
+        if (expression === 'Cypress.Cookies') {
+            return `// TODO(@nrwl/cypress): this command has been removed, use cy.session instead. https://docs.cypress.io/guides/references/migration-guide#Command-Cypress-API-Changes
+${node.getText()}`;
+        }
+    });
+    tree.write(filePath, markedRemovedCommands);
+}
+exports.shouldUseCySession = shouldUseCySession;
+/**
+ * leave a comment about nested cy commands in a cy.should callback
+ * */
+function shouldNotUseCyInShouldCB(tree, filePath) {
+    const content = tree.read(filePath, 'utf-8');
+    const markedNestedCyCommands = tsquery_1.tsquery.replace(content, 'CallExpression > PropertyAccessExpression:has(Identifier[name="cy"]):has(Identifier[name="should"])', (node) => {
+        if ((0, helpers_1.isAlreadyCommented)(node) ||
+            (node.parent && !(0, typescript_1.isCallExpression)(node.parent))) {
+            return;
+        }
+        const parentExpression = node.parent;
+        if (parentExpression?.arguments?.[0] &&
+            ((0, typescript_1.isArrowFunction)(parentExpression.arguments[0]) ||
+                (0, typescript_1.isFunctionExpression)(parentExpression.arguments[0]))) {
+            const isUsingNestedCyCommand = tsquery_1.tsquery.query(parentExpression.arguments[0], 'CallExpression > PropertyAccessExpression:has(Identifier[name="cy"])')?.length > 0;
+            if (isUsingNestedCyCommand) {
+                return `/**
+* TODO(@nrwl/cypress): Nesting Cypress commands in a should assertion now throws.
+* You should use .then() to chain commands instead.
+* More Info: https://docs.cypress.io/guides/references/migration-guide#-should
+**/
+${node.getText()}`;
+            }
+            return node.getText();
+        }
+    });
+    tree.write(filePath, markedNestedCyCommands);
+}
+exports.shouldNotUseCyInShouldCB = shouldNotUseCyInShouldCB;
+/**
+ * leave a comment on all usages of overriding built-ins that are now banned
+ * */
+function shouldNotOverrideCommands(tree, filePath) {
+    const content = tree.read(filePath, 'utf-8');
+    const markedOverrideUsage = tsquery_1.tsquery.replace(content, 'PropertyAccessExpression:has(Identifier[name="overwrite"]):has(Identifier[name="Cypress"])', (node) => {
+        if ((0, helpers_1.isAlreadyCommented)(node)) {
+            return;
+        }
+        const expression = node.expression.getText().trim();
+        // prevent grabbing other Cypress.<something>.defaults
+        if (expression === 'Cypress.Commands') {
+            // get value.
+            const overwriteExpression = node.parent;
+            const command = overwriteExpression.arguments?.[0]?.text; // need string without quotes
+            if (helpers_1.BANNED_COMMANDS.includes(command)) {
+                // overwrite
+                return `/**
+* TODO(@nrwl/cypress): This command can no longer be overridden
+* Consider using a different name like 'custom_${command}'
+* More info: https://docs.cypress.io/guides/references/migration-guide#Cypress-Commands-overwrite
+**/
+${node.getText()}`;
+            }
+        }
+    });
+    tree.write(filePath, markedOverrideUsage);
+}
+exports.shouldNotOverrideCommands = shouldNotOverrideCommands;
+exports.default = updateToCypress12;

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.d.ts

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

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const replace_package_1 = require("@nx/devkit/src/utils/replace-package");
+async function replacePackage(tree) {
+    await (0, replace_package_1.replaceNrwlPackageWithNxPackage)(tree, '@nrwl/cypress', '@nx/cypress');
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = replacePackage;

package/src/migrations/update-16-2-0/update-cy-tsconfig.d.ts

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

package/src/migrations/update-16-2-0/update-cy-tsconfig.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCyTsConfigNames = void 0;
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+async function normalizeCyTsConfigNames(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/cypress:cypress', (_, projectName) => {
+        const projectConfig = projects.get(projectName);
+        const newTsConfigPath = (0, devkit_1.joinPathFragments)(projectConfig.root, 'cypress', 'tsconfig.json');
+        // if there is already a tsconfig.json in the cypress folder, then assume things are setup already
+        if (!tree.exists(newTsConfigPath)) {
+            moveProjectTsCyConfig(tree, projectConfig, newTsConfigPath);
+            moveCyDirTsCyConfig(tree, projectConfig, newTsConfigPath);
+            updateCyDirTsConfigReferences(tree, projectConfig);
+        }
+    });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.normalizeCyTsConfigNames = normalizeCyTsConfigNames;
+function moveProjectTsCyConfig(tree, projectConfig, newTsConfigPath) {
+    if (tree.exists((0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.cy.json'))) {
+        tree.rename((0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.cy.json'), newTsConfigPath);
+        (0, devkit_1.updateJson)(tree, newTsConfigPath, (json) => {
+            json.extends = '../tsconfig.json';
+            json.compilerOptions ??= {};
+            json.compilerOptions = {
+                ...json.compilerOptions,
+                sourceMap: false,
+                outDir: '../../../dist/out-tsc',
+            };
+            json.include ??= [];
+            json.include = json.include.map((p) => {
+                if (p.startsWith('cypress/')) {
+                    return p.replace('cypress/', '');
+                }
+                return `../${p}`;
+            });
+            return json;
+        });
+    }
+}
+function moveCyDirTsCyConfig(tree, projectConfig, newTsConfigPath) {
+    if (tree.exists((0, devkit_1.joinPathFragments)(projectConfig.root, 'cypress', 'tsconfig.cy.json'))) {
+        tree.rename((0, devkit_1.joinPathFragments)(projectConfig.root, 'cypress', 'tsconfig.cy.json'), newTsConfigPath);
+        (0, devkit_1.updateJson)(tree, newTsConfigPath, (json) => {
+            json.compilerOptions ??= {};
+            json.compilerOptions = {
+                ...json.compilerOptions,
+                sourceMap: false,
+            };
+            return json;
+        });
+    }
+}
+function updateCyDirTsConfigReferences(tree, projectConfig) {
+    if (!tree.exists((0, devkit_1.joinPathFragments)(projectConfig.root, 'cypress', 'tsconfig.json'))) {
+        return;
+    }
+    (0, devkit_1.updateJson)(tree, (0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.json'), (json) => {
+        json.references ??= [];
+        if (!json.references) {
+            return json;
+        }
+        const cyFile = json.references.find((p) => p.path.includes('tsconfig.cy.json'));
+        if (cyFile) {
+            json.references.splice(json.references.indexOf(cyFile), 1);
+        }
+        if (!json.references.some((r) => r.path === './cypress/tsconfig.json')) {
+            json.references.push({
+                path: './cypress/tsconfig.json',
+            });
+        }
+        return json;
+    });
+}
+exports.default = normalizeCyTsConfigNames;

package/src/migrations/update-16-4-0/tsconfig-sourcemaps.d.ts

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

package/src/migrations/update-16-4-0/tsconfig-sourcemaps.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixLegacyCypressTsconfig = void 0;
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+async function fixLegacyCypressTsconfig(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/cypress:cypress', (options, projectName, targetName, configName) => {
+        const projectConfig = projects.get(projectName);
+        if (options.testingType !== 'e2e' &&
+            projectConfig.targets[targetName]?.options?.testingType !== 'e2e') {
+            return;
+        }
+        const tsconfigToRemove = options.tsConfig ??
+            (0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.e2e.json');
+        const projectLevelConfigPath = (0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.json');
+        if (!tree.exists(projectLevelConfigPath) ||
+            !tree.exists(tsconfigToRemove)) {
+            return;
+        }
+        if (tsconfigToRemove === projectLevelConfigPath) {
+            (0, devkit_1.updateJson)(tree, projectLevelConfigPath, (json) => {
+                json.compilerOptions = {
+                    sourceMap: false,
+                    ...json.compilerOptions,
+                };
+                return json;
+            });
+        }
+        else {
+            const e2eConfig = (0, devkit_1.readJson)(tree, tsconfigToRemove);
+            (0, devkit_1.updateJson)(tree, projectLevelConfigPath, (json) => {
+                json.compilerOptions = {
+                    sourceMap: false,
+                    ...json.compilerOptions,
+                    ...e2eConfig.compilerOptions,
+                };
+                json.files = Array.from(new Set([...(json.files ?? []), ...(e2eConfig.files ?? [])]));
+                json.include = Array.from(new Set([...(json.include ?? []), ...(e2eConfig.include ?? [])]));
+                json.exclude = Array.from(new Set([...(json.exclude ?? []), ...(e2eConfig.exclude ?? [])]));
+                // these paths will always be 'unix style'
+                // and on windows relative will not work on these paths
+                const tsConfigFromProjRoot = path_1.posix.relative(projectConfig.root, tsconfigToRemove);
+                json.references = (json.references ?? []).filter(({ path }) => !path.includes(tsConfigFromProjRoot));
+                return json;
+            });
+            tree.delete(tsconfigToRemove);
+        }
+        if (configName) {
+            delete projectConfig.targets[targetName].configurations[configName]
+                .tsConfig;
+        }
+        else {
+            delete projectConfig.targets[targetName].options.tsConfig;
+        }
+        (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfig);
+    });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.fixLegacyCypressTsconfig = fixLegacyCypressTsconfig;
+exports.default = fixLegacyCypressTsconfig;