@nx/cypress 23.1.0-beta.5 → 23.1.0-beta.6

package/dist/src/migrations/update-23-1-0/disable-webpack-ct-just-in-time-compile.d.ts

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

package/dist/src/migrations/update-23-1-0/disable-webpack-ct-just-in-time-compile.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = disableWebpackCtJustInTimeCompile;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const config_1 = require("../../utils/config");
+const migrations_1 = require("../../utils/migrations");
+// @nx/remix component testing uses the vite dev server, so justInTimeCompile
+// (webpack only) does not apply even though the preset takes no bundler option.
+const NX_VITE_CT_PRESET = '@nx/remix/plugins/component-testing';
+let ts;
+async function disableWebpackCtJustInTimeCompile(tree) {
+    let wereProjectsMigrated = false;
+    for await (const { cypressConfigPath } of (0, migrations_1.cypressProjectConfigs)(tree)) {
+        if (!tree.exists(cypressConfigPath)) {
+            continue;
+        }
+        const contents = tree.read(cypressConfigPath, 'utf-8');
+        const config = (0, config_1.resolveCypressConfigObject)(contents);
+        if (!config) {
+            continue;
+        }
+        const component = (0, migrations_1.getObjectProperty)(config, 'component');
+        if (!component ||
+            !isWebpackComponentTesting(component) ||
+            setsJustInTimeCompile(component)) {
+            continue;
+        }
+        tree.write(cypressConfigPath, addJustInTimeCompile(contents, component));
+        wereProjectsMigrated = true;
+    }
+    if (wereProjectsMigrated) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+function isWebpackComponentTesting(component) {
+    ts ??= (0, internal_1.ensureTypescript)();
+    // A vite bundler (inline devServer or preset options) opts out.
+    if (getComponentProperty(component, 'bundler').some((property) => ts.isStringLiteral(property.initializer) &&
+        property.initializer.text === 'vite')) {
+        return false;
+    }
+    // Preset-based config: trust it only when `component` actually calls
+    // nxComponentTestingPreset, so a stale/unused preset import doesn't count.
+    if (usesNxComponentTestingPreset(component)) {
+        // @nx/remix is the only vite-based Nx CT preset; resolve the import bound
+        // to the call so an unrelated remix reference elsewhere can't misclassify.
+        return getComponentTestingPresetImport(component) !== NX_VITE_CT_PRESET;
+    }
+    // Hand-written config: migrate only when it has an inline devServer framework.
+    return hasInlineDevServerFramework(component);
+}
+function usesNxComponentTestingPreset(component) {
+    ts ??= (0, internal_1.ensureTypescript)();
+    return (0, tsquery_1.query)(component, 'CallExpression').some((call) => ts.isIdentifier(call.expression) &&
+        call.expression.text === 'nxComponentTestingPreset');
+}
+function hasInlineDevServerFramework(component) {
+    ts ??= (0, internal_1.ensureTypescript)();
+    if (!ts.isObjectLiteralExpression(component.initializer)) {
+        return false;
+    }
+    const devServer = (0, migrations_1.getObjectProperty)(component.initializer, 'devServer');
+    if (!devServer || !ts.isObjectLiteralExpression(devServer.initializer)) {
+        return false;
+    }
+    return !!(0, migrations_1.getObjectProperty)(devServer.initializer, 'framework');
+}
+function getComponentProperty(component, name) {
+    ts ??= (0, internal_1.ensureTypescript)();
+    return (0, tsquery_1.query)(component, 'PropertyAssignment').filter((property) => ts.isIdentifier(property.name) && property.name.text === name);
+}
+// Resolves the module specifier that binds the `nxComponentTestingPreset`
+// identifier used inside `component`, covering both ESM `import` and CJS
+// `require` cypress configs. Returns null when no such binding is found.
+function getComponentTestingPresetImport(component) {
+    ts ??= (0, internal_1.ensureTypescript)();
+    for (const statement of component.getSourceFile().statements) {
+        if (ts.isImportDeclaration(statement) && statement.importClause) {
+            const namedBindings = statement.importClause.namedBindings;
+            if (namedBindings &&
+                ts.isNamedImports(namedBindings) &&
+                ts.isStringLiteral(statement.moduleSpecifier) &&
+                namedBindings.elements.some((element) => element.name.text === 'nxComponentTestingPreset')) {
+                return statement.moduleSpecifier.text;
+            }
+        }
+        if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                const initializer = declaration.initializer;
+                if (!initializer ||
+                    !ts.isCallExpression(initializer) ||
+                    !ts.isIdentifier(initializer.expression) ||
+                    initializer.expression.text !== 'require' ||
+                    !ts.isObjectBindingPattern(declaration.name)) {
+                    continue;
+                }
+                const moduleSpecifier = initializer.arguments[0];
+                if (moduleSpecifier &&
+                    ts.isStringLiteral(moduleSpecifier) &&
+                    declaration.name.elements.some((element) => ts.isIdentifier(element.name) &&
+                        element.name.text === 'nxComponentTestingPreset')) {
+                    return moduleSpecifier.text;
+                }
+            }
+        }
+    }
+    return null;
+}
+function setsJustInTimeCompile(component) {
+    return getComponentProperty(component, 'justInTimeCompile').length > 0;
+}
+function addJustInTimeCompile(contents, component) {
+    ts ??= (0, internal_1.ensureTypescript)();
+    const indent = '    ';
+    const comment = config_1.JIT_COMPILE_DISABLE_COMMENT.map((line) => `${indent}${line}`).join('\n');
+    const newProperty = `${comment}\n${indent}justInTimeCompile: false,`;
+    const initializer = component.initializer;
+    // Object literal: insert the property after the last existing one, leaving
+    // the surrounding source (comments, formatting) untouched. `component` is
+    // gated to be non-empty before we reach here.
+    if (ts.isObjectLiteralExpression(initializer)) {
+        const properties = initializer.properties;
+        const lastProperty = properties[properties.length - 1];
+        let insertAt = lastProperty.getEnd();
+        if (properties.hasTrailingComma) {
+            // Insert after the existing trailing comma, not before it.
+            const commaIndex = contents.indexOf(',', insertAt);
+            if (commaIndex !== -1) {
+                insertAt = commaIndex + 1;
+            }
+        }
+        const separator = properties.hasTrailingComma ? '' : ',';
+        return `${contents.slice(0, insertAt)}${separator}\n${newProperty}${contents.slice(insertAt)}`;
+    }
+    // Preset call (or any other expression): wrap it in an object and spread.
+    const componentValue = `{\n${indent}...${initializer.getText()},\n${newProperty}\n  }`;
+    return `${contents.slice(0, component.getStart())}component: ${componentValue}${contents.slice(component.getEnd())}`;
+}

