@nx/cypress 17.0.3 → 17.0.4

package/src/generators/init/init.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cypressInitGenerator = void 0;
+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");
-const js_1 = require("@nx/js");
 function setupE2ETargetDefaults(tree) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
     if (!nxJson.namedInputs) {
@@ -13,31 +14,86 @@ 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',
     ];
     (0, devkit_1.updateNxJson)(tree, nxJson);
 }
-function updateDependencies(tree) {
-    (0, devkit_1.removeDependenciesFromPackageJson)(tree, ['@nx/cypress'], []);
-    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+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,
-        '@types/node': versions_1.typesNodeVersion,
+    }, 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',
+            ciTargetName: 'e2e-ci',
+            openTargetName: 'open-cypress',
+        },
     });
+    (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) {
-    setupE2ETargetDefaults(tree);
-    const tasks = [];
-    tasks.push(await (0, js_1.initGenerator)(tree, {
-        ...options,
-        skipFormat: true,
-    }));
+    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) {
-        tasks.push(updateDependencies(tree));
+        installTask = updateDependencies(tree, options);
     }
-    return (0, devkit_1.runTasksInSerial)(...tasks);
+    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.cypressInitGenerator = cypressInitGenerator;
+exports.cypressInitGeneratorInternal = cypressInitGeneratorInternal;
 exports.default = cypressInitGenerator;

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

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

package/src/generators/init/schema.json

