@nx/jest 17.0.3 → 17.1.0-beta.2

package/migrations.json

@@ -29,6 +29,11 @@
       "version": "16.5.0-beta.2",
       "description": "Add test-setup.ts to ignored files in production input",
       "implementation": "./src/migrations/update-16-5-0/add-test-setup-to-inputs-ignore"
+    },
+    "move-options-to-target-defaults": {
+      "version": "17.1.0-beta.2",
+      "description": "Move jest executor options to nx.json targetDefaults",
+      "implementation": "./src/migrations/update-17-1-0/move-options-to-target-defaults"
     }
   },
   "packageJsonUpdates": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/jest",
-  "version": "17.0.3",
+  "version": "17.1.0-beta.2",
   "private": false,
   "description": "The Nx Plugin for Jest contains executors and generators allowing your workspace to use the powerful Jest testing capabilities.",
   "repository": {
@@ -44,9 +44,9 @@
     "jest-util": "^29.4.1",
     "resolve.exports": "1.1.0",
     "tslib": "^2.3.0",
-    "@nx/devkit": "17.0.3",
-    "@nx/js": "17.0.3",
-    "@nrwl/jest": "17.0.3"
+    "@nx/devkit": "17.1.0-beta.2",
+    "@nx/js": "17.1.0-beta.2",
+    "@nrwl/jest": "17.1.0-beta.2"
   },
   "publishConfig": {
     "access": "public"

package/src/generators/configuration/lib/update-workspace.js

@@ -16,13 +16,6 @@ function updateWorkspace(tree, options) {
         ],
         options: {
             jestConfig: (0, devkit_1.joinPathFragments)((0, devkit_1.normalizePath)(projectConfig.root), `jest.config.${options.js ? 'js' : 'ts'}`),
-            passWithNoTests: true,
-        },
-        configurations: {
-            ci: {
-                ci: true,
-                codeCoverage: true,
-            },
         },
     };
     (0, devkit_1.updateProjectConfiguration)(tree, options.project, projectConfig);

package/src/generators/init/init.js