package/dist/src/migrations/update-23-1-0/disable-webpack-ct-just-in-time-compile.md

@@ -0,0 +1,38 @@
+#### Disable `justInTimeCompile` for webpack component testing
+
+Cypress 14+ defaults `justInTimeCompile` to `true` for the webpack dev server, compiling each spec on demand. In run mode the runner can load a component test before its spec finishes compiling, so the spec executes 0 tests while the run still exits green - a false pass that hides broken component tests in CI.
+
+This migration sets an explicit `justInTimeCompile: false` in the Cypress configs of webpack component testing projects, keeping the choice visible and reversible. Remove the line to opt back into just-in-time compilation.
+
+#### Sample Code Changes
+
+##### Before
+
+```ts title="apps/my-app/cypress.config.ts"
+import { defineConfig } from 'cypress';
+import { nxComponentTestingPreset } from '@nx/react/plugins/component-testing';
+
+export default defineConfig({
+  component: nxComponentTestingPreset(__filename),
+});
+```
+
+##### After
+
+```ts title="apps/my-app/cypress.config.ts"
+import { defineConfig } from 'cypress';
+import { nxComponentTestingPreset } from '@nx/react/plugins/component-testing';
+
+export default defineConfig({
+  component: {
+    ...nxComponentTestingPreset(__filename),
+    // Cypress 14+ defaults justInTimeCompile to true (webpack only), which can
+    // intermittently run 0 tests in CI. Remove this line to opt back in.
+    justInTimeCompile: false,
+  },
+});
+```
+
+#### What is not changed
+
+`justInTimeCompile` only applies to the webpack dev server, so vite-based component testing is left untouched. This migration skips vite configs (including `@nx/remix`, which uses the vite dev server), configs that already set `justInTimeCompile`, and e2e-only configs.