@@ -1,16 +1,34 @@
 {
-  "$schema": "http://json-schema.org/schema",
+  "$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/schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema",
+  "$schema": "https://json-schema.org/schema",
   "$id": "NxCypressMigrateTo11",
   "cli": "nx",
   "title": "Migrate e2e project to Cypress 11",

package/src/migrations/update-18-1-0/update-cypress-version-13-6-6.d.ts

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

package/src/migrations/update-18-1-0/update-cypress-version-13-6-6.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const cypress_version_1 = require("../../utils/cypress-version");
+async function default_1(tree) {
+    if ((0, cypress_version_1.installedCypressVersion)() < 13) {
+        return;
+    }
+    (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { cypress: '^13.6.6' });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;

package/src/plugins/plugin.d.ts

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

package/src/plugins/plugin.js

@@ -0,0 +1,215 @@
+"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 js_1 = require("@nx/js");
+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 constants_1 = require("../utils/constants");
+const config_utils_1 = require("@nx/devkit/src/utils/config-utils");
+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,cjs}',
+    async (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, [
+            (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot)),
+        ]);
+        const { targets, targetGroups } = targetsCache[hash]
+            ? targetsCache[hash]
+            : await buildCypressTargets(configFilePath, projectRoot, options, context);
+        calculatedTargets[hash] = { targets, targetGroups };
+        const project = {
+            projectType: 'application',
+            targets,
+            metadata: {
+                technologies: ['cypress'],
+            },
+        };
+        if (targetGroups) {
+            project.metadata.targetGroups = targetGroups;
+        }
+        return {
+            projects: {
+                [projectRoot]: project,
+            },
+        };
+    },
+];
+function getOutputs(projectRoot, cypressConfig, testingType) {
+    function getOutput(path) {
+        if (path.startsWith('..')) {
+            return (0, devkit_1.joinPathFragments)('{workspaceRoot}', projectRoot, path);
+        }
+        else {
+            return (0, devkit_1.joinPathFragments)('{projectRoot}', path);
+        }
+    }
+    const { screenshotsFolder, videosFolder, e2e, component } = cypressConfig;
+    const outputs = [];
+    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;
+}
+async function buildCypressTargets(configFilePath, projectRoot, options, context) {
+    const cypressConfig = await (0, config_utils_1.loadConfigFile)((0, path_1.join)(context.workspaceRoot, configFilePath));
+    const pluginPresetOptions = {
+        ...cypressConfig.e2e?.[constants_1.NX_PLUGIN_OPTIONS],
+        ...cypressConfig.env,
+        ...cypressConfig.e2e?.env,
+    };
+    const webServerCommands = pluginPresetOptions?.webServerCommands;
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const targets = {};
+    let targetGroups;
+    if ('e2e' in cypressConfig) {
+        targets[options.targetName] = {
+            command: `cypress run`,
+            options: { cwd: projectRoot },
+            cache: true,
+            inputs: getInputs(namedInputs),
+            outputs: getOutputs(projectRoot, cypressConfig, 'e2e'),
+        };
+        if (webServerCommands?.default) {
+            delete webServerCommands.default;
+        }
+        if (Object.keys(webServerCommands ?? {}).length > 0) {
+            targets[options.targetName].configurations ??= {};
+            for (const [configuration, webServerCommand] of Object.entries(webServerCommands ?? {})) {
+                targets[options.targetName].configurations[configuration] = {
+                    command: `cypress run --env webServerCommand="${webServerCommand}"`,
+                };
+            }
+        }
+        const ciWebServerCommand = pluginPresetOptions?.ciWebServerCommand;
+        if (ciWebServerCommand) {
+            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 = getInputs(namedInputs);
+            const groupName = 'E2E (CI)';
+            targetGroups = { [groupName]: [] };
+            const ciTargetGroup = targetGroups[groupName];
+            for (const file of specFiles) {
+                const relativeSpecFilePath = (0, devkit_1.normalizePath)((0, path_1.relative)(projectRoot, file));
+                const targetName = options.ciTargetName + '--' + relativeSpecFilePath;
+                ciTargetGroup.push(targetName);
+                targets[targetName] = {
+                    outputs,
+                    inputs,
+                    cache: true,
+                    command: `cypress run --env webServerCommand="${ciWebServerCommand}" --spec ${relativeSpecFilePath}`,
+                    options: {
+                        cwd: projectRoot,
+                    },
+                };
+                dependsOn.push({
+                    target: targetName,
+                    projects: 'self',
+                    params: 'forward',
+                });
+            }
+            targets[options.ciTargetName] = {
+                executor: 'nx:noop',
+                cache: true,
+                inputs,
+                outputs,
+                dependsOn,
+            };
+            ciTargetGroup.push(options.ciTargetName);
+        }
+        else {
+            targetGroups = null;
+        }
+    }
+    if ('component' in cypressConfig) {
+        // This will not override the e2e target if it is the same
+        targets[options.componentTestingTargetName] ??= {
+            command: `cypress run --component`,
+            options: { cwd: projectRoot },
+            cache: true,
+            inputs: getInputs(namedInputs),
+            outputs: getOutputs(projectRoot, cypressConfig, 'component'),
+        };
+    }
+    targets[options.openTargetName] = {
+        command: `cypress open`,
+        options: { cwd: projectRoot },
+    };
+    return { targets, targetGroups };
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.targetName ??= 'e2e';
+    options.openTargetName ??= 'open-cypress';
+    options.componentTestingTargetName ??= 'component-test';
+    options.ciTargetName ??= 'e2e-ci';
+    return options;
+}
+function getInputs(namedInputs) {
+    return [
+        ...('production' in namedInputs
+            ? ['default', '^production']
+            : ['default', '^default']),
+        {
+            externalDependencies: ['cypress'],
+        },
+    ];
+}

package/src/utils/add-linter.d.ts

@@ -17,5 +17,6 @@ export interface CyLinterOptions {
      * This is useful when adding linting to a brand new project vs an existing one
      **/
     overwriteExisting?: boolean;
+    addPlugin?: boolean;
 }
 export declare function addLinterToCyProject(tree: Tree, options: CyLinterOptions): Promise<() => void>;

package/src/utils/add-linter.js

@@ -20,17 +20,16 @@ async function addLinterToCyProject(tree, options) {
             linter: options.linter,
             skipFormat: true,
             tsConfigPaths: [(0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.json')],
-            eslintFilePatterns: [
-                `${projectConfig.root}/**/*.${options.js ? 'js' : '{js,ts}'}`,
-            ],
             setParserOptionsProject: options.setParserOptionsProject,
             skipPackageJson: options.skipPackageJson,
             rootProject: options.rootProject,
+            addPlugin: options.addPlugin,
         }));
     }
     if (!options.linter || options.linter !== eslint_1.Linter.EsLint) {
         return (0, devkit_1.runTasksInSerial)(...tasks);
     }
