@nx/jest 24.0.0 → 24.0.2

package/dist/src/generators/configuration/files/common/tsconfig.spec.json__tmpl__

@@ -1,7 +1,8 @@
 {
   "extends": "<%= extendedConfig %>",
   "compilerOptions": {
-    "outDir": "<%= outDir %>",<% if (module) { %>
+    "outDir": "<%= outDir %>",<% if (rootDir) { %>
+    "rootDir": "<%= rootDir %>",<% } if (module) { %>
     "module": "<%= module %>",<% } if (module === 'commonjs') { %>
     "moduleResolution": "<%= moduleResolution %>",<% } if (isolatedModules) { %>
     "isolatedModules": true,<% } if (supportTsx) { %>

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

@@ -56,6 +56,9 @@ function createFiles(tree, options, presetExt) {
     const isolatedModules = options.isTsSolutionSetup &&
         transformer === 'ts-jest' &&
         moduleResolution === 'node10';
+    // ts-jest drops `composite` and, with `isolatedModules`, compiles each test
+    // file alone. TypeScript 6 then fails with TS5011 unless `rootDir` is set.
+    const rootDir = options.isTsSolutionSetup && transformer === 'ts-jest' ? '.' : undefined;
     (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, commonFilesFolder), projectConfig.root, {
         tmpl: '',
         ...options,
@@ -74,6 +77,7 @@ function createFiles(tree, options, presetExt) {
         outDir: options.isTsSolutionSetup
             ? `./out-tsc/jest`
             : `${rootOffset}dist/out-tsc`,
+        rootDir,
         module: usesTsJestModuleSettings ? 'commonjs' : undefined,
         moduleResolution,
         isolatedModules,

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

@@ -1,4 +1,4 @@
-import { type Tree } from '@nx/devkit';
+import type { Tree } from '@nx/devkit';
 import { type JestPresetExtension } from '../../../utils/config/config-file';
 import type { NormalizedJestProjectSchema } from '../schema';
 export declare function writeRootJestPreset(tree: Tree, presetExt: JestPresetExtension): void;

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

@@ -2,10 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeRootJestPreset = writeRootJestPreset;
 exports.createJestConfig = createJestConfig;
-const devkit_1 = require("@nx/devkit");
 const config_file_1 = require("../../../utils/config/config-file");
-const internal_1 = require("@nx/js/internal");
-const internal_2 = require("@nx/devkit/internal");
 function writeRootJestPreset(tree, presetExt) {
     if (!tree.exists(`jest.preset.${presetExt}`)) {
         if (presetExt === 'mjs') {
@@ -28,72 +25,8 @@ async function createJestConfig(tree, options, presetExt) {
         // will copy the template config file
         return;
     }
-    const rootJestPath = (0, config_file_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
+    if (!(0, config_file_1.findRootJestConfig)(tree)) {
         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.${(0, internal_1.getProjectType)(tree, rootProjectConfig.root, rootProjectConfig.projectType) === 'application'
-                ? 'app'
-                : 'lib'}.${options.js ? 'js' : 'ts'}`;
-            tree.rename(rootJestPath, jestProjectConfig);
-            const nxJson = (0, devkit_1.readNxJson)(tree);
-            const targetDefaults = (0, internal_2.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);
-        }
     }
 }
 function generateGlobalConfig(tree, isJS) {

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateTsConfig = updateTsConfig;
 const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
 const internal_1 = require("@nx/js/internal");
 function updateTsConfig(host, options) {
     const { root, projectType: _projectType } = (0, devkit_1.readProjectConfiguration)(host, options.project);
@@ -55,9 +56,31 @@ function updateTsConfig(host, options) {
             json.exclude = [...uniqueExclude];
             return json;
         });
+        // A composite spec config reaches runtime sources only through a project
+        // reference. Skip it when the runtime config references the spec config.
+        const specTsconfigPath = (0, devkit_1.joinPathFragments)(root, 'tsconfig.spec.json');
+        const runtimeReference = `./${path_1.posix.relative(root, runtimeTsconfigPath)}`;
+        if (options.isTsSolutionSetup &&
+            canBeReferencedBy(host, runtimeTsconfigPath, specTsconfigPath)) {
+            (0, devkit_1.updateJson)(host, specTsconfigPath, (json) => {
+                json.references ??= [];
+                if (!json.references.some((r) => r.path === runtimeReference)) {
+                    json.references.push({ path: runtimeReference });
+                }
+                return json;
+            });
+        }
     }
     else {
         devkit_1.logger.warn(`Couldn't find a runtime tsconfig file at ${runtimeTsconfigPath} to exclude the test files from. ` +
             `If you're using a different filename for your runtime tsconfig, please provide it with the '--runtimeTsconfigFileName' flag.`);
     }
 }
+function canBeReferencedBy(tree, tsconfigPath, referrerPath) {
+    const ts = (0, internal_1.ensureTypescript)();
+    const host = (0, internal_1.createTreeParseConfigHost)(tree);
+    const { options, projectReferences } = ts.parseJsonConfigFileContent(ts.readConfigFile(tsconfigPath, host.readFile).config, host, path_1.posix.dirname(tsconfigPath));
+    return (options.composite === true &&
+        !options.noEmit &&
+        !projectReferences?.some((r) => ts.resolveProjectReferencePath(r) === referrerPath));
+}

package/dist/src/migrations/update-24-0-0/remove-deprecated-executors.d.ts

@@ -1,4 +1,4 @@
-import type { Tree } from '@nx/devkit';
+import { type Tree } from '@nx/devkit';
 export default function update(tree: Tree): Promise<{
     nextSteps?: string[];
     agentContext?: string[];

package/dist/src/migrations/update-24-0-0/remove-deprecated-executors.js

@@ -1,10 +1,225 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = update;
+const devkit_1 = require("@nx/devkit");
 const internal_1 = require("@nx/devkit/internal");
+const node_path_1 = require("node:path");
+const node_util_1 = require("node:util");
+const config_file_1 = require("../../utils/config/config-file");
+const removedExecutors = ['@nx/jest:jest', '@nrwl/jest:jest'];
+// The removed executor set this on every run; @nx/jest/plugin sets the same value
+const tsNodeCompilerOptions = JSON.stringify({
+    moduleResolution: 'node10',
+    module: 'commonjs',
+    customConditions: null,
+});
+const isBoolean = (value) => typeof value === 'boolean';
+const isPositiveInteger = (value) => Number.isSafeInteger(value) && value > 0;
+/**
+ * The only options a rewritten target may set. Generators wrote jestConfig,
+ * tsConfig, passWithNoTests, ci and codeCoverage. Jest 29 and 30 read the other
+ * flags from --name=value as the values the executor passed to runCLI.
+ */
+const acceptedOptions = new Map([
+    ['jestConfig', isPlainPath],
+    ['tsConfig', (value) => typeof value === 'string'],
+    ['codeCoverage', isBoolean],
+    ['bail', isBoolean],
+    ['ci', isBoolean],
+    ['detectOpenHandles', isBoolean],
+    ['forceExit', isBoolean],
+    ['logHeapUsage', isBoolean],
+    ['passWithNoTests', isBoolean],
+    ['runInBand', isBoolean],
+    ['silent', isBoolean],
+    ['maxWorkers', isPositiveInteger],
+    ['testTimeout', isPositiveInteger],
+]);
 function update(tree) {
-    return (0, internal_1.migrateRemovedExecutors)(tree, ['@nx/jest:jest', '@nrwl/jest:jest'], async (tree, options) => {
-        const { convertToInferred } = require('../../generators/convert-to-inferred/convert-to-inferred');
-        return convertToInferred(tree, options);
+    return (0, internal_1.migrateRemovedExecutors)(tree, removedExecutors, async (tree, options) => {
+        const converter = require('../../generators/convert-to-inferred/convert-to-inferred');
+        const unconverted = rewriteTargetsWithUndetectedConfig(tree);
+        try {
+            return await converter.convertToInferred(tree, options);
+        }
+        finally {
+            restoreTargets(tree, unconverted);
+        }
     });
 }
+/**
+ * @nx/jest/plugin infers a project's target only from `jest.config.<ext>` in
+ * its root, so a target running another config becomes an explicit command.
+ * A target that can't be rewritten is removed and returned, because the
+ * converter would switch it to the project's `jest.config.<ext>`.
+ */
+function rewriteTargetsWithUndetectedConfig(tree) {
+    const targetDefaults = (0, devkit_1.readNxJson)(tree)?.targetDefaults;
+    const unconvertedByProject = new Map();
+    for (const [projectName, project] of (0, devkit_1.getProjects)(tree)) {
+        const unconverted = {};
+        let changed = false;
+        for (const [targetName, target] of Object.entries(project.targets ?? {})) {
+            if (!removedExecutors.includes(target.executor)) {
+                continue;
+            }
+            const readDefaults = (executor) => (0, internal_1.readTargetDefaultsForTarget)(targetName, targetDefaults, executor, {
+                projectName,
+                projectNode: { name: projectName, type: 'lib', data: project },
+            });
+            let runsUndetectedConfig = false;
+            try {
+                const executorDefaults = readDefaults(target.executor);
+                const resolved = resolveTarget(target, executorDefaults, project, `${projectName}:${targetName}`);
+                const jestConfig = resolved.options?.jestConfig;
+                if (!jestConfig || isProjectRootJestConfig(jestConfig, project.root)) {
+                    continue;
+                }
+                runsUndetectedConfig = true;
+                const rewritten = toRunCommandsTarget(resolved);
+                assertDefaultsKeepTarget(rewritten, executorDefaults, readDefaults('nx:run-commands'));
+                project.targets[targetName] = rewritten;
+                changed = true;
+            }
+            catch (error) {
+                devkit_1.logger.warn(`Could not rewrite target "${targetName}" in project "${projectName}" to run Jest with its config file: ${String(error)}`);
+                if (runsUndetectedConfig) {
+                    unconverted[targetName] = target;
+                    delete project.targets[targetName];
+                    changed = true;
+                }
+            }
+        }
+        if (changed) {
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
+        }
+        if (Object.keys(unconverted).length) {
+            unconvertedByProject.set(projectName, unconverted);
+        }
+    }
+    return unconvertedByProject;
+}
+function restoreTargets(tree, targetsByProject) {
+    for (const [projectName, targets] of targetsByProject) {
+        // Read again to keep what the converter did to sibling targets
+        const project = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+        project.targets = { ...project.targets, ...targets };
+        (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
+    }
+}
+/**
+ * The target merged with the defaults the removed executor received, with Nx
+ * tokens resolved.
+ */
+function resolveTarget(target, defaults, project, key) {
+    const resolved = (0, internal_1.mergeTargetConfigurations)(structuredClone(target), structuredClone(defaults ?? {}));
+    if (resolved.options) {
+        resolved.options = (0, internal_1.resolveNxTokensInOptions)(resolved.options, project, key);
+    }
+    for (const name of Object.keys(resolved.configurations ?? {})) {
+        resolved.configurations[name] = (0, internal_1.resolveNxTokensInOptions)(resolved.configurations[name], project, `${key}:${name}`);
+    }
+    return resolved;
+}
+/**
+ * Target defaults are matched by executor, so the rewritten target can get
+ * entries the removed executor never did. They must not change it.
+ */
+function assertDefaultsKeepTarget(target, executorDefaults, runCommandsDefaults) {
+    if (!runCommandsDefaults) {
+        return;
+    }
+    // The executor got these entries too, and the target holds their values
+    // translated for Jest
+    if ((0, node_util_1.isDeepStrictEqual)(executorDefaults, runCommandsDefaults)) {
+        return;
+    }
+    if (!(0, node_util_1.isDeepStrictEqual)(withDefaults(target, runCommandsDefaults), withDefaults(target, {}))) {
+        throw new Error('The target defaults that apply to nx:run-commands targets would change it.');
+    }
+}
+// Resolves '...' spreads too, and drops the undefined values the merge leaves
+function withDefaults(target, defaults) {
+    return JSON.parse(JSON.stringify((0, internal_1.mergeTargetConfigurations)(structuredClone(target), structuredClone(defaults), undefined, undefined, undefined, false)));
+}
+function isProjectRootJestConfig(jestConfig, projectRoot) {
+    const path = node_path_1.posix.normalize(jestConfig);
+    return config_file_1.jestConfigExtensions.some((ext) => path === node_path_1.posix.join(projectRoot, `jest.config.${ext}`));
+}
+// Relative, and left unchanged by sh, cmd.exe and nx:run-commands
+function isPlainPath(value) {
+    return typeof value === 'string' && /^[\w@+.-][\w@+./-]*$/.test(value);
+}
+function assertAcceptedOptions(options) {
+    for (const [name, value] of Object.entries(options)) {
+        if (!acceptedOptions.get(name)?.(value)) {
+            throw new Error(`The rewrite does not accept the "${name}" option set to ${JSON.stringify(value)}.`);
+        }
+    }
+}
+// jestConfig becomes the command, and the executor never passed tsConfig to Jest
+function toJestOptions({ jestConfig: _jestConfig, tsConfig: _tsConfig, codeCoverage, ...flags }) {
+    return codeCoverage === undefined
+        ? flags
+        : { ...flags, coverage: codeCoverage };
+}
+// The leading ./ is what the move generator rewrites for a root project
+function jestCommand(jestConfig) {
+    return `jest --config ${(0, internal_1.toProjectRelativePath)(node_path_1.posix.normalize(jestConfig), '.')}`;
+}
+function optionsFor(target, configuration) {
+    return {
+        ...target.options,
+        ...(configuration ? target.configurations[configuration] : {}),
+    };
+}
+function toRunCommandsTarget(target) {
+    const { executor: _executor, options, configurations, ...rest } = target;
+    const configurationNames = Object.keys(configurations ?? {});
+    for (const values of [options, ...Object.values(configurations ?? {})]) {
+        assertAcceptedOptions(values);
+    }
+    for (const name of [undefined, ...configurationNames]) {
+        const values = optionsFor(target, name);
+        // runCLI accepted this pair, but Jest's CLI rejects it
+        if (values.runInBand === true && 'maxWorkers' in values) {
+            throw new Error('Jest rejects runInBand with maxWorkers on its CLI.');
+        }
+    }
+    const rewritten = {
+        executor: 'nx:run-commands',
+        ...rest,
+        options: {
+            command: jestCommand(options.jestConfig),
+            // The executor ran from where nx started, usually the workspace root.
+            // Set explicitly, so an nx:run-commands default's cwd can't apply.
+            cwd: '.',
+            env: { TS_NODE_COMPILER_OPTIONS: tsNodeCompilerOptions },
+            ...toJestOptions(options),
+        },
+    };
+    if (configurations) {
+        rewritten.configurations = Object.fromEntries(configurationNames.map((name) => {
+            const { jestConfig } = configurations[name];
+            return [
+                name,
+                {
+                    ...(jestConfig ? { command: jestCommand(jestConfig) } : {}),
+                    ...toJestOptions(configurations[name]),
+                },
+            ];
+        }));
+    }
+    const outputOptions = [
+        ...(rest.outputs ?? []).join(' ').matchAll(/\{options\.(\w+)/g),
+    ].map(([, name]) => name);
+    for (const name of [undefined, ...configurationNames]) {
+        const before = optionsFor(target, name);
+        const after = optionsFor(rewritten, name);
+        const changed = outputOptions.find((option) => !(0, node_util_1.isDeepStrictEqual)(before[option], after[option]));
+        if (changed) {
+            throw new Error(`An output reads the "${changed}" option, which the rewrite changes.`);
+        }
+    }
+    return rewritten;
+}

package/dist/src/migrations/update-24-0-0/remove-deprecated-executors.md

@@ -2,6 +2,22 @@
 
 Nx 24 removes the `@nx/jest:jest` executor and its `@nrwl/jest:jest` alias. The migration registers `@nx/jest/plugin` in `nx.json` and converts the targets that use those executors to inferred tasks. Options the plugin does not infer stay on the target. A target with nothing left to override is removed from project configuration. When several projects share the same remaining options, those options move to a `targetDefaults` entry scoped to the plugin. `targetDefaults` entries keyed by a removed executor are removed once no target uses that executor.
 
+The plugin only infers a target from `jest.config.<ext>` in the project root. A target that runs any other config file, such as a root project's `jest.config.app.ts`, becomes an `nx:run-commands` target that runs `jest --config <file>` from the workspace root. It keeps the options, configurations and target defaults it used. The executor ran Jest from the directory `nx` started in, so a run started from another directory now uses the workspace root too.
+
+The rewrite accepts only these options, in the target and in each configuration:
+
+- `jestConfig`, set to a relative path made of ASCII letters, digits and `_ @ + . / -`. A configuration's `jestConfig` becomes its own command.
+- `codeCoverage`, `bail`, `ci`, `detectOpenHandles`, `forceExit`, `logHeapUsage`, `passWithNoTests`, `runInBand` and `silent`, set to `true` or `false`. `codeCoverage` becomes `--coverage`.
+- `maxWorkers` and `testTimeout`, set to a positive integer.
+- `tsConfig`, which Jest never read. The rewrite drops it.
+
+The target keeps the removed executor, and the migration lists it, in these cases:
+
+- It sets any other option, or sets an accepted option to another kind of value.
+- It sets `runInBand: true` together with `maxWorkers`, also through a configuration. Jest's CLI rejects that pair.
+- An output reads an option the rewrite removes or renames, such as `{options.tsConfig}`.
+- `targetDefaults` that apply to `nx:run-commands` targets would change it.
+
 The migration lists the targets the converter cannot convert safely. In agentic runs, an AI prompt finishes them and validates the project graph.
 
 #### Sample code changes

package/dist/src/plugins/plugin.js

@@ -5,6 +5,8 @@ const tslib_1 = require("tslib");
 const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
 const minimatch_1 = require("minimatch");
+const picomatch = require("picomatch");
+const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const posix = tslib_1.__importStar(require("node:path/posix"));
@@ -206,7 +208,6 @@ async function buildJestTargets(rawConfig, needsDtsInputs, configFilePath, proje
                     [groupName]: targetGroup,
                 },
             };
-            const specIgnoreRegexes = rawConfig.testPathIgnorePatterns?.map((p) => new RegExp(replaceRootDirInPath(projectRoot, p)));
             for (const testPath of specs) {
                 const relativePath = (0, devkit_1.normalizePath)((0, node_path_1.relative)((0, node_path_1.join)(context.workspaceRoot, projectRoot), testPath));
                 if (relativePath.includes('../')) {
@@ -219,9 +220,6 @@ async function buildJestTargets(rawConfig, needsDtsInputs, configFilePath, proje
                             testMatch,
                         }, null, 2)}`);
                 }
-                if (specIgnoreRegexes?.some((regex) => regex.test(relativePath))) {
-                    continue;
-                }
                 const targetName = `${options.ciTargetName}--${relativePath}`;
                 dependsOn.push({
                     target: targetName,
@@ -606,21 +604,152 @@ function requireJestUtil(packageName, projectRoot, workspaceRoot) {
         paths: [(0, node_path_1.dirname)(resolvedJestCorePaths[jestPath])],
     }));
 }
+// Defaults copied from https://github.com/jestjs/jest/blob/d1a2ed7/packages/jest-config/src/Defaults.ts
+const DEFAULT_TEST_MATCH = [
+    '**/__tests__/**/*.?([mc])[jt]s?(x)',
+    '**/?(*.)+(spec|test).?([mc])[jt]s?(x)',
+];
+const DEFAULT_MODULE_FILE_EXTENSIONS = [
+    'js',
+    'mjs',
+    'cjs',
+    'jsx',
+    'ts',
+    'mts',
+    'cts',
+    'tsx',
+    'json',
+    'node',
+];
+// Mirrors how Jest selects test files: jest-haste-map's file list, then
+// SearchSource's checks, all on the absolute path
 async function getTestPaths(projectRoot, rawConfig, rootDir, context, presetCache) {
-    const testMatch = await getJestOption(rawConfig, rootDir, 'testMatch', presetCache);
-    let paths = await (0, internal_1.globWithWorkspaceContext)(context.workspaceRoot, (testMatch || [
-        // Default copied from https://github.com/jestjs/jest/blob/d1a2ed7/packages/jest-config/src/Defaults.ts#L84
-        '**/__tests__/**/*.?([mc])[jt]s?(x)',
-        '**/?(*.)+(spec|test).?([mc])[jt]s?(x)',
-    ]).map((pattern) => posix.join(projectRoot, pattern)), []);
-    const testRegex = await getJestOption(rawConfig, rootDir, 'testRegex', presetCache);
-    if (testRegex) {
-        const testRegexes = Array.isArray(rawConfig.testRegex)
-            ? rawConfig.testRegex.map((r) => new RegExp(r))
-            : [new RegExp(rawConfig.testRegex)];
-        paths = paths.filter((path) => testRegexes.some((r) => r.test(path)));
-    }
-    return { specs: paths, testMatch };
+    // Jest resolves rootDir's symlinks. Resolve the workspace root with it so
+    // file paths still compare; a default rootDir needs neither
+    let workspaceRoot = context.workspaceRoot;
+    if (rawConfig.rootDir) {
+        rootDir = tryRealpath(rootDir);
+        workspaceRoot = tryRealpath(workspaceRoot);
+    }
+    const preset = await loadPresetConfig(rawConfig, rootDir, presetCache);
+    // jest-config lets a key the config sets override the preset, even when empty
+    const getOption = (name, defaultValue) => (Object.hasOwn(rawConfig, name) ? rawConfig : preset)?.[name] ??
+        defaultValue;
+    const toArray = (value) => Array.isArray(value) ? value : [value];
+    const posixRootDir = (0, devkit_1.normalizePath)(rootDir);
+    const toRegExp = (patterns) => patterns.length > 0
+        ? new RegExp(patterns
+            .map((pattern) => pattern.replaceAll('<rootDir>', posixRootDir))
+            .join('|'))
+        : undefined;
+    // jest-config reads a falsy testRegex as none
+    const testRegex = toArray(getOption('testRegex', []) || []);
+    // jest-config drops the default testMatch when testRegex is set
+    const testMatch = toArray(getOption('testMatch', testRegex.length > 0 ? [] : DEFAULT_TEST_MATCH));
+    const roots = getOption('roots', ['<rootDir>']).map((root) => `${(0, devkit_1.normalizePath)((0, node_path_1.resolve)(rootDir, replaceRootDirInPath(rootDir, root)))}/`);
+    const extensions = new Set([
+        'snap',
+        ...getOption('moduleFileExtensions', DEFAULT_MODULE_FILE_EXTENSIONS),
+    ]);
+    // jest-config swaps its default haste, which sets forceNodeFilesystemAPI,
+    // for any haste the config or preset sets, even an empty one
+    const hasteConfig = [rawConfig, preset].find((config) => config && Object.hasOwn(config, 'haste'));
+    const useNativeFind = !!hasteConfig &&
+        !hasteConfig.haste?.forceNodeFilesystemAPI &&
+        (await hasNativeFindSupport());
+    // jest-haste-map's native find crawler matches extensions as
+    // case-insensitive suffixes, its Node API crawler as the last extension
+    const suffixes = [...extensions].map((ext) => `.${ext}`.toLowerCase());
+    const hasExtension = useNativeFind
+        ? (path) => {
+            const lowerCasePath = path.toLowerCase();
+            return suffixes.some((suffix) => lowerCasePath.endsWith(suffix));
+        }
+        : (path) => extensions.has((0, node_path_1.extname)(path).slice(1));
+    // jest-config concatenates preset and config modulePathIgnorePatterns
+    const modulePathIgnorePattern = toRegExp((preset?.modulePathIgnorePatterns ?? []).concat(rawConfig.modulePathIgnorePatterns ?? []));
+    const testPathIgnorePattern = toRegExp(getOption('testPathIgnorePatterns', ['/node_modules/']));
+    const testRegexes = testRegex.map((regex) => new RegExp(regex));
+    // Globbing from the project root already applies `**/` globs, so only other
+    // globs need a match check
+    const testMatchers = testMatch.every((pattern) => pattern.startsWith('**/'))
+        ? []
+        : testMatch.map((pattern) => {
+            // Built like jest-util's: minimatch would read `(a|b)` groups literally
+            const isMatch = picomatch(replacePathSepForGlob(replaceRootDirInPath(escapeGlobCharacters(rootDir), pattern)), { dot: true }, true);
+            return {
+                isMatch,
+                negated: isMatch.state.negated || !!isMatch.state.negatedExtglob,
+            };
+        });
+    // Unless every testMatch glob is negated, a file must match a non-negated one
+    const includePatterns = testMatch.filter((_, i) => !testMatchers[i]?.negated);
+    const candidates = await (0, internal_1.globWithWorkspaceContext)(context.workspaceRoot, includePatterns.length > 0
+        ? includePatterns.map((pattern) => {
+            const path = replaceRootDirInPath(rootDir, pattern);
+            return (0, node_path_1.isAbsolute)(path)
+                ? (0, devkit_1.normalizePath)((0, node_path_1.relative)(workspaceRoot, path))
+                : posix.join(projectRoot, pattern);
+        })
+        : [posix.join(projectRoot, '**/*')], []);
+    const workspacePath = (0, devkit_1.normalizePath)((0, node_path_1.join)(workspaceRoot, '/'));
+    const specs = candidates.filter((file) => {
+        const path = workspacePath + file;
+        return (hasExtension(path) &&
+            !modulePathIgnorePattern?.test(path) &&
+            roots.some((root) => path.includes(root)) &&
+            (testMatchers.length === 0 || matchesGlobs(testMatchers, path)) &&
+            !testPathIgnorePattern?.test(path) &&
+            (testRegexes.length === 0 || testRegexes.some((r) => r.test(path))));
+    });
+    return { specs, testMatch };
+}
+function matchesGlobs(matchers, path) {
+    let kept;
+    for (const { isMatch, negated } of matchers) {
+        const matched = isMatch(path);
+        if (!matched && negated) {
+            kept = false;
+        }
+        else if (matched && !negated) {
+            kept = true;
+        }
+    }
+    return matchers.every(({ negated }) => negated)
+        ? kept !== false
+        : kept === true;
+}
+// Ports of the jest-config and jest-util helpers Jest uses to put rootDir into
+// testMatch globs
+function escapeGlobCharacters(path) {
+    return path.replaceAll(/([!()*?[\\\]{}])/g, '\\$1');
+}
+function replacePathSepForGlob(path) {
+    return path.replaceAll(/\\(?![$()+.?^{}])/g, '/');
+}
+function tryRealpath(path) {
+    try {
+        return node_fs_1.realpathSync.native(path);
+    }
+    catch {
+        return path;
+    }
+}
+let nativeFindSupport;
+// Port of jest-haste-map's check for a find that supports -iname, cached
+// because the find on PATH doesn't change during a process lifetime
+function hasNativeFindSupport() {
+    nativeFindSupport ??= new Promise((done) => {
+        try {
+            const child = (0, node_child_process_1.spawn)('find', ['.', '-type', 'f', '(', '-iname', '*.ts', '-o', '-iname', '*.js', ')'], { cwd: __dirname, stdio: 'ignore', windowsHide: true });
+            child.on('error', () => done(false));
+            child.on('exit', (code) => done(code === 0));
+        }
+        catch {
+            done(false);
+        }
+    });
+    return nativeFindSupport;
 }
 /**
  * Collects workspace-relative paths to files whose CONTENT the plugin reads
@@ -939,11 +1068,3 @@ function getTsJestMajorVersion() {
     }
     return cachedTsJestMajorVersion;
 }
-async function getJestOption(rawConfig, rootDir, optionName, presetCache) {
-    if (rawConfig[optionName])
-        return rawConfig[optionName];
-    const preset = await loadPresetConfig(rawConfig, rootDir, presetCache);
-    if (preset?.[optionName])
-        return preset[optionName];
-    return undefined;
-}

package/dist/src/utils/config/get-jest-projects.d.ts

@@ -1,11 +1,11 @@
 /**
  * Get a list of paths to all the jest config files
- * using the Nx Jest executor and `@nx/run:commands`
- * running `jest`.
+ * used by `nx:run-commands` targets running `jest`,
+ * including the targets `@nx/jest/plugin` infers.
  *
  * This is used to configure Jest multi-project support.
  *
- * To add a project not using the Nx Jest executor:
+ * To add a project without such a target:
  * export default async () => ({
  *   projects: [...(await getJestProjectsAsync()), '<rootDir>/path/to/jest.config.ts'];
  * });

package/dist/src/utils/config/get-jest-projects.js

@@ -10,12 +10,12 @@ function getJestConfigProjectPath(projectJestConfigPath) {
 }
 /**
  * Get a list of paths to all the jest config files
- * using the Nx Jest executor and `@nx/run:commands`
- * running `jest`.
+ * used by `nx:run-commands` targets running `jest`,
+ * including the targets `@nx/jest/plugin` infers.
  *
  * This is used to configure Jest multi-project support.
  *
- * To add a project not using the Nx Jest executor:
+ * To add a project without such a target:
  * export default async () => ({
  *   projects: [...(await getJestProjectsAsync()), '<rootDir>/path/to/jest.config.ts'];
  * });
@@ -33,11 +33,7 @@ async function getJestProjectsAsync() {
             continue;
         }
         for (const targetConfiguration of Object.values(projectConfig.targets)) {
-            if (targetConfiguration.executor === '@nx/jest:jest' ||
-                targetConfiguration.executor === '@nrwl/jest:jest') {
-                collectJestConfigFromJestExecutor(targetConfiguration, jestConfigurations);
-            }
-            else if (targetConfiguration.executor === 'nx:run-commands') {
+            if (targetConfiguration.executor === 'nx:run-commands') {
                 collectJestConfigFromRunCommandsExecutor(targetConfiguration, projectConfig.root, jestConfigurations);
             }
         }
@@ -55,18 +51,6 @@ function removeDuplicates(configs) {
             configs.delete(dir);
     });
 }
-function collectJestConfigFromJestExecutor(targetConfiguration, jestConfigurations) {
-    if (targetConfiguration.options?.jestConfig) {
-        jestConfigurations.add(getJestConfigProjectPath(targetConfiguration.options.jestConfig));
-    }
-    if (targetConfiguration.configurations) {
-        for (const configurationObject of Object.values(targetConfiguration.configurations)) {
-            if (configurationObject.jestConfig) {
-                jestConfigurations.add(getJestConfigProjectPath(configurationObject.jestConfig));
-            }
-        }
-    }
-}
 function collectJestConfigFromRunCommandsExecutor(targetConfiguration, projectRoot, jestConfigurations) {
     if (targetConfiguration.options?.command) {
         collectJestConfigFromCommand(targetConfiguration.options.command, targetConfiguration.options.cwd ?? projectRoot, jestConfigurations);
@@ -80,12 +64,16 @@ function collectJestConfigFromRunCommandsExecutor(targetConfiguration, projectRo
     if (targetConfiguration.configurations) {
         for (const configurationObject of Object.values(targetConfiguration.configurations)) {
             if (configurationObject.command) {
-                collectJestConfigFromCommand(configurationObject.command, configurationObject.cwd ?? projectRoot, jestConfigurations);
+                collectJestConfigFromCommand(configurationObject.command, configurationObject.cwd ??
+                    targetConfiguration.options?.cwd ??
+                    projectRoot, jestConfigurations);
             }
             else if (configurationObject.commands) {
                 for (const command of configurationObject.commands) {
                     const commandScript = typeof command === 'string' ? command : command.command;
-                    collectJestConfigFromCommand(commandScript, configurationObject.cwd ?? projectRoot, jestConfigurations);
+                    collectJestConfigFromCommand(commandScript, configurationObject.cwd ??
+                        targetConfiguration.options?.cwd ??
+                        projectRoot, jestConfigurations);
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/jest",
-  "version": "24.0.0",
+  "version": "24.0.2",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -103,21 +103,22 @@
     }
   },
   "dependencies": {
-    "@nx/devkit": "24.0.0",
-    "@nx/js": "24.0.0",
+    "@nx/devkit": "24.0.2",
+    "@nx/js": "24.0.2",
     "@phenomnomnominal/tsquery": "~6.2.0",
     "identity-obj-proxy": "3.0.0",
     "jest-config": "^30.0.2",
     "jest-resolve": "^30.0.2",
     "jsonc-parser": "^3.2.0",
     "minimatch": "10.2.5",
+    "picomatch": "4.0.4",
     "resolve.exports": "2.0.3",
     "semver": "^7.6.3",
     "tslib": "^2.3.0",
     "yargs-parser": "21.1.1"
   },
   "devDependencies": {
-    "nx": "24.0.0"
+    "nx": "24.0.2"
   },
   "publishConfig": {
     "access": "public"