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

package/src/generators/configuration/lib/create-files.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFiles = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+function createFiles(tree, options, presetExt) {
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const filesFolder = options.setupFile === 'angular' ? '../files-angular' : '../files';
+    let transformer;
+    let transformerOptions = null;
+    if (options.compiler === 'babel' || options.babelJest) {
+        transformer = 'babel-jest';
+    }
+    else if (options.compiler === 'swc') {
+        transformer = '@swc/jest';
+        if (options.supportTsx) {
+            transformerOptions =
+                "{ jsc: { parser: { syntax: 'typescript', tsx: true }, transform: { react: { runtime: 'automatic' } } } }";
+        }
+    }
+    else {
+        transformer = 'ts-jest';
+        transformerOptions = "{ tsconfig: '<rootDir>/tsconfig.spec.json' }";
+    }
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, filesFolder), projectConfig.root, {
+        tmpl: '',
+        ...options,
+        // jsdom is the default
+        testEnvironment: options.testEnvironment === 'none' || options.testEnvironment === 'jsdom'
+            ? ''
+            : options.testEnvironment,
+        transformer,
+        transformerOptions,
+        js: !!options.js,
+        rootProject: options.rootProject,
+        projectRoot: options.rootProject ? options.project : projectConfig.root,
+        offsetFromRoot: (0, devkit_1.offsetFromRoot)(projectConfig.root),
+        presetExt,
+    });
+    if (options.setupFile === 'none') {
+        tree.delete((0, path_1.join)(projectConfig.root, './src/test-setup.ts'));
+    }
+    if (options.js) {
+        tree.rename((0, path_1.join)(projectConfig.root, 'jest.config.ts'), (0, path_1.join)(projectConfig.root, 'jest.config.js'));
+    }
+}
+exports.createFiles = createFiles;

package/src/generators/configuration/lib/create-jest-config.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedJestProjectSchema } from '../schema';
+export declare function createJestConfig(tree: Tree, options: Partial<NormalizedJestProjectSchema>, presetExt: 'cjs' | 'js'): Promise<void>;