@@ -34,7 +34,8 @@ function createJestConfig(tree, options) {
       const nxPreset = require('@nx/jest/preset').default;
 
       module.exports = { ...nxPreset }`);
-        addTestInputs(tree);
+        updateProductionFileSet(tree);
+        addJestTargetDefaults(tree);
     }
     if (options.rootProject) {
         // we don't want any config to be made because the `configurationGenerator` will do it.
@@ -73,7 +74,7 @@ function createJestConfig(tree, options) {
         }
     }
 }
-function addTestInputs(tree) {
+function updateProductionFileSet(tree) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const productionFileSet = nxJson.namedInputs?.production;
     if (productionFileSet) {
@@ -91,14 +92,29 @@ function addTestInputs(tree) {
         // Dedupe and set
         nxJson.namedInputs.production = Array.from(new Set(productionFileSet));
     }
-    // Test targets depend on all their project's sources + production sources of dependencies
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+function addJestTargetDefaults(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const productionFileSet = nxJson.namedInputs?.production;
     nxJson.targetDefaults ??= {};
-    nxJson.targetDefaults.test ??= {};
-    nxJson.targetDefaults.test.inputs ??= [
+    nxJson.targetDefaults['@nx/jest:jest'] ??= {};
+    nxJson.targetDefaults['@nx/jest:jest'].cache ??= true;
+    // Test targets depend on all their project's sources + production sources of dependencies
+    nxJson.targetDefaults['@nx/jest:jest'].inputs ??= [
         'default',
         productionFileSet ? '^production' : '^default',
+        '{workspaceRoot}/jest.preset.js',
     ];
-    nxJson.targetDefaults.test.inputs.push('{workspaceRoot}/jest.preset.js');
+    nxJson.targetDefaults['@nx/jest:jest'].options ??= {
+        passWithNoTests: true,
+    };
+    nxJson.targetDefaults['@nx/jest:jest'].configurations ??= {
+        ci: {
+            ci: true,
+            codeCoverage: true,
+        },
+    };
     (0, devkit_1.updateNxJson)(tree, nxJson);
 }
 function updateDependencies(tree, options) {

package/src/migrations/update-17-1-0/move-options-to-target-defaults.d.ts

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

package/src/migrations/update-17-1-0/move-options-to-target-defaults.js

@@ -0,0 +1,117 @@
+"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 project_configuration_utils_1 = require("nx/src/project-graph/utils/project-configuration-utils");
+async function update(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    // Don't override anything if there are already target defaults for jest
+    if (nxJson.targetDefaults?.['@nx/jest:jest']) {
+        return;
+    }
+    nxJson.targetDefaults ??= {};
+    /**
+     * A set of targets which does not use any other executors
+     */
+    const jestTargets = new Set();
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    (0, executor_options_utils_1.forEachExecutorOptionsInGraph)(graph, '@nx/jest:jest', (value, proj, targetName) => {
+        jestTargets.add(targetName);
+    });
+    // Workspace does not use jest?
+    if (jestTargets.size === 0) {
+        return;
+    }
+    // Use the project graph so targets which are inferred are considered
+    const projects = graph.nodes;
+    const projectMap = (0, devkit_1.getProjects)(tree);
+    const jestDefaults = (nxJson.targetDefaults['@nx/jest:jest'] = {});
+    // All jest targets have the same name
+    if (jestTargets.size === 1) {
+        const targetName = Array.from(jestTargets)[0];
+        if (nxJson.targetDefaults[targetName]) {
+            Object.assign(jestDefaults, nxJson.targetDefaults[targetName]);
+        }
+    }
+    jestDefaults.cache ??= true;
+    const inputs = ['default'];
+    inputs.push(nxJson.namedInputs?.production ? '^production' : '^default');
+    if (tree.exists('jest.preset.js')) {
+        inputs.push('{workspaceRoot}/jest.preset.js');
+    }
+    jestDefaults.inputs ??= inputs;
+    // Remember if there were already defaults so we don't assume the executor default
+    const passWithNoTestsPreviouslyInDefaults = jestDefaults.options?.passWithNoTests !== undefined;
+    const ciCiPreviouslyInDefaults = jestDefaults.configurations?.ci?.ci !== undefined;
+    const ciCodeCoveragePreviouslyInDefaults = jestDefaults.configurations?.ci?.codeCoverage !== undefined;
+    jestDefaults.options ??= {};
+    jestDefaults.options.passWithNoTests ??= true;
+    jestDefaults.configurations ??= {};
+    jestDefaults.configurations.ci ??= {};
+    jestDefaults.configurations.ci.ci ??= true;
+    jestDefaults.configurations.ci.codeCoverage ??= true;
+    // Cleanup old target defaults
+    for (const [targetDefaultKey, targetDefault] of Object.entries(nxJson.targetDefaults)) {
+        if (!isTargetDefaultUsed(targetDefault, nxJson.targetDefaults, projects, projectMap)) {
+            delete nxJson.targetDefaults[targetDefaultKey];
+        }
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/jest:jest', (value, proj, targetName, configuration) => {
+        const projConfig = projectMap.get(proj);
+        if (!configuration) {
+            // Options
+            if (value.passWithNoTests === jestDefaults.options.passWithNoTests) {
+                delete projConfig.targets[targetName].options.passWithNoTests;
+            }
+            else if (!passWithNoTestsPreviouslyInDefaults) {
+                projConfig.targets[targetName].options.passWithNoTests ??= false;
+            }
+            if (Object.keys(projConfig.targets[targetName].options).length === 0) {
+                delete projConfig.targets[targetName].options;
+            }
+        }
+        else if (configuration === 'ci') {
+            // CI Config
+            if (value.ci === jestDefaults.configurations.ci.ci) {
+                delete projConfig.targets[targetName].configurations.ci.ci;
+            }
+            else if (ciCiPreviouslyInDefaults) {
+                projConfig.targets[targetName].configurations.ci.ci ??= false;
+            }
+            if (value.codeCoverage === jestDefaults.configurations.ci.codeCoverage) {
+                delete projConfig.targets[targetName].configurations.ci.codeCoverage;
+            }
+            else if (ciCodeCoveragePreviouslyInDefaults) {
+                projConfig.targets[targetName].configurations.ci.codeCoverage ??=
+                    false;
+            }
+            if (Object.keys(projConfig.targets[targetName].configurations.ci)
+                .length === 0) {
+                delete projConfig.targets[targetName].configurations.ci;
+            }
+            if (Object.keys(projConfig.targets[targetName].configurations).length ===
+                0) {
+                delete projConfig.targets[targetName].configurations;
+            }
+        }
+        (0, devkit_1.updateProjectConfiguration)(tree, proj, projConfig);
+    });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = update;
+/**
+ * Checks every target on every project to see if one of them uses the target default
+ */
+function isTargetDefaultUsed(targetDefault, targetDefaults, projects, projectMap) {
+    for (const p of Object.values(projects)) {
+        for (const targetName in p.data?.targets ?? {}) {
+            if ((0, project_configuration_utils_1.readTargetDefaultsForTarget)(targetName, targetDefaults, 
+            // It might seem like we should use the graph here too but we don't want to pass an executor which was processed in the graph
+            projectMap.get(p.name).targets?.[targetName]?.executor) === targetDefault) {
+                return true;
+            }
+        }
+    }
+    return false;
+}