+    options.overwriteExisting = options.overwriteExisting || !eslintFile;
     tasks.push(!options.skipPackageJson
         ? (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { 'eslint-plugin-cypress': versions_1.eslintPluginCypressVersion })
         : () => { });
@@ -38,6 +37,7 @@ async function addLinterToCyProject(tree, options) {
         const overrides = [];
         if (options.rootProject) {
             (0, eslint_file_1.addPluginsToLintConfig)(tree, projectConfig.root, '@nx');
+            overrides.push(global_eslint_config_1.typeScriptOverride);
             overrides.push(global_eslint_config_1.javaScriptOverride);
         }
         (0, eslint_file_1.addExtendsToLintConfig)(tree, projectConfig.root, 'plugin:cypress/recommended');
@@ -55,7 +55,7 @@ async function addLinterToCyProject(tree, options) {
         };
         const addCy6Override = cyVersion && cyVersion < 7;
         if (options.overwriteExisting) {
-            overrides.push({
+            overrides.unshift({
                 files: ['*.ts', '*.tsx', '*.js', '*.jsx'],
                 parserOptions: !options.setParserOptionsProject
                     ? undefined

package/src/utils/config.d.ts

@@ -1,18 +1,17 @@
-export declare function addDefaultE2EConfig(cyConfigContents: string, options: {
-    directory: string;
-    bundler?: string;
-}): Promise<string>;
+import { type Tree } from '@nx/devkit';
+import type { NxComponentTestingOptions, NxCypressE2EPresetOptions } from '../../plugins/cypress-preset';
+export declare const CYPRESS_CONFIG_FILE_NAME_PATTERN = "cypress.config.{js,ts,mjs,cjs}";
+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
  * to bring in the nxComponentTestingPreset function
  **/
-export declare function addDefaultCTConfig(cyConfigContents: string, options?: {
-    bundler?: string;
-}): Promise<string>;
+export declare function addDefaultCTConfig(cyConfigContents: string, options?: NxComponentTestingOptions): Promise<string>;
 /**
  * Adds the mount command for Cypress
  * Make sure after calling this the correct import statement is added
  * to bring in the correct mount from cypress.
  **/
 export declare function addMountDefinition(cmpCommandFileContents: string): Promise<string>;
+export declare function getProjectCypressConfigPath(tree: Tree, projectRoot: string): string;

package/src/utils/config.js

@@ -1,30 +1,40 @@
 "use strict";
 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) {
+exports.getProjectCypressConfigPath = exports.addMountDefinition = exports.addDefaultCTConfig = exports.addDefaultE2EConfig = exports.CYPRESS_CONFIG_FILE_NAME_PATTERN = void 0;
+const devkit_1 = require("@nx/devkit");
+exports.CYPRESS_CONFIG_FILE_NAME_PATTERN = 'cypress.config.{js,ts,mjs,cjs}';
+const TS_QUERY_COMMON_JS_EXPORT_SELECTOR = 'BinaryExpression:has(Identifier[name="module"]):has(Identifier[name="exports"])';
+const TS_QUERY_EXPORT_CONFIG_PREFIX = `:matches(ExportAssignment, ${TS_QUERY_COMMON_JS_EXPORT_SELECTOR}) `;
+async function addDefaultE2EConfig(cyConfigContents, options, baseUrl) {
     if (!cyConfigContents) {
         throw new Error('The passed in cypress config file is empty!');
     }
     const { tsquery } = await Promise.resolve().then(() => require('@phenomnomnominal/tsquery'));
+    const isCommonJS = tsquery.query(cyConfigContents, TS_QUERY_COMMON_JS_EXPORT_SELECTOR).length >
+        0;
     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 isCommonJS
+            ? `const { nxE2EPreset } = require('@nx/cypress/plugins/cypress-preset');
+    
+    ${updatedConfigContents}`
+            : `import { nxE2EPreset } from '@nx/cypress/plugins/cypress-preset';
+    
+    ${updatedConfigContents}`;
     }
     return updatedConfigContents;
 }
@@ -42,9 +52,16 @@ async function addDefaultCTConfig(cyConfigContents, options = {}) {
     const testingTypeConfig = tsquery.query(cyConfigContents, `${TS_QUERY_EXPORT_CONFIG_PREFIX} PropertyAssignment:has(Identifier[name="component"])`);
     let updatedConfigContents = cyConfigContents;
     if (testingTypeConfig.length === 0) {
-        const configValue = options?.bundler === 'vite'
-            ? "nxComponentTestingPreset(__filename, { bundler: 'vite' })"
-            : 'nxComponentTestingPreset(__filename)';
+        let configValue = 'nxComponentTestingPreset(__filename)';
+        if (options) {
+            if (options.bundler !== 'vite') {
+                // vite is the default bundler, so we don't need to set it
+                delete options.bundler;
+            }
+            if (Object.keys(options).length) {
+                configValue = `nxComponentTestingPreset(__filename, ${JSON.stringify(options)})`;
+            }
+        }
         updatedConfigContents = tsquery.replace(cyConfigContents, `${TS_QUERY_EXPORT_CONFIG_PREFIX} ObjectLiteralExpression:first-child`, (node) => {
             if (node.properties.length > 0) {
                 return `{
@@ -86,3 +103,13 @@ async function addMountDefinition(cmpCommandFileContents) {
     return `${updatedInterface}\n${mountCommand}`;
 }
 exports.addMountDefinition = addMountDefinition;
+function getProjectCypressConfigPath(tree, projectRoot) {
+    const cypressConfigPaths = (0, devkit_1.glob)(tree, [
+        (0, devkit_1.joinPathFragments)(projectRoot, exports.CYPRESS_CONFIG_FILE_NAME_PATTERN),
+    ]);
+    if (cypressConfigPaths.length === 0) {
+        throw new Error(`Could not find a cypress config file in ${projectRoot}.`);
+    }
+    return cypressConfigPaths[0];
+}
+exports.getProjectCypressConfigPath = getProjectCypressConfigPath;

package/src/utils/constants.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Key used to store options used by the nx plugin for @nx/cypress.
+ */
+export declare const NX_PLUGIN_OPTIONS = "__NxPluginOptions__";

package/src/utils/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NX_PLUGIN_OPTIONS = void 0;
+/**
+ * Key used to store options used by the nx plugin for @nx/cypress.
+ */
+exports.NX_PLUGIN_OPTIONS = '__NxPluginOptions__';

package/src/utils/ct-helpers.d.ts

@@ -11,6 +11,6 @@ export declare function getTempTailwindPath(context: ExecutorContext): string;
  * Checks if the childProjectName is a descendent of the parentProjectName
  * in the project graph
  **/
-export declare function isCtProjectUsingBuildProject(graph: ProjectGraph, parentProjectName: string, childProjectName: string): boolean;
+export declare function isCtProjectUsingBuildProject(graph: ProjectGraph, parentProjectName: string, childProjectName: string, seen?: Set<string>): boolean;
 export declare function getProjectConfigByPath(graph: ProjectGraph, configPath: string): ProjectConfiguration;
 export declare function createExecutorContext(graph: ProjectGraph, targets: Record<string, TargetConfiguration>, projectName: string, targetName: string, configurationName: string): ExecutorContext;

package/src/utils/ct-helpers.js

@@ -30,14 +30,18 @@ exports.getTempTailwindPath = getTempTailwindPath;
  * Checks if the childProjectName is a descendent of the parentProjectName
  * in the project graph
  **/
-function isCtProjectUsingBuildProject(graph, parentProjectName, childProjectName) {
+function isCtProjectUsingBuildProject(graph, parentProjectName, childProjectName, seen = new Set()) {
+    if (seen.has(parentProjectName)) {
+        return false;
+    }
+    seen.add(parentProjectName);
     const isProjectDirectDep = graph.dependencies[parentProjectName].some((p) => p.target === childProjectName);
     if (isProjectDirectDep) {
         return true;
     }
     const maybeIntermediateProjects = graph.dependencies[parentProjectName].filter((p) => !graph.externalNodes[p.target]);
     for (const maybeIntermediateProject of maybeIntermediateProjects) {
-        if (isCtProjectUsingBuildProject(graph, maybeIntermediateProject.target, childProjectName)) {
+        if (isCtProjectUsingBuildProject(graph, maybeIntermediateProject.target, childProjectName, seen)) {
             return true;
         }
     }

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>;