package/src/generators/configuration/lib/create-jest-config.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJestConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const project_configuration_utils_1 = require("nx/src/project-graph/utils/project-configuration-utils");
+const find_root_jest_files_1 = require("../../../utils/config/find-root-jest-files");
+async function createJestConfig(tree, options, presetExt) {
+    if (!tree.exists(`jest.preset.${presetExt}`)) {
+        // preset is always js file.
+        tree.write(`jest.preset.${presetExt}`, `
+      const nxPreset = require('@nx/jest/preset').default;
+
+      module.exports = { ...nxPreset }`);
+    }
+    if (options.rootProject) {
+        // we don't want any config to be made because the `configurationGenerator` will do it.
+        // will copy the template config file
+        return;
+    }
+    const rootJestPath = (0, find_root_jest_files_1.findRootJestConfig)(tree);
+    if (!rootJestPath) {
+        // if there's not root jest config, we will create one and return
+        // this can happen when:
+        // - root jest config was renamed => in which case there is migration needed
+        // - root project didn't have jest setup => again, no migration is needed
+        generateGlobalConfig(tree, options.js);
+        return;
+    }
+    if (tree.exists(rootJestPath)) {
+        // moving from root project config to monorepo-style config
+        const { nodes: projects } = await (0, devkit_1.createProjectGraphAsync)();
+        const projectConfigurations = Object.values(projects);
+        const rootProject = projectConfigurations.find((projectNode) => projectNode.data?.root === '.');
+        // root project might have been removed,
+        // if it's missing there's nothing to migrate
+        if (rootProject) {
+            const jestTarget = Object.entries(rootProject.data?.targets ?? {}).find(([_, t]) => ((t?.executor === '@nx/jest:jest' ||
+                t?.executor === '@nrwl/jest:jest') &&
+                t?.options?.jestConfig === rootJestPath) ||
+                (t?.executor === 'nx:run-commands' && t?.options?.command === 'jest'));
+            if (!jestTarget) {
+                return;
+            }
+            const [jestTargetName, jestTargetConfigInGraph] = jestTarget;
+            // if root project doesn't have jest target, there's nothing to migrate
+            const rootProjectConfig = (0, devkit_1.readProjectConfiguration)(tree, rootProject.name);
+            if (rootProjectConfig.targets?.['test']?.executor === 'nx:run-commands'
+                ? rootProjectConfig.targets?.['test']?.command !== 'jest'
+                : rootProjectConfig.targets?.['test']?.options?.jestConfig !==
+                    rootJestPath) {
+                // Jest target has already been updated
+                return;
+            }
+            const jestProjectConfig = `jest.config.${rootProjectConfig.projectType === 'application' ? 'app' : 'lib'}.${options.js ? 'js' : 'ts'}`;
+            tree.rename(rootJestPath, jestProjectConfig);
+            const nxJson = (0, devkit_1.readNxJson)(tree);
+            const targetDefaults = (0, project_configuration_utils_1.readTargetDefaultsForTarget)(jestTargetName, nxJson.targetDefaults, jestTargetConfigInGraph.executor);
+            const target = (rootProjectConfig.targets[jestTargetName] ??=
+                jestTargetConfigInGraph.executor === 'nx:run-commands'
+                    ? { command: `jest --config ${jestProjectConfig}` }
+                    : {
+                        executor: jestTargetConfigInGraph.executor,
+                        options: {},
+                    });
+            if (target.executor === '@nx/jest:jest') {
+                target.options.jestConfig = jestProjectConfig;
+            }
+            if (targetDefaults?.cache === undefined) {
+                target.cache = jestTargetConfigInGraph.cache;
+            }
+            if (targetDefaults?.inputs === undefined) {
+                target.inputs = jestTargetConfigInGraph.inputs;
+            }
+            if (targetDefaults?.outputs === undefined) {
+                target.outputs = jestTargetConfigInGraph.outputs;
+            }
+            if (targetDefaults?.dependsOn === undefined) {
+                target.dependsOn = jestTargetConfigInGraph.dependsOn;
+            }
+            (0, devkit_1.updateProjectConfiguration)(tree, rootProject.name, rootProjectConfig);
+            // generate new global config as it was move to project config or is missing
+            generateGlobalConfig(tree, options.js);
+        }
+    }
+}
+exports.createJestConfig = createJestConfig;
+function generateGlobalConfig(tree, isJS) {
+    const contents = isJS
+        ? (0, devkit_1.stripIndents) `
+    const { getJestProjectsAsync } = require('@nx/jest');
+
+    module.exports = async () => ({
+      projects: await getJestProjectsAsync()
+    });`
+        : (0, devkit_1.stripIndents) `
+    import { getJestProjectsAsync } from '@nx/jest';
+
+    export default async () => ({
+     projects: await getJestProjectsAsync()
+    });`;
+    tree.write(`jest.config.${isJS ? 'js' : 'ts'}`, contents);
+}

package/src/generators/configuration/lib/ensure-dependencies.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedJestProjectSchema } from '../schema';
+export declare function ensureDependencies(tree: Tree, options: Partial<NormalizedJestProjectSchema>): import("@nx/devkit").GeneratorCallback;

package/src/generators/configuration/lib/ensure-dependencies.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../../utils/versions");
+function ensureDependencies(tree, options) {
+    const dependencies = {
+        tslib: versions_1.tslibVersion,
+    };
+    const devDeps = {
+        // because the default jest-preset uses ts-jest,
+        // jest will throw an error if it's not installed
+        // even if not using it in overriding transformers
+        'ts-jest': versions_1.tsJestVersion,
+    };
+    if (options.testEnvironment !== 'none') {
+        devDeps[`jest-environment-${options.testEnvironment}`] = versions_1.jestVersion;
+    }
+    if (!options.js) {
+        devDeps['ts-node'] = versions_1.tsNodeVersion;
+        devDeps['@types/jest'] = versions_1.jestTypesVersion;
+        devDeps['@types/node'] = versions_1.typesNodeVersion;
+    }
+    if (options.compiler === 'babel' || options.babelJest) {
+        devDeps['babel-jest'] = versions_1.babelJestVersion;
+        // in some cases @nx/js will not already be present i.e. node only projects
+        devDeps['@nx/js'] = versions_1.nxVersion;
+    }
+    else if (options.compiler === 'swc') {
+        devDeps['@swc/jest'] = versions_1.swcJestVersion;
+    }
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, dependencies, devDeps);
+}
+exports.ensureDependencies = ensureDependencies;

package/src/generators/configuration/lib/update-jestconfig.d.ts

