@nx/cypress 17.1.2 → 17.2.0-beta.1

package/migrations.json

@@ -47,6 +47,16 @@
       "version": "16.8.0-beta.4",
       "description": "Update to Cypress v13. Most noteable change is video recording is off by default. This migration will only update if the workspace is already on Cypress v12. https://docs.cypress.io/guides/references/migration-guide#Migrating-to-Cypress-130",
       "implementation": "./src/migrations/update-16-8-0/cypress-13"
+    },
+    "add-nx-metadata": {
+      "version": "17.2.0-beta.0",
+      "description": "Add devServerTargets into cypress.config.ts files for @nx/cypress/plugin",
+      "implementation": "./src/migrations/update-17-2-0/add-dev-server-targets-to-cypress-configs"
+    },
+    "add-nx-cypress-plugin": {
+      "version": "17.2.0-beta.0",
+      "description": "Add the @nx/cypress/plugin to nx.json plugins",
+      "implementation": "./src/migrations/update-17-2-0/add-nx-cypress-plugin"
     }
   },
   "packageJsonUpdates": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/cypress",
-  "version": "17.1.2",
+  "version": "17.2.0-beta.1",
   "private": false,
   "description": "The Nx Plugin for Cypress contains executors and generators allowing your workspace to use the powerful Cypress integration testing capabilities.",
   "repository": {
@@ -34,14 +34,14 @@
     "migrations": "./migrations.json"
   },
   "dependencies": {
+    "@nx/devkit": "17.2.0-beta.1",
+    "@nx/eslint": "17.2.0-beta.1",
+    "@nx/js": "17.2.0-beta.1",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "detect-port": "^1.5.1",
     "semver": "7.5.3",
     "tslib": "^2.3.0",
-    "@nx/devkit": "17.1.2",
-    "@nx/js": "17.1.2",
-    "@nx/eslint": "17.1.2",
-    "@nrwl/cypress": "17.1.2"
+    "@nrwl/cypress": "17.2.0-beta.1"
   },
   "peerDependencies": {
     "cypress": ">= 3 < 14"

package/plugin.d.ts

@@ -0,0 +1 @@
+export { createNodes, createDependencies } from './src/plugins/plugin';

package/plugin.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDependencies = exports.createNodes = void 0;
+var plugin_1 = require("./src/plugins/plugin");
+Object.defineProperty(exports, "createNodes", { enumerable: true, get: function () { return plugin_1.createNodes; } });
+Object.defineProperty(exports, "createDependencies", { enumerable: true, get: function () { return plugin_1.createDependencies; } });

package/plugins/cypress-preset.d.ts

@@ -30,26 +30,8 @@ export declare function nxBaseCypressPreset(pathToConfig: string, options?: {
  *   }
  * })
  *
- * @param pathToConfig will be used to construct the output paths for videos and screenshots
  */
-export declare function nxE2EPreset(pathToConfig: string, options?: NxCypressE2EPresetOptions): {
-    fileServerFolder: string;
-    supportFile: string;
-    specPattern: string;
-    fixturesFolder: string;
-    videosFolder: string;
-    screenshotsFolder: string;
-    chromeWebSecurity: boolean;
-} | {
-    setupNodeEvents(on: any): void;
-    fileServerFolder: string;
-    supportFile: string;
-    specPattern: string;
-    fixturesFolder: string;
-    videosFolder: string;
-    screenshotsFolder: string;
-    chromeWebSecurity: boolean;
-};
+export declare function nxE2EPreset(pathToConfig: string, options?: NxCypressE2EPresetOptions): any;
 export type NxCypressE2EPresetOptions = {
     bundler?: string;
     /**
@@ -58,5 +40,7 @@ export type NxCypressE2EPresetOptions = {
      * default is 'src'
      **/
     cypressDir?: string;
+    devServerTargets?: Record<string, string>;
+    ciDevServerTarget?: string;
 };
 export {};

package/plugins/cypress-preset.js

@@ -5,6 +5,8 @@ const devkit_1 = require("@nx/devkit");
 const path_1 = require("path");
 const fs_1 = require("fs");
 const preprocessor_vite_1 = require("../src/plugins/preprocessor-vite");
+const ct_helpers_1 = require("../src/utils/ct-helpers");
+const start_dev_server_1 = require("../src/utils/start-dev-server");
 function nxBaseCypressPreset(pathToConfig, options) {
     // used to set babel settings for react CT.
     process.env.NX_CYPRESS_COMPONENT_TEST =
@@ -39,25 +41,50 @@ exports.nxBaseCypressPreset = nxBaseCypressPreset;
  *   }
  * })
  *
- * @param pathToConfig will be used to construct the output paths for videos and screenshots
  */
 function nxE2EPreset(pathToConfig, options) {
     const basePath = options?.cypressDir || 'src';
-    const baseConfig = {
+    const baseConfig /** Cypress.EndToEndConfigOptions */ = {
         ...nxBaseCypressPreset(pathToConfig),
         fileServerFolder: '.',
         supportFile: `${basePath}/support/e2e.ts`,
         specPattern: `${basePath}/**/*.cy.{js,jsx,ts,tsx}`,
         fixturesFolder: `${basePath}/fixtures`,
-    };
-    if (options?.bundler === 'vite') {
-        return {
-            ...baseConfig,
-            setupNodeEvents(on) {
+        env: {
+            devServerTargets: options?.devServerTargets,
+            devServerTargetOptions: {},
+            ciDevServerTarget: options?.ciDevServerTarget,
+        },
+        async setupNodeEvents(on, config) {
+            if (options?.bundler === 'vite') {
                 on('file:preprocessor', (0, preprocessor_vite_1.default)());
-            },
-        };
-    }
+            }
+            if (!config.env.devServerTargets) {
+                return;
+            }
+            const devServerTarget = config.env.devServerTarget ?? config.env.devServerTargets['default'];
+            if (!devServerTarget) {
+                return;
+            }
+            if (!config.baseUrl && devServerTarget) {
+                const graph = await (0, devkit_1.createProjectGraphAsync)();
+                const target = (0, devkit_1.parseTargetString)(devServerTarget, graph);
+                const context = (0, ct_helpers_1.createExecutorContext)(graph, graph.nodes[target.project].data?.targets, target.project, target.target, target.configuration);
+                const devServer = (0, start_dev_server_1.startDevServer)({
+                    devServerTarget,
+                    ...config.env.devServerTargetOptions,
+                }, context);
+                on('after:run', () => {
+                    devServer.return();
+                });
+                const devServerValue = (await devServer.next()).value;
+                if (!devServerValue) {
+                    return;
+                }
+                return { ...config, baseUrl: devServerValue.baseUrl };
+            }
+        },
+    };
     return baseConfig;
 }
 exports.nxE2EPreset = nxE2EPreset;