package/dist/src/utils/config.d.ts

@@ -2,6 +2,7 @@ import { type Tree } from '@nx/devkit';
 import type { ObjectLiteralExpression } from 'typescript';
 import type { NxComponentTestingOptions, NxCypressE2EPresetOptions } from '../../plugins/cypress-preset';
 export declare const CYPRESS_CONFIG_FILE_NAME_PATTERN = "cypress.config.{js,ts,mjs,cjs}";
+export declare const JIT_COMPILE_DISABLE_COMMENT: string[];
 export declare function addDefaultE2EConfig(cyConfigContents: string, options: NxCypressE2EPresetOptions, baseUrl: string): Promise<string>;
 /**
  * Adds the nxComponentTestingPreset to the cypress config file.
@@ -13,8 +14,13 @@ export declare function addDefaultE2EConfig(cyConfigContents: string, options: N
  * doing so unconditionally produces mixed-syntax files in CJS workspaces
  * (an ESM `import` followed by a CJS `module.exports`), so prefer passing
  * `presetImportPath`.
+ *
+ * Pass `cypressMajorVersion` to opt webpack setups out of `justInTimeCompile`
+ * on Cypress 14+, where it defaults to `true` and can intermittently run 0
+ * tests in CI. The opt-out is emitted as an explicit `justInTimeCompile: false`
+ * so it is visible and reversible.
  **/
-export declare function addDefaultCTConfig(cyConfigContents: string, options?: NxComponentTestingOptions, presetImportPath?: string): Promise<string>;
+export declare function addDefaultCTConfig(cyConfigContents: string, options?: NxComponentTestingOptions, presetImportPath?: string, cypressMajorVersion?: number | null): Promise<string>;
 /**
  * Adds the mount command for Cypress
  * Make sure after calling this the correct import statement is added

package/dist/src/utils/config.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CYPRESS_CONFIG_FILE_NAME_PATTERN = void 0;
+exports.JIT_COMPILE_DISABLE_COMMENT = exports.CYPRESS_CONFIG_FILE_NAME_PATTERN = void 0;
 exports.addDefaultE2EConfig = addDefaultE2EConfig;
 exports.addDefaultCTConfig = addDefaultCTConfig;
 exports.addMountDefinition = addMountDefinition;
@@ -11,6 +11,12 @@ const internal_1 = require("@nx/js/internal");
 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}) `;
+// Shared so the CT generator (addDefaultCTConfig) and the
+// disable-webpack-ct-just-in-time-compile migration emit the identical note.
+exports.JIT_COMPILE_DISABLE_COMMENT = [
+    '// Cypress 14+ defaults justInTimeCompile to true (webpack only), which can',
+    '// intermittently run 0 tests in CI. Remove this line to opt back in.',
+];
 async function addDefaultE2EConfig(cyConfigContents, options, baseUrl) {
     if (!cyConfigContents) {
         throw new Error('The passed in cypress config file is empty!');
@@ -71,8 +77,13 @@ ${updatedConfigContents}`;
  * doing so unconditionally produces mixed-syntax files in CJS workspaces
  * (an ESM `import` followed by a CJS `module.exports`), so prefer passing
  * `presetImportPath`.
+ *
+ * Pass `cypressMajorVersion` to opt webpack setups out of `justInTimeCompile`
+ * on Cypress 14+, where it defaults to `true` and can intermittently run 0
+ * tests in CI. The opt-out is emitted as an explicit `justInTimeCompile: false`
+ * so it is visible and reversible.
  **/