@@ -0,0 +1,3 @@
+import { NormalizedJestProjectSchema } from '../schema';
+import { Tree } from '@nx/devkit';
+export declare function updateJestConfig(host: Tree, options: NormalizedJestProjectSchema): void;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateJestConfig = void 0;
+const find_root_jest_files_1 = require("../../../utils/config/find-root-jest-files");
+const update_config_1 = require("../../../utils/config/update-config");
+const devkit_1 = require("@nx/devkit");
+function isUsingUtilityFunction(host) {
+    const rootConfig = (0, find_root_jest_files_1.findRootJestConfig)(host);
+    if (!rootConfig) {
+        return false;
+    }
+    const rootConfigContent = host.read(rootConfig, 'utf-8');
+    return (rootConfigContent.includes('getJestProjects()') ||
+        rootConfigContent.includes('getJestProjectsAsync()'));
+}
+function updateJestConfig(host, options) {
+    if (isUsingUtilityFunction(host)) {
+        return;
+    }
+    const project = (0, devkit_1.readProjectConfiguration)(host, options.project);
+    const rootConfig = (0, find_root_jest_files_1.findRootJestConfig)(host);
+    if (rootConfig) {
+        (0, update_config_1.addPropertyToJestConfig)(host, (0, find_root_jest_files_1.findRootJestConfig)(host), 'projects', `<rootDir>/${project.root}`);
+    }
+}
+exports.updateJestConfig = updateJestConfig;

package/src/generators/configuration/lib/update-tsconfig.d.ts

@@ -0,0 +1,3 @@
+import { NormalizedJestProjectSchema } from '../schema';
+import { Tree } from '@nx/devkit';
+export declare function updateTsConfig(host: Tree, options: NormalizedJestProjectSchema): void;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTsConfig = void 0;
+const path_1 = require("path");
+const devkit_1 = require("@nx/devkit");
+function updateTsConfig(host, options) {
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(host, options.project);
+    if (!host.exists((0, path_1.join)(projectConfig.root, 'tsconfig.json'))) {
+        throw new Error(`Expected ${(0, path_1.join)(projectConfig.root, 'tsconfig.json')} to exist. Please create one.`);
+    }
+    (0, devkit_1.updateJson)(host, (0, path_1.join)(projectConfig.root, 'tsconfig.json'), (json) => {
+        if (json.references &&
+            !json.references.some((r) => r.path === './tsconfig.spec.json')) {
+            json.references.push({
+                path: './tsconfig.spec.json',
+            });
+        }
+        return json;
+    });
+}
+exports.updateTsConfig = updateTsConfig;

package/src/generators/configuration/lib/update-vscode-recommended-extensions.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function updateVsCodeRecommendedExtensions(host: Tree): void;

package/src/generators/configuration/lib/update-vscode-recommended-extensions.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateVsCodeRecommendedExtensions = void 0;
+const devkit_1 = require("@nx/devkit");
+function updateVsCodeRecommendedExtensions(host) {
+    if (!host.exists('.vscode/extensions.json')) {
+        return;
+    }
+    (0, devkit_1.updateJson)(host, '.vscode/extensions.json', (json) => {
+        json.recommendations = json.recommendations || [];
+        const extension = 'firsttris.vscode-jest-runner';
+        if (!json.recommendations.includes(extension)) {
+            json.recommendations.push(extension);
+        }
+        return json;
+    });
+}
+exports.updateVsCodeRecommendedExtensions = updateVsCodeRecommendedExtensions;

package/src/generators/configuration/lib/update-workspace.d.ts

@@ -0,0 +1,3 @@
+import { NormalizedJestProjectSchema } from '../schema';
+import { Tree } from '@nx/devkit';
+export declare function updateWorkspace(tree: Tree, options: NormalizedJestProjectSchema): void;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateWorkspace = void 0;
+const devkit_1 = require("@nx/devkit");
+function updateWorkspace(tree, options) {
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    if (!projectConfig.targets) {
+        projectConfig.targets = {};
+    }
+    projectConfig.targets[options.targetName] = {
+        executor: '@nx/jest:jest',
+        outputs: [
+            options.rootProject
+                ? (0, devkit_1.joinPathFragments)('{workspaceRoot}', 'coverage', '{projectName}')
+                : (0, devkit_1.joinPathFragments)('{workspaceRoot}', 'coverage', '{projectRoot}'),
+        ],
+        options: {
+            jestConfig: (0, devkit_1.joinPathFragments)((0, devkit_1.normalizePath)(projectConfig.root), `jest.config.${options.js ? 'js' : 'ts'}`),
+        },
+    };
+    (0, devkit_1.updateProjectConfiguration)(tree, options.project, projectConfig);
+}
+exports.updateWorkspace = updateWorkspace;

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