package/src/executors/cypress/cypress.impl.js

@@ -1,19 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const devkit_1 = require("@nx/devkit");
-const executor_utils_1 = require("nx/src/command-line/run/executor-utils");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const ct_helpers_1 = require("../../utils/ct-helpers");
 const cypress_version_1 = require("../../utils/cypress-version");
-const detectPort = require("detect-port");
+const start_dev_server_1 = require("../../utils/start-dev-server");
 const Cypress = require('cypress'); // @NOTE: Importing via ES6 messes the whole test dependencies.
 async function cypressExecutor(options, context) {
     options = normalizeOptions(options, context);
     // this is used by cypress component testing presets to build the executor contexts with the correct configuration options.
     process.env.NX_CYPRESS_TARGET_CONFIGURATION = context.configurationName;
     let success;
-    for await (const devServerValues of startDevServer(options, context)) {
+    for await (const devServerValues of (0, start_dev_server_1.startDevServer)(options, context)) {
         try {
             success = await runCypress(devServerValues.baseUrl, {
                 ...options,
@@ -90,50 +89,6 @@ A generator to migrate from v8 to v10 is provided. See https://nx.dev/cypress/v1
 `);
     }
 }
-async function* startDevServer(opts, context) {
-    // no dev server, return the provisioned base url
-    if (!opts.devServerTarget || opts.skipServe) {
-        yield { baseUrl: opts.baseUrl };
-        return;
-    }
-    const parsedDevServerTarget = (0, devkit_1.parseTargetString)(opts.devServerTarget, context);
-    const [targetSupportsWatchOpt] = getValueFromSchema(context, parsedDevServerTarget, 'watch');
-    const overrides = {
-        // @NOTE: Do not forward watch option if not supported by the target dev server,
-        //  this is relevant for running Cypress against dev server target that does not support this option,
-        //  for instance @nguniversal/builders:ssr-dev-server.
-        ...(targetSupportsWatchOpt ? { watch: opts.watch } : {}),
-    };
-    if (opts.port === 'cypress-auto') {
-        const freePort = await getPortForProject(context, parsedDevServerTarget);
-        overrides['port'] = freePort;
-    }
-    else if (opts.port !== undefined) {
-        overrides['port'] = opts.port;
-        // zero is a special case that means any valid port so there is no reason to try to 'lock it'
-        if (opts.port !== 0) {
-            const didLock = attemptToLockPort(opts.port);
-            if (!didLock) {
-                devkit_1.logger.warn((0, devkit_1.stripIndents) `${opts.port} is potentially already in use by another cypress run.
-If the port is in use, try using a different port value or passing --port='cypress-auto' to find a free port.`);
-            }
-        }
-    }
-    for await (const output of await (0, devkit_1.runExecutor)(parsedDevServerTarget, overrides, context)) {
-        if (!output.success && !opts.watch)
-            throw new Error('Could not compile application files');
-        if (!opts.baseUrl &&
-            !output.baseUrl &&
-            !output.info?.baseUrl &&
-            (output.port || output.info?.port)) {
-            output.baseUrl = `http://localhost:${output.port ?? output.info?.port}`;
-        }
-        yield {
-            baseUrl: opts.baseUrl || output.baseUrl || output.info?.baseUrl,
-            portLockFilePath: overrides.port && (0, path_1.join)(__dirname, `${overrides.port}.txt`),
-        };
-    }
-}
 /**
  * @whatItDoes Initialize the Cypress test runner with the provided project configuration.
  * By default, Cypress will run tests from the CLI without the GUI and provide directly the results in the console output.
@@ -154,8 +109,14 @@ async function runCypress(baseUrl, opts) {
     if (opts.browser) {
         options.browser = opts.browser;
     }
+    options.env = {
+        devServerTarget: opts.devServerTarget,
+    };
     if (opts.env) {
-        options.env = opts.env;
+        options.env = {
+            ...options.env,
+            ...opts.env,
+        };
     }
     if (opts.spec) {
         options.spec = opts.spec;
@@ -211,110 +172,6 @@ async function runCypress(baseUrl, opts) {
      */
     return !result.totalFailed && !result.failures;
 }
-/**
- * try to find a free port for the project to run on
- * will return undefined if no port is found or the project doesn't have a port option
- **/
-async function getPortForProject(context, target, defaultPort = 4200) {
-    const fmtTarget = (0, devkit_1.targetToTargetString)(target);
-    const [hasPortOpt, schemaPortValue] = getValueFromSchema(context, target, 'port');
-    let freePort;
-    if (hasPortOpt) {
-        let normalizedPortValue;
-        if (!schemaPortValue) {
-            devkit_1.logger.info(`NX ${fmtTarget} did not have a defined port value, checking for free port with the default value of ${defaultPort}`);
-            normalizedPortValue = defaultPort;
-        }
-        else {
-            normalizedPortValue = Number(schemaPortValue);
-        }
-        if (isNaN(normalizedPortValue)) {
-            devkit_1.output.warn({
-                title: `Port Not a Number`,
-                bodyLines: [
-                    `The port value found was not a number or can't be parsed to a number`,
-                    `When reading the devServerTarget (${fmtTarget}) schema, expected ${schemaPortValue} to be a number but got NaN.`,
-                    `Nx will use the default value of ${defaultPort} instead.`,
-                    `You can manually specify a port by setting the 'port' option`,
-                ],
-            });
-            normalizedPortValue = defaultPort;
-        }
-        try {
-            let attempts = 0;
-            // make sure when this check happens in parallel,
-            // we don't let the same port be used by multiple projects
-            do {
-                freePort = await detectPort(freePort || normalizedPortValue);
-                if (attemptToLockPort(freePort)) {
-                    break;
-                }
-                attempts++;
-                // increment port in case the lock file isn't cleaned up
-                freePort++;
-            } while (attempts < 20);
-            devkit_1.logger.info(`NX Using port ${freePort} for ${fmtTarget}`);
-        }
-        catch (err) {
-            throw new Error((0, devkit_1.stripIndents) `Unable to find a free port for the dev server, ${fmtTarget}.
-You can disable auto port detection by specifing a port or not passing a value to --port`);
-        }
-    }
-    else {
-        devkit_1.output.warn({
-            title: `No Port Option Found`,
-            bodyLines: [
-                `The 'port' option is set to 'cypress-auto', but the devServerTarget (${fmtTarget}) does not have a port option.`,
-                `Because of this, Nx is unable to verify the port is free before starting the dev server.`,
-                `This might cause issues if the devServerTarget is trying to use a port that is already in use.`,
-            ],
-        });
-    }
-    return freePort;
-}
-/**
- * Check if the given target has the given property in it's options.
- * if the property is does not have a default value or is not in the actual executor options,
- * the value will be undefined even if it's in the executor schema.
- **/
-function getValueFromSchema(context, target, property) {
-    let targetOpts;
-    try {
-        targetOpts = (0, devkit_1.readTargetOptions)(target, context);
-    }
-    catch (e) {
-        throw new Error(`Unable to read the target options for  ${(0, devkit_1.targetToTargetString)(target)}.
-Are you sure this is a valid target?
-Was trying to read the target for the property: '${property}', but got the following error: 
-${e.message || e}`);
-    }
-    let targetHasOpt = Object.keys(targetOpts).includes(property);
-    if (!targetHasOpt) {
-        // NOTE: readTargetOptions doesn't apply non defaulted values, i.e. @nx/vite has a port options but is optional
-        // so we double check the schema if readTargetOptions didn't return a value for the property
-        const projectConfig = context.projectsConfigurations?.projects?.[target.project];
-        const targetConfig = projectConfig.targets[target.target];
-        const [collection, executor] = targetConfig.executor.split(':');
-        const { schema } = (0, executor_utils_1.getExecutorInformation)(collection, executor, context.root);
-        // NOTE: schema won't have a default since readTargetOptions would have
-        // already set that and this check wouldn't need to be made
-        targetHasOpt = Object.keys(schema.properties).includes(property);
-    }
-    return [targetHasOpt, targetOpts[property]];
-}
-function attemptToLockPort(port) {
-    const portLockFilePath = (0, path_1.join)(__dirname, `${port}.txt`);
-    try {
-        if ((0, fs_1.existsSync)(portLockFilePath)) {
-            return false;
-        }
-        (0, fs_1.writeFileSync)(portLockFilePath, 'locked');
-        return true;
-    }
-    catch (err) {
-        return false;
-    }
-}
 function cleanupTmpFile(path) {
     try {
         if (path && (0, fs_1.existsSync)(path)) {

package/src/generators/component-configuration/component-configuration.js

@@ -7,11 +7,17 @@ const versions_1 = require("../../utils/versions");
 const base_setup_1 = require("../base-setup/base-setup");
 async function componentConfigurationGenerator(tree, options) {
     const opts = normalizeOptions(options);
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const hasPlugin = nxJson.plugins?.some((p) => typeof p === 'string'
+        ? p === '@nx/cypress/plugin'
+        : p.plugin === '@nx/cypress/plugin');
     const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, opts.project);
     const installDepsTask = updateDeps(tree, opts);
     addProjectFiles(tree, projectConfig, opts);
-    addTargetToProject(tree, projectConfig, opts);
-    updateNxJsonConfiguration(tree);
+    if (!hasPlugin) {
+        addTargetToProject(tree, projectConfig, opts);
+    }
+    updateNxJsonConfiguration(tree, hasPlugin);
     updateTsConfigForComponentTesting(tree, projectConfig);
     if (!opts.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
@@ -67,25 +73,26 @@ function addTargetToProject(tree, projectConfig, opts) {
     };
     (0, devkit_1.updateProjectConfiguration)(tree, opts.project, projectConfig);
 }
-function updateNxJsonConfiguration(tree) {
+function updateNxJsonConfiguration(tree, hasPlugin) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
-    const cacheableOperations = nxJson.tasksRunnerOptions?.default?.options?.cacheableOperations;
-    if (cacheableOperations && !cacheableOperations.includes('component-test')) {
-        cacheableOperations.push('component-test');
+    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',
+        ]));
     }
-    nxJson.targetDefaults ??= {};
-    nxJson.targetDefaults['component-test'] ??= {};
-    nxJson.targetDefaults['component-test'].cache ??= true;
-    if (nxJson.namedInputs) {
-        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',
-            ]));
+    if (!hasPlugin) {
+        const cacheableOperations = nxJson.tasksRunnerOptions?.default?.options?.cacheableOperations;
+        if (cacheableOperations &&
+            !cacheableOperations.includes('component-test')) {
+            cacheableOperations.push('component-test');
         }
+        nxJson.targetDefaults ??= {};
+        nxJson.targetDefaults['component-test'] ??= {};
+        nxJson.targetDefaults['component-test'].cache ??= true;
         nxJson.targetDefaults['component-test'] ??= {};
         nxJson.targetDefaults['component-test'].inputs ??= [
             'default',

package/src/generators/configuration/configuration.js

@@ -17,11 +17,18 @@ async function configurationGenerator(tree, options) {
     if (!(0, cypress_version_1.installedCypressVersion)()) {
         tasks.push(await (0, init_1.default)(tree, opts));
     }
+    const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const hasPlugin = nxJson.plugins?.some((p) => typeof p === 'string'
+        ? p === '@nx/cypress/plugin'
+        : p.plugin === '@nx/cypress/plugin');
     if (opts.bundler === 'vite') {
         tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, { vite: versions_1.viteVersion }));
     }
-    await addFiles(tree, opts);
-    addTarget(tree, opts);
+    await addFiles(tree, opts, projectGraph, hasPlugin);
+    if (!hasPlugin) {
+        addTarget(tree, opts);
+    }
     const linterTask = await (0, add_linter_1.addLinterToCyProject)(tree, {
         ...opts,
         cypressDir: opts.directory,
@@ -46,16 +53,20 @@ Rename or remove the existing e2e target.`);
 In this case you need to provide a devServerTarget,'<projectName>:<targetName>[:<configName>]', or a baseUrl option`);
     }
     options.directory ??= 'src';
+    const devServerTarget = options.devServerTarget ??
+        (projectConfig.targets.serve ? `${options.project}:serve` : undefined);
+    if (!options.baseUrl && !devServerTarget) {
+        throw new Error('Either baseUrl or devServerTarget must be provided');
+    }
     return {
         ...options,
         bundler: options.bundler ?? 'webpack',
         rootProject: options.rootProject ?? projectConfig.root === '.',
         linter: options.linter ?? eslint_1.Linter.EsLint,
-        devServerTarget: options.devServerTarget ??
-            (projectConfig.targets.serve ? `${options.project}:serve` : undefined),
+        devServerTarget,
     };
 }
-async function addFiles(tree, options) {
+async function addFiles(tree, options, projectGraph, hasPlugin) {
     const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
     const cyVersion = (0, cypress_version_1.installedCypressVersion)();
     const filesToUse = cyVersion && cyVersion < 10 ? 'v9' : 'v10';
@@ -84,10 +95,29 @@ async function addFiles(tree, options) {
             jsx: options.jsx,
         });
         const cyFile = (0, devkit_1.joinPathFragments)(projectConfig.root, 'cypress.config.ts');
+        let devServerTargets;
+        let ciDevServerTarget;
+        if (hasPlugin && !options.baseUrl && options.devServerTarget) {
+            devServerTargets = {};
+            devServerTargets.default = options.devServerTarget;
+            const parsedTarget = (0, devkit_1.parseTargetString)(options.devServerTarget, projectGraph);
+            const devServerProjectConfig = (0, devkit_1.readProjectConfiguration)(tree, parsedTarget.project);
+            // Add production e2e target if serve target is found
+            if (parsedTarget.configuration !== 'production' &&
+                devServerProjectConfig.targets[parsedTarget.target]?.configurations?.['production']) {
+                devServerTargets.production = `${parsedTarget.project}:${parsedTarget.target}:production`;
+            }
+            // Add ci/static e2e target if serve target is found
+            if (devServerProjectConfig.targets?.['serve-static']) {
+                ciDevServerTarget = `${parsedTarget.project}:serve-static`;
+            }
+        }
         const updatedCyConfig = await (0, config_1.addDefaultE2EConfig)(tree.read(cyFile, 'utf-8'), {
-            directory: options.directory,
-            bundler: options.bundler,
-        });
+            cypressDir: options.directory,
+            bundler: options.bundler === 'vite' ? 'vite' : undefined,
+            devServerTargets,
+            ciDevServerTarget: ciDevServerTarget,
+        }, options.baseUrl);
         tree.write(cyFile, updatedCyConfig);
     }
     if (cyVersion &&
@@ -148,9 +178,6 @@ function addTarget(tree, opts) {
             };
         }
     }