-async function addDefaultCTConfig(cyConfigContents, options = {}, presetImportPath) {
+async function addDefaultCTConfig(cyConfigContents, options = {}, presetImportPath, cypressMajorVersion) {
     if (!cyConfigContents) {
         throw new Error('The passed in cypress config file is empty!');
     }
@@ -85,6 +96,11 @@ async function addDefaultCTConfig(cyConfigContents, options = {}, presetImportPa
         // See addDefaultE2EConfig for the rationale on __filename vs
         // import.meta.url.
         const pathToConfig = isCommonJS ? '__filename' : 'import.meta.url';
+        // justInTimeCompile only applies to the webpack dev server and only exists
+        // on Cypress 14+, where it defaults to true.
+        const disableJustInTimeCompile = options.bundler !== 'vite' &&
+            cypressMajorVersion != null &&
+            cypressMajorVersion >= 14;
         let configValue = `nxComponentTestingPreset(${pathToConfig})`;
         if (options) {
             if (options.bundler !== 'vite') {
@@ -95,15 +111,23 @@ async function addDefaultCTConfig(cyConfigContents, options = {}, presetImportPa
                 configValue = `nxComponentTestingPreset(${pathToConfig}, ${JSON.stringify(options)})`;
             }
         }
+        const jitComment = exports.JIT_COMPILE_DISABLE_COMMENT.map((line) => `    ${line}`).join('\n');
+        const componentValue = disableJustInTimeCompile
+            ? `{
+    ...${configValue},
+${jitComment}
+    justInTimeCompile: false,
+  }`
+            : configValue;
         updatedConfigContents = tsquery.replace(cyConfigContents, `${TS_QUERY_EXPORT_CONFIG_PREFIX} ObjectLiteralExpression:first-child`, (node) => {
             if (node.properties.length > 0) {
                 return `{
   ${node.properties.map((p) => p.getText()).join(',\n')},
-  component: ${configValue}
+  component: ${componentValue}
 }`;
             }
             return `{
-  component: ${configValue}
+  component: ${componentValue}
 }`;
         });
     }

package/migrations.json

@@ -52,6 +52,15 @@
       "description": "Rename imports of `createNodesV2` from `@nx/cypress/plugin` to the canonical `createNodes` export.",
       "implementation": "./dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes",
       "documentation": "./dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.md"
+    },
+    "disable-webpack-ct-just-in-time-compile": {
+      "version": "23.1.0-beta.6",
+      "requires": {
+        "cypress": ">=14.0.0"
+      },
+      "description": "Set `justInTimeCompile: false` in webpack component testing Cypress configs on Cypress 14+, where it defaults to true and can intermittently run 0 tests in CI.",
+      "implementation": "./dist/src/migrations/update-23-1-0/disable-webpack-ct-just-in-time-compile",
+      "documentation": "./dist/src/migrations/update-23-1-0/disable-webpack-ct-just-in-time-compile.md"
     }
   },
   "packageJsonUpdates": {
@@ -127,6 +136,18 @@
           "alwaysAddToPackageJson": false
         }
       }
+    },
+    "23.1.0-eslint-plugin-cypress": {
+      "version": "23.1.0-beta.6",
+      "requires": {
+        "eslint-plugin-cypress": ">=2.0.0 <3.5.0"
+      },
+      "packages": {
+        "eslint-plugin-cypress": {
+          "version": "^3.5.0",
+          "alwaysAddToPackageJson": false
+        }
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/cypress",
-  "version": "23.1.0-beta.5",
+  "version": "23.1.0-beta.6",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -89,12 +89,12 @@
     "semver": "^7.6.3",
     "tree-kill": "^1.2.2",
     "tslib": "^2.3.0",
-    "@nx/devkit": "23.1.0-beta.5",
-    "@nx/eslint": "23.1.0-beta.5",
-    "@nx/js": "23.1.0-beta.5"
+    "@nx/devkit": "23.1.0-beta.6",
+    "@nx/js": "23.1.0-beta.6",
+    "@nx/eslint": "23.1.0-beta.6"
   },
   "devDependencies": {
-    "nx": "23.1.0-beta.5"
+    "nx": "23.1.0-beta.6"
   },
   "peerDependencies": {
     "cypress": ">= 13 < 16"