@nx/jest 24.0.0-rc.1 → 24.0.1

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/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-rc.1",
+  "version": "24.0.1",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -103,8 +103,8 @@
     }
   },
   "dependencies": {
-    "@nx/devkit": "24.0.0-rc.1",
-    "@nx/js": "24.0.0-rc.1",
+    "@nx/devkit": "24.0.1",
+    "@nx/js": "24.0.1",
     "@phenomnomnominal/tsquery": "~6.2.0",
     "identity-obj-proxy": "3.0.0",
     "jest-config": "^30.0.2",
@@ -117,7 +117,7 @@
     "yargs-parser": "21.1.1"
   },
   "devDependencies": {
-    "nx": "24.0.0-rc.1"
+    "nx": "24.0.1"
   },
   "publishConfig": {
     "access": "public"