@@ -0,0 +1,31 @@
+export interface JestProjectSchema {
+  project: string;
+  targetName?: string;
+  supportTsx?: boolean;
+  /**
+   * @deprecated use setupFile instead
+   */
+  skipSetupFile?: boolean;
+  setupFile?: 'angular' | 'web-components' | 'none';
+  skipSerializers?: boolean;
+  testEnvironment?: 'node' | 'jsdom' | 'none';
+  /**
+   * @deprecated use compiler: "babel" instead
+   */
+  babelJest?: boolean;
+  skipFormat?: boolean;
+
+  addPlugin?: boolean;
+  compiler?: 'tsc' | 'babel' | 'swc';
+  skipPackageJson?: boolean;
+  js?: boolean;
+
+  /**
+   * @internal
+   */
+  addExplicitTargets?: boolean;
+}
+
+export type NormalizedJestProjectSchema = JestProjectSchema & {
+  rootProject: boolean;
+};

package/src/generators/configuration/schema.json

@@ -0,0 +1,80 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxJestProject",
+  "cli": "nx",
+  "title": "Add Jest Configuration to a project",
+  "description": "Add Jest Configuration to a project.",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The name of the project.",
+      "$default": {
+        "$source": "projectName"
+      },
+      "x-priority": "important"
+    },
+    "skipSetupFile": {
+      "type": "boolean",
+      "description": "Skips the setup file required for angular.",
+      "default": false,
+      "x-deprecated": "Use `--setup-file` instead."
+    },
+    "setupFile": {
+      "type": "string",
+      "enum": ["none", "angular", "web-components"],
+      "description": "The setup file to be generated.",
+      "default": "none",
+      "x-priority": "important"
+    },
+    "skipSerializers": {
+      "type": "boolean",
+      "description": "Skips the serializers required to snapshot angular templates.",
+      "default": false
+    },
+    "supportTsx": {
+      "type": "boolean",
+      "description": "Setup `tsx` support.",
+      "default": false,
+      "x-priority": "important"
+    },
+    "testEnvironment": {
+      "type": "string",
+      "enum": ["jsdom", "node", "none"],
+      "description": "The test environment for jest.",
+      "default": "jsdom",
+      "x-priority": "important"
+    },
+    "compiler": {
+      "type": "string",
+      "enum": ["tsc", "babel", "swc"],
+      "description": "The compiler to use for source and tests.",
+      "default": "tsc"
+    },
+    "babelJest": {
+      "type": "boolean",
+      "alias": "babel-jest",
+      "description": "Use `babel-jest` instead of `ts-jest`.",
+      "x-deprecated": "Use `--compiler=babel` instead.",
+      "default": false
+    },
+    "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"
+    },
+    "js": {
+      "type": "boolean",
+      "default": false,
+      "description": "Use JavaScript instead of TypeScript for config files"
+    }
+  },
+  "required": []
+}

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

@@ -0,0 +1,5 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+import type { JestInitSchema } from './schema';
+export declare function jestInitGenerator(tree: Tree, options: JestInitSchema): Promise<GeneratorCallback>;
+export declare function jestInitGeneratorInternal(tree: Tree, options: JestInitSchema): Promise<GeneratorCallback>;
+export default jestInitGenerator;