-    else {
-        throw new Error('Either baseUrl or devServerTarget must be provided');
-    }
     (0, devkit_1.updateProjectConfiguration)(tree, opts.project, projectConfig);
 }
 exports.default = configurationGenerator;

package/src/generators/init/init.js

@@ -13,6 +13,7 @@ function setupE2ETargetDefaults(tree) {
     nxJson.targetDefaults ??= {};
     const productionFileSet = !!nxJson.namedInputs?.production;
     nxJson.targetDefaults.e2e ??= {};
+    nxJson.targetDefaults.e2e.cache ??= true;
     nxJson.targetDefaults.e2e.inputs ??= [
         'default',
         productionFileSet ? '^production' : '^default',
@@ -27,13 +28,52 @@ function updateDependencies(tree) {
         '@types/node': versions_1.typesNodeVersion,
     });
 }
+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);
+}
+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) {
-    setupE2ETargetDefaults(tree);
+    const addPlugins = process.env.NX_PCV3 === 'true';
+    updateProductionFileset(tree);
+    if (!addPlugins) {
+        setupE2ETargetDefaults(tree);
+    }
     const tasks = [];
     tasks.push(await (0, js_1.initGenerator)(tree, {
         ...options,
         skipFormat: true,
     }));
+    if (addPlugins) {
+        addPlugin(tree);
+    }
     if (!options.skipPackageJson) {
         tasks.push(updateDependencies(tree));
     }

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

@@ -2,4 +2,6 @@ export interface Schema {
   skipPackageJson?: boolean;
 
   skipFormat?: boolean;
+
+  addPlugins?: boolean;
 }

package/src/migrations/update-17-2-0/add-dev-server-targets-to-cypress-configs.d.ts

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

package/src/migrations/update-17-2-0/add-dev-server-targets-to-cypress-configs.js

@@ -0,0 +1,125 @@
+"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");
+const typescript_1 = require("typescript");
+function addDevServerTargets(tree, cypressConfig, devServerTargets) {
+    const contents = tree.read(cypressConfig, 'utf-8');
+    const sourceFile = (0, typescript_1.createSourceFile)(cypressConfig, contents, typescript_1.ScriptTarget.ESNext);
+    const ciDevServerTarget = devServerTargets.ci;
+    delete devServerTargets.ci;
+    const changes = [];
+    const visit = (node) => {
+        if ((0, typescript_1.isCallExpression)(node) &&
+            (0, typescript_1.isIdentifier)(node.expression) &&
+            node.expression.text === 'nxE2EPreset') {
+            const argumentContents = ', ' +
+                JSON.stringify({
+                    devServerTargets,
+                    ciDevServerTarget,
+                });
+            if (node.arguments.length === 1) {
+                changes.push({
+                    type: devkit_1.ChangeType.Insert,
+                    index: node.arguments[0].getEnd(),
+                    text: argumentContents,
+                });
+            }
+            else {
+                const lastArgument = node.arguments[node.arguments.length - 1];
+                if ((0, typescript_1.isObjectLiteralExpression)(lastArgument)) {
+                    const lastProperty = lastArgument.properties[lastArgument.properties.length - 1];
+                    const trailingComma = lastArgument.properties.hasTrailingComma;
+                    changes.push({
+                        type: devkit_1.ChangeType.Insert,
+                        index: lastProperty.getEnd(),
+                        text: (trailingComma ? '' : ', ') +
+                            'devServerTargets: ' +
+                            JSON.stringify(devServerTargets) +
+                            (ciDevServerTarget
+                                ? `, ciDevServerTarget: '${ciDevServerTarget}'`
+                                : ''),
+                    });
+                }
+            }
+        }
+        else {
+            (0, typescript_1.forEachChild)(node, visit);
+        }
+    };
+    (0, typescript_1.forEachChild)(sourceFile, visit);
+    tree.write(cypressConfig, (0, devkit_1.applyChangesToString)(contents, changes));
+}
+async function update(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    const devServerTargetsMap = new Map();
+    (0, executor_options_utils_1.forEachExecutorOptionsInGraph)(graph, '@nx/cypress:cypress', (options, project, target, configuration) => {
+        const targetConfig = projects.get(project).targets?.[target];
+        if (!targetConfig) {
+            return;
+        }
+        const cypressConfig = options.cypressConfig ?? targetConfig.options?.cypressConfig;
+        if (!cypressConfig) {
+            return;
+        }
+        const devServerTargets = {};
+        devServerTargets.default = targetConfig.options?.devServerTarget;
+        for (const [configuration, configurationOptions] of Object.entries(targetConfig.configurations ?? {})) {
+            devServerTargets[configuration] = configurationOptions.devServerTarget;
+        }
+        devServerTargetsMap.set(cypressConfig, devServerTargets);
+    });
+    for (const [cypressConfig, devServerTargets] of devServerTargetsMap) {
+        addDevServerTargets(tree, cypressConfig, devServerTargets);
+    }
+    // const configFiles = glob(tree, [createNodes[0]]);
+    //
+    // const proj = Object.fromEntries(getProjects(tree).entries());
+    //
+    // const rootMappings = createProjectRootMappingsFromProjectConfigurations(proj);
+    //
+    // for (const configFile of configFiles) {
+    //   const siblings = tree.children(dirname(configFile));
+    //   if (!siblings.includes('project.json')) {
+    //     continue;
+    //   }
+    //
+    //   const projectName = findProjectForPath(configFile, rootMappings);
+    //   const projectConfig = readProjectConfiguration(tree, projectName);
+    //   const e2eTarget: TargetConfiguration<CypressExecutorOptions> =
+    //     projectConfig.targets?.e2e;
+    //
+    //   if (!e2eTarget || e2eTarget.executor !== '@nx/cypress:cypress') {
+    //     continue;
+    //   }
+    //
+    //   nxMetadata.devServerTarget = e2eTarget.options?.devServerTarget;
+    //   nxMetadata.productionDevServerTarget =
+    //     e2eTarget.configurations?.production?.devServerTarget;
+    //   nxMetadata.ciDevServerTarget =
+    //     e2eTarget.configurations?.ci?.devServerTarget;
+    //
+    //   if (Object.values(nxMetadata).filter((v) => !!v).length > 0) {
+    //     let contents = tree.read(configFile, 'utf-8');
+    //
+    //     contents =
+    //       `import type { NxCypressMetadata } from '@nx/cypress/plugin';\n` +
+    //       contents +
+    //       `
+    //
+    //     /**
+    //      * This is metadata for the @nx/cypress/plugin
+    //      */
+    //     export const nx: NxCypressMetadata = ${JSON.stringify(
+    //       nxMetadata,
+    //       null,
+    //       2
+    //     )};`;
+    //
+    //     tree.write(configFile, contents);
+    //   }
+    // }
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = update;

package/src/migrations/update-17-2-0/add-nx-cypress-plugin.d.ts

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

package/src/migrations/update-17-2-0/add-nx-cypress-plugin.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const plugin_1 = require("../../plugins/plugin");
+const find_project_for_path_1 = require("nx/src/project-graph/utils/find-project-for-path");
+const replace_project_configuration_with_plugin_1 = require("@nx/devkit/src/utils/replace-project-configuration-with-plugin");
+async function update(tree) {
+    const proj = Object.fromEntries((0, devkit_1.getProjects)(tree).entries());
+    const rootMappings = (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(proj);
+    await (0, replace_project_configuration_with_plugin_1.replaceProjectConfigurationsWithPlugin)(tree, rootMappings, '@nx/cypress/plugin', plugin_1.createNodes, {
+        targetName: 'e2e',
+        componentTestingTargetName: 'component-test',
+    });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = update;

package/src/plugins/plugin.d.ts

@@ -0,0 +1,8 @@
+import { CreateDependencies, CreateNodes } from '@nx/devkit';
+export interface CypressPluginOptions {
+    ciTargetName?: string;
+    targetName?: string;
+    componentTestingTargetName?: string;
+}
+export declare const createDependencies: CreateDependencies;
+export declare const createNodes: CreateNodes<CypressPluginOptions>;

package/src/plugins/plugin.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.createDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const internal_1 = require("@nx/js/src/internal");
+const js_1 = require("@nx/js");
+const project_configuration_utils_1 = require("nx/src/project-graph/utils/project-configuration-utils");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const fs_1 = require("fs");
+const workspace_context_1 = require("nx/src/utils/workspace-context");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const cachePath = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'cypress.hash');
+const targetsCache = (0, fs_1.existsSync)(cachePath) ? readTargetsCache() : {};
+const calculatedTargets = {};
+function readTargetsCache() {
+    return (0, devkit_1.readJsonFile)(cachePath);
+}
+function writeTargetsToCache(targets) {
+    (0, devkit_1.writeJsonFile)(cachePath, targets);
+}
+const createDependencies = () => {
+    writeTargetsToCache(calculatedTargets);
+    return [];
+};
+exports.createDependencies = createDependencies;
+exports.createNodes = [
+    '**/cypress.config.{js,ts,mjs,mts,cjs,cts}',
+    (configFilePath, options, context) => {
+        options = normalizeOptions(options);
+        const projectRoot = (0, path_1.dirname)(configFilePath);
+        // Do not create a project if package.json and project.json isn't there.
+        const siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
+        if (!siblingFiles.includes('package.json') &&
+            !siblingFiles.includes('project.json')) {
+            return {};
+        }
+        const hash = (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context);
+        const targets = targetsCache[hash]
+            ? targetsCache[hash]
+            : buildCypressTargets(configFilePath, projectRoot, options, context);
+        calculatedTargets[hash] = targets;
+        return {
+            projects: {
+                [projectRoot]: {
+                    projectType: 'application',
+                    targets,
+                },
+            },
+        };
+    },
+];
+function getOutputs(projectRoot, cypressConfig, testingType) {
+    function getOutput(path) {
+        if (path.startsWith('..')) {
+            return (0, path_1.join)('{workspaceRoot}', (0, path_1.join)(projectRoot, path));
+        }
+        else {
+            return (0, path_1.join)('{projectRoot}', path);
+        }
+    }
+    const { screenshotsFolder, videosFolder, e2e, component } = cypressConfig;
+    const outputs = ['{options.videosFolder}', '{options.screenshotsFolder}'];
+    if (videosFolder) {
+        outputs.push(getOutput(videosFolder));
+    }
+    if (screenshotsFolder) {
+        outputs.push(getOutput(screenshotsFolder));
+    }
+    switch (testingType) {
+        case 'e2e': {
+            if (e2e.videosFolder) {
+                outputs.push(getOutput(e2e.videosFolder));
+            }
+            if (e2e.screenshotsFolder) {
+                outputs.push(getOutput(e2e.screenshotsFolder));
+            }
+            break;
+        }
+        case 'component': {
+            if (component.videosFolder) {
+                outputs.push(getOutput(component.videosFolder));
+            }
+            if (component.screenshotsFolder) {
+                outputs.push(getOutput(component.screenshotsFolder));
+            }
+            break;
+        }
+    }
+    return outputs;
+}
+function buildCypressTargets(configFilePath, projectRoot, options, context) {
+    const cypressConfig = getCypressConfig(configFilePath, context);
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const baseTargetConfig = {
+        executor: '@nx/cypress:cypress',
+        options: {
+            cypressConfig: configFilePath,
+        },
+    };
+    const targets = {};
+    if ('e2e' in cypressConfig) {
+        const e2eTargetDefaults = (0, project_configuration_utils_1.readTargetDefaultsForTarget)(options.targetName, context.nxJsonConfiguration.targetDefaults, '@nx/cypress:cypress');
+        targets[options.targetName] = {
+            ...baseTargetConfig,
+            options: {
+                ...baseTargetConfig.options,
+                testingType: 'e2e',
+            },
+        };
+        if (e2eTargetDefaults?.cache === undefined) {
+            targets[options.targetName].cache = true;
+        }
+        if (e2eTargetDefaults?.inputs === undefined) {
+            targets[options.targetName].inputs =
+                'production' in namedInputs
+                    ? ['default', '^production']
+                    : ['default', '^default'];
+        }
+        if (e2eTargetDefaults?.outputs === undefined) {
+            targets[options.targetName].outputs = getOutputs(projectRoot, cypressConfig, 'e2e');
+        }
+        const cypressEnv = {
+            ...cypressConfig.env,
+            ...cypressConfig.e2e?.env,
+        };
+        const devServerTargets = cypressEnv?.devServerTargets;
+        if (devServerTargets?.default) {
+            targets[options.targetName].options.devServerTarget =
+                devServerTargets.default;
+            delete devServerTargets.default;
+        }
+        if (Object.keys(devServerTargets ?? {}).length > 0) {
+            targets[options.targetName].configurations ??= {};
+            for (const [configuration, devServerTarget] of Object.entries(devServerTargets ?? {})) {
+                targets[options.targetName].configurations[configuration] = {
+                    devServerTarget,
+                };
+            }
+        }
+        const ciDevServerTarget = cypressEnv?.ciDevServerTarget;
+        if (ciDevServerTarget) {
+            const specPatterns = Array.isArray(cypressConfig.e2e.specPattern)
+                ? cypressConfig.e2e.specPattern.map((p) => (0, path_1.join)(projectRoot, p))
+                : [(0, path_1.join)(projectRoot, cypressConfig.e2e.specPattern)];
+            const excludeSpecPatterns = !cypressConfig.e2e
+                .excludeSpecPattern
+                ? cypressConfig.e2e.excludeSpecPattern
+                : Array.isArray(cypressConfig.e2e.excludeSpecPattern)
+                    ? cypressConfig.e2e.excludeSpecPattern.map((p) => (0, path_1.join)(projectRoot, p))
+                    : [(0, path_1.join)(projectRoot, cypressConfig.e2e.excludeSpecPattern)];
+            const specFiles = (0, workspace_context_1.globWithWorkspaceContext)(context.workspaceRoot, specPatterns, excludeSpecPatterns);
+            const dependsOn = [];
+            const outputs = getOutputs(projectRoot, cypressConfig, 'e2e');
+            const inputs = 'production' in namedInputs
+                ? ['default', '^production']
+                : ['default', '^default'];
+            for (const file of specFiles) {
+                const targetName = options.ciTargetName + '--' + file;
+                targets[targetName] = {
+                    ...targets[options.targetName],
+                    outputs,
+                    inputs,
+                    cache: true,
+                    configurations: undefined,
+                    options: {
+                        ...targets[options.targetName].options,
+                        devServerTarget: ciDevServerTarget,
+                        spec: file,
+                    },
+                };
+                dependsOn.push({
+                    target: targetName,
+                    projects: 'self',
+                    params: 'forward',
+                });
+            }
+            targets[options.ciTargetName] ??= {};
+            targets[options.ciTargetName] = {
+                executor: 'nx:noop',
+                cache: true,
+                inputs,
+                outputs,
+                dependsOn,
+            };
+        }
+    }
+    if ('component' in cypressConfig) {
+        const componentTestingTargetDefaults = (0, project_configuration_utils_1.readTargetDefaultsForTarget)(options.componentTestingTargetName, context.nxJsonConfiguration.targetDefaults, '@nx/cypress:cypress');
+        // This will not override the e2e target if it is the same
+        targets[options.componentTestingTargetName] ??= {
+            ...baseTargetConfig,
+            options: {
+                ...baseTargetConfig.options,
+                testingType: 'component',
+            },
+        };
+        if (componentTestingTargetDefaults?.cache === undefined) {
+            targets[options.componentTestingTargetName].cache = true;
+        }
+        if (componentTestingTargetDefaults?.inputs === undefined) {
+            targets[options.componentTestingTargetName].inputs =
+                'production' in namedInputs
+                    ? ['default', '^production']
+                    : ['default', '^default'];
+        }
+        if (componentTestingTargetDefaults?.outputs === undefined) {
+            targets[options.componentTestingTargetName].outputs = getOutputs(projectRoot, cypressConfig, 'component');
+        }
+    }
+    return targets;
+}
+function getCypressConfig(configFilePath, context) {
+    const resolvedPath = (0, path_1.join)(context.workspaceRoot, configFilePath);
+    let module;
+    if (['.ts', '.mts', '.cts'].includes((0, path_1.extname)(configFilePath))) {
+        const tsConfigPath = (0, js_1.getRootTsConfigPath)();
+        if (tsConfigPath) {
+            const unregisterTsProject = (0, internal_1.registerTsProject)(tsConfigPath);
+            try {
+                module = require(resolvedPath);
+            }
+            finally {
+                unregisterTsProject();
+            }
+        }
+        else {
+            module = require(resolvedPath);
+        }
+    }
+    else {
+        module = require(resolvedPath);
+    }
+    return module.default ?? module;
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.targetName ??= 'e2e';
+    options.componentTestingTargetName ??= 'component-test';
+    options.ciTargetName ??= 'e2e-ci';
+    return options;
+}

package/src/utils/config.d.ts

@@ -1,7 +1,5 @@
-export declare function addDefaultE2EConfig(cyConfigContents: string, options: {
-    directory: string;
-    bundler?: string;
-}): Promise<string>;
+import { NxCypressE2EPresetOptions } from '../../plugins/cypress-preset';
+export declare function addDefaultE2EConfig(cyConfigContents: string, options: NxCypressE2EPresetOptions, baseUrl: string): Promise<string>;
 /**
  * Adds the nxComponentTestingPreset to the cypress config file
  * Make sure after calling this the correct import statement is addeda

package/src/utils/config.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addMountDefinition = exports.addDefaultCTConfig = exports.addDefaultE2EConfig = void 0;
 const TS_QUERY_EXPORT_CONFIG_PREFIX = ':matches(ExportAssignment, BinaryExpression:has(Identifier[name="module"]):has(Identifier[name="exports"]))';
-async function addDefaultE2EConfig(cyConfigContents, options) {
+async function addDefaultE2EConfig(cyConfigContents, options, baseUrl) {
     if (!cyConfigContents) {
         throw new Error('The passed in cypress config file is empty!');
     }
@@ -10,21 +10,22 @@ async function addDefaultE2EConfig(cyConfigContents, options) {
     const testingTypeConfig = tsquery.query(cyConfigContents, `${TS_QUERY_EXPORT_CONFIG_PREFIX} PropertyAssignment:has(Identifier[name="e2e"])`);
     let updatedConfigContents = cyConfigContents;
     if (testingTypeConfig.length === 0) {
-        const configValue = options.bundler === 'vite'
-            ? `nxE2EPreset(__filename, { cypressDir: '${options.directory}', bundler: 'vite' })`
-            : `nxE2EPreset(__filename, { cypressDir: '${options.directory}' })`;
+        const configValue = `nxE2EPreset(__filename, ${JSON.stringify(options)})`;
         updatedConfigContents = tsquery.replace(cyConfigContents, `${TS_QUERY_EXPORT_CONFIG_PREFIX} ObjectLiteralExpression:first-child`, (node) => {
+            let baseUrlContents = baseUrl ? `,\nbaseUrl: '${baseUrl}'` : '';
             if (node.properties.length > 0) {
                 return `{
   ${node.properties.map((p) => p.getText()).join(',\n')},
-  e2e: ${configValue} 
+  e2e: { ...${configValue}${baseUrlContents} } 
 }`;
             }
             return `{
-  e2e: ${configValue}
+  e2e: { ...${configValue}${baseUrlContents} }
 }`;
         });
-        updatedConfigContents = `import { nxE2EPreset } from '@nx/cypress/plugins/cypress-preset';\n${updatedConfigContents}`;
+        return `import { nxE2EPreset } from '@nx/cypress/plugins/cypress-preset';
+    
+    ${updatedConfigContents}`;
     }
     return updatedConfigContents;
 }

package/src/utils/start-dev-server.d.ts

@@ -0,0 +1,9 @@
+import { ExecutorContext } from '@nx/devkit';
+import { CypressExecutorOptions } from '../executors/cypress/cypress.impl';
+export declare function startDevServer(opts: Omit<CypressExecutorOptions, 'cypressConfig'>, context: ExecutorContext): AsyncGenerator<{
+    baseUrl: any;
+    portLockFilePath?: undefined;
+} | {
+    baseUrl: any;
+    portLockFilePath: string;
+}, void, unknown>;

package/src/utils/start-dev-server.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDevServer = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const detectPort = require("detect-port");
+const executor_utils_1 = require("nx/src/command-line/run/executor-utils");
+const fs_1 = require("fs");
+async function* startDevServer(opts, context) {
+    // no dev server, return the provisioned base url
+    if (!opts.devServerTarget || opts.skipServe) {
+        yield { baseUrl: opts.baseUrl };
+        return;
+    }
+    const parsedDevServerTarget = (0, devkit_1.parseTargetString)(opts.devServerTarget, context);
+    const [targetSupportsWatchOpt] = getValueFromSchema(context, parsedDevServerTarget, 'watch');
+    const overrides = {
+        // @NOTE: Do not forward watch option if not supported by the target dev server,
+        //  this is relevant for running Cypress against dev server target that does not support this option,
+        //  for instance @nguniversal/builders:ssr-dev-server.
+        ...(targetSupportsWatchOpt ? { watch: opts.watch } : {}),
+    };
+    if (opts.port === 'cypress-auto') {
+        const freePort = await getPortForProject(context, parsedDevServerTarget);
+        overrides['port'] = freePort;
+    }
+    else if (opts.port !== undefined) {
+        overrides['port'] = opts.port;
+        // zero is a special case that means any valid port so there is no reason to try to 'lock it'
+        if (opts.port !== 0) {
+            const didLock = attemptToLockPort(opts.port);
+            if (!didLock) {
+                devkit_1.logger.warn((0, devkit_1.stripIndents) `${opts.port} is potentially already in use by another cypress run.
+If the port is in use, try using a different port value or passing --port='cypress-auto' to find a free port.`);
+            }
+        }
+    }
+    for await (const output of await (0, devkit_1.runExecutor)(parsedDevServerTarget, overrides, context)) {
+        if (!output.success && !opts.watch)
+            throw new Error('Could not compile application files');
+        if (!opts.baseUrl &&
+            !output.baseUrl &&
+            !output.info?.baseUrl &&
+            (output.port || output.info?.port)) {
+            output.baseUrl = `http://localhost:${output.info.port}`;
+        }
+        yield {
+            baseUrl: opts.baseUrl || output.baseUrl || output.info?.baseUrl,
+            portLockFilePath: overrides.port && (0, path_1.join)(__dirname, `${overrides.port}.txt`),
+        };
+    }
+}
+exports.startDevServer = startDevServer;
+/**
+ * try to find a free port for the project to run on
+ * will return undefined if no port is found or the project doesn't have a port option
+ **/
+async function getPortForProject(context, target, defaultPort = 4200) {
+    const fmtTarget = (0, devkit_1.targetToTargetString)(target);
+    const [hasPortOpt, schemaPortValue] = getValueFromSchema(context, target, 'port');
+    let freePort;
+    if (hasPortOpt) {
+        let normalizedPortValue;
+        if (!schemaPortValue) {
+            devkit_1.logger.info(`NX ${fmtTarget} did not have a defined port value, checking for free port with the default value of ${defaultPort}`);
+            normalizedPortValue = defaultPort;
+        }
+        else {
+            normalizedPortValue = Number(schemaPortValue);
+        }
+        if (isNaN(normalizedPortValue)) {
+            devkit_1.output.warn({
+                title: `Port Not a Number`,
+                bodyLines: [
+                    `The port value found was not a number or can't be parsed to a number`,
+                    `When reading the devServerTarget (${fmtTarget}) schema, expected ${schemaPortValue} to be a number but got NaN.`,
+                    `Nx will use the default value of ${defaultPort} instead.`,
+                    `You can manually specify a port by setting the 'port' option`,
+                ],
+            });
+            normalizedPortValue = defaultPort;
+        }
+        try {
+            let attempts = 0;
+            // make sure when this check happens in parallel,
+            // we don't let the same port be used by multiple projects
+            do {
+                freePort = await detectPort(freePort || normalizedPortValue);
+                if (attemptToLockPort(freePort)) {
+                    break;
+                }
+                attempts++;
+                // increment port in case the lock file isn't cleaned up
+                freePort++;
+            } while (attempts < 20);
+            devkit_1.logger.info(`NX Using port ${freePort} for ${fmtTarget}`);
+        }
+        catch (err) {
+            throw new Error((0, devkit_1.stripIndents) `Unable to find a free port for the dev server, ${fmtTarget}.
+You can disable auto port detection by specifing a port or not passing a value to --port`);
+        }
+    }
+    else {
+        devkit_1.output.warn({
+            title: `No Port Option Found`,
+            bodyLines: [
+                `The 'port' option is set to 'cypress-auto', but the devServerTarget (${fmtTarget}) does not have a port option.`,
+                `Because of this, Nx is unable to verify the port is free before starting the dev server.`,
+                `This might cause issues if the devServerTarget is trying to use a port that is already in use.`,
+            ],
+        });
+    }
+    return freePort;
+}
+/**
+ * Check if the given target has the given property in it's options.
+ * if the property is does not have a default value or is not in the actual executor options,
+ * the value will be undefined even if it's in the executor schema.
+ **/
+function getValueFromSchema(context, target, property) {
+    let targetOpts;
+    try {
+        targetOpts = (0, devkit_1.readTargetOptions)(target, context);
+    }
+    catch (e) {
+        throw new Error(`Unable to read the target options for  ${(0, devkit_1.targetToTargetString)(target)}.
+Are you sure this is a valid target?
+Was trying to read the target for the property: '${property}', but got the following error: 
+${e.message || e}`);
+    }
+    let targetHasOpt = Object.keys(targetOpts).includes(property);
+    if (!targetHasOpt) {
+        // NOTE: readTargetOptions doesn't apply non defaulted values, i.e. @nx/vite has a port options but is optional
+        // so we double check the schema if readTargetOptions didn't return a value for the property
+        const projectConfig = context.projectsConfigurations?.projects?.[target.project];
+        const targetConfig = projectConfig.targets[target.target];
+        const [collection, executor] = targetConfig.executor.split(':');
+        const { schema } = (0, executor_utils_1.getExecutorInformation)(collection, executor, context.root, context.projectsConfigurations.projects);
+        // NOTE: schema won't have a default since readTargetOptions would have
+        // already set that and this check wouldn't need to be made
+        targetHasOpt = Object.keys(schema.properties).includes(property);
+    }
+    return [targetHasOpt, targetOpts[property]];
+}
+function attemptToLockPort(port) {
+    const portLockFilePath = (0, path_1.join)(__dirname, `${port}.txt`);
+    try {
+        if ((0, fs_1.existsSync)(portLockFilePath)) {
+            return false;
+        }
+        (0, fs_1.writeFileSync)(portLockFilePath, 'locked');
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}