package/src/generators/init/init.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jestInitGeneratorInternal = exports.jestInitGenerator = 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 is_preset_cjs_1 = require("../../utils/config/is-preset-cjs");
+function addPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.plugins ??= [];
+    if (!nxJson.plugins.some((p) => typeof p === 'string'
+        ? p === '@nx/jest/plugin'
+        : p.plugin === '@nx/jest/plugin')) {
+        nxJson.plugins.push({
+            plugin: '@nx/jest/plugin',
+            options: {
+                targetName: 'test',
+            },
+        });
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+function updateProductionFileSet(tree, presetExt) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const productionFileSet = nxJson.namedInputs?.production;
+    if (productionFileSet) {
+        // This is one of the patterns in the default jest patterns
+        productionFileSet.push(
+        // Remove spec, test, and snapshots from the production fileset
+        '!{projectRoot}/**/?(*.)+(spec|test).[jt]s?(x)?(.snap)', 
+        // Remove tsconfig.spec.json
+        '!{projectRoot}/tsconfig.spec.json', 
+        // Remove jest.config.js/ts
+        '!{projectRoot}/jest.config.[jt]s', 
+        // Remove test-setup.js/ts
+        // TODO(meeroslav) this should be standardized
+        '!{projectRoot}/src/test-setup.[jt]s', '!{projectRoot}/test-setup.[jt]s');
+        // Dedupe and set
+        nxJson.namedInputs.production = Array.from(new Set(productionFileSet));
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+function addJestTargetDefaults(tree, presetEnv) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.targetDefaults ??= {};
+    nxJson.targetDefaults['@nx/jest:jest'] ??= {};
+    const productionFileSet = nxJson.namedInputs?.production;
+    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.${presetEnv}`,
+    ];
+    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) {
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+        '@nx/jest': versions_1.nxVersion,
+        jest: versions_1.jestVersion,
+    }, undefined, options.keepExistingVersions);
+}
+function jestInitGenerator(tree, options) {
+    return jestInitGeneratorInternal(tree, { addPlugin: false, ...options });
+}
+exports.jestInitGenerator = jestInitGenerator;
+async function jestInitGeneratorInternal(tree, options) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    options.addPlugin ??= addPluginDefault;
+    const presetExt = (0, is_preset_cjs_1.isPresetCjs)(tree) ? 'cjs' : 'js';
+    if (!tree.exists('jest.preset.js') && !tree.exists('jest.preset.cjs')) {
+        updateProductionFileSet(tree, presetExt);
+        if (options.addPlugin) {
+            addPlugin(tree);
+        }
+        else {
+            addJestTargetDefaults(tree, presetExt);
+        }
+    }
+    const tasks = [];
+    if (!options.skipPackageJson) {
+        tasks.push((0, devkit_1.removeDependenciesFromPackageJson)(tree, ['@nx/jest'], []));
+        tasks.push(updateDependencies(tree, options));
+    }
+    if (options.updatePackageScripts) {
+        await (0, update_package_scripts_1.updatePackageScripts)(tree, plugin_1.createNodes);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.jestInitGeneratorInternal = jestInitGeneratorInternal;
+exports.default = jestInitGenerator;

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

@@ -0,0 +1,8 @@
+export interface JestInitSchema {
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  keepExistingVersions?: boolean;
+  updatePackageScripts?: boolean;
+
+  addPlugin?: boolean;
+}

package/src/generators/init/schema.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxJestInit",
+  "cli": "nx",
+  "title": "Jest init",
+  "description": "Add Jest Configuration to a 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
+    }
+  },
+  "required": []
+}

package/src/migrations/update-15-0-0/add-jest-inputs.d.ts

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

package/src/migrations/update-15-0-0/add-jest-inputs.js

@@ -0,0 +1,41 @@
+"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");
+async function default_1(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const jestTargets = getJestTargetNames(tree);
+    const hasProductionFileset = !!nxJson.namedInputs?.production;
+    if (jestTargets.size > 0 && hasProductionFileset) {
+        const productionFileset = new Set(nxJson.namedInputs.production);
+        for (const exclusion of [
+            '!{projectRoot}/**/?(*.)+(spec|test).[jt]s?(x)?(.snap)',
+            '!{projectRoot}/tsconfig.spec.json',
+            '!{projectRoot}/jest.config.[jt]s',
+        ]) {
+            productionFileset.add(exclusion);
+        }
+        nxJson.namedInputs.production = Array.from(productionFileset);
+    }
+    for (const targetName of jestTargets) {
+        nxJson.targetDefaults ??= {};
+        const jestTargetDefaults = (nxJson.targetDefaults[targetName] ??= {});
+        jestTargetDefaults.inputs ??= [
+            'default',
+            hasProductionFileset ? '^production' : '^default',
+            ...(tree.exists('jest.preset.js')
+                ? ['{workspaceRoot}/jest.preset.js']
+                : []),
+        ];
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;
+function getJestTargetNames(tree) {
+    const jestTargetNames = new Set();
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nrwl/jest:jest', (_, __, target) => {
+        jestTargetNames.add(target);
+    });
+    return jestTargetNames;
+}

package/src/migrations/update-15-8-0/update-configs-jest-29.d.ts

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