@nx/jest 22.6.0-beta.12 → 22.6.0-beta.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/jest",
-  "version": "22.6.0-beta.12",
+  "version": "22.6.0-beta.14",
   "private": false,
   "description": "The Nx Plugin for Jest contains executors and generators allowing your workspace to use the powerful Jest testing capabilities.",
   "repository": {
@@ -37,8 +37,8 @@
   "dependencies": {
     "@jest/reporters": "^30.0.2",
     "@jest/test-result": "^30.0.2",
-    "@nx/devkit": "22.6.0-beta.12",
-    "@nx/js": "22.6.0-beta.12",
+    "@nx/devkit": "22.6.0-beta.14",
+    "@nx/js": "22.6.0-beta.14",
     "@phenomnomnominal/tsquery": "~6.1.4",
     "identity-obj-proxy": "3.0.0",
     "jest-config": "^30.0.2",
@@ -52,7 +52,7 @@
     "yargs-parser": "21.1.1"
   },
   "devDependencies": {
-    "nx": "22.6.0-beta.12"
+    "nx": "22.6.0-beta.14"
   },
   "publishConfig": {
     "access": "public"

package/src/plugins/plugin.d.ts

@@ -12,6 +12,16 @@ export interface JestPluginOptions {
      *  and test matcher instead of Jest's.
      */
     disableJestRuntime?: boolean;
+    /**
+     * Whether to use Jest's resolver (jest-resolve) for resolving config file
+     * references (presets, transforms, setup files, module name mappers, etc.)
+     * as task inputs. When false, uses path-based classification which is fast
+     * but cannot follow symlinks or honor custom moduleDirectories/modulePaths.
+     * Enable this if your config references workspace-linked packages or relies
+     * on Jest-specific resolution behavior.
+     * @default true when disableJestRuntime is false, false otherwise
+     */
+    useJestResolver?: boolean;
 }
 export declare const createNodes: CreateNodesV2<JestPluginOptions>;
 export declare const createNodesV2: CreateNodesV2<JestPluginOptions>;

package/src/plugins/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../../../packages/jest/src/plugins/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,aAAa,EASd,MAAM,YAAY,CAAC;AA4BpB,MAAM,WAAW,iBAAiB;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAmBD,eAAO,MAAM,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAiFxD,CAAC;AAEF,eAAO,MAAM,aAAa,kCAAc,CAAC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../../../packages/jest/src/plugins/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,aAAa,EASd,MAAM,YAAY,CAAC;AA6BpB,MAAM,WAAW,iBAAiB;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAmBD,eAAO,MAAM,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAiFxD,CAAC;AAEF,eAAO,MAAM,aAAa,kCAAc,CAAC"}

package/src/plugins/plugin.js

@@ -17,6 +17,7 @@ const plugins_1 = require("nx/src/utils/plugins");
 const workspace_context_1 = require("nx/src/utils/workspace-context");
 const versions_1 = require("../utils/versions");
 const pmc = (0, devkit_1.getPackageManagerCommand)();
+const REPORTER_BUILTINS = new Set(['default', 'github-actions', 'summary']);
 function readTargetsCache(cachePath) {
     return process.env.NX_CACHE_PROJECT_GRAPH !== 'false' && (0, node_fs_1.existsSync)(cachePath)
         ? (0, devkit_1.readJsonFile)(cachePath)
@@ -147,8 +148,13 @@ async function buildJestTargets(configFilePath, projectRoot, options, context, p
     });
     // Not normalizing it here since also affects options for convert-to-inferred.
     const disableJestRuntime = options.disableJestRuntime !== false;
+    const useJestResolver = options.useJestResolver ?? !disableJestRuntime;
+    // Jest defaults rootDir to the config file's directory, but allows overrides
+    const rootDir = rawConfig.rootDir
+        ? (0, node_path_1.resolve)((0, node_path_1.dirname)(absConfigFilePath), rawConfig.rootDir)
+        : (0, node_path_1.resolve)(context.workspaceRoot, projectRoot);
     const cache = (target.cache = true);
-    const inputs = (target.inputs = getInputs(namedInputs, rawConfig.preset, projectRoot, context.workspaceRoot, disableJestRuntime));
+    const inputs = (target.inputs = await getInputs(namedInputs, rawConfig, rootDir, projectRoot, context.workspaceRoot, presetCache, useJestResolver));
     let metadata;
     const groupName = options?.ciGroupName ?? (0, plugins_1.deriveGroupNameFromTarget)(options?.ciTargetName);
     if (disableJestRuntime) {
@@ -156,7 +162,7 @@ async function buildJestTargets(configFilePath, projectRoot, options, context, p
             ? (0, node_path_1.join)(context.workspaceRoot, projectRoot, rawConfig.coverageDirectory)
             : undefined, undefined, context));
         if (options?.ciTargetName) {
-            const { specs, testMatch } = await getTestPaths(projectRoot, rawConfig, absConfigFilePath, context, presetCache);
+            const { specs, testMatch } = await getTestPaths(projectRoot, rawConfig, rootDir, context, presetCache);
             const targetGroup = [];
             const dependsOn = [];
             metadata = {
@@ -341,71 +347,79 @@ async function buildJestTargets(configFilePath, projectRoot, options, context, p
     }
     return { targets, metadata };
 }
-function getInputs(namedInputs, preset, projectRoot, workspaceRoot, disableJestRuntime) {
+async function getInputs(namedInputs, rawConfig, rootDir, projectRoot, workspaceRoot, presetCache, useJestResolver) {
     const inputs = [
         ...('production' in namedInputs
             ? ['default', '^production']
             : ['default', '^default']),
     ];
     const externalDependencies = ['jest'];
-    const presetInput = disableJestRuntime
-        ? resolvePresetInputWithoutJestResolver(preset, projectRoot, workspaceRoot)
-        : resolvePresetInputWithJestResolver(preset, projectRoot, workspaceRoot);
+    const resolvedModulePaths = rawConfig.modulePaths?.map((p) => replaceRootDirInPath(rootDir, p));
+    const jestResolve = useJestResolver
+        ? requireJestUtil('jest-resolve', projectRoot, workspaceRoot).default
+        : null;
+    const presetInput = jestResolve
+        ? resolvePresetInputWithJestResolver(rawConfig.preset, rootDir, projectRoot, workspaceRoot, jestResolve, rawConfig.moduleDirectories, resolvedModulePaths)
+        : resolvePresetInputWithoutJestResolver(rawConfig.preset, rootDir, projectRoot, workspaceRoot);
+    // Track preset file path to avoid duplicating it with config-derived inputs
+    let presetInputPath = null;
     if (presetInput) {
         if (typeof presetInput !== 'string' &&
             'externalDependencies' in presetInput) {
             externalDependencies.push(...presetInput.externalDependencies);
         }
         else {
+            presetInputPath = presetInput;
             inputs.push(presetInput);
         }
     }
+    const resolveFilePath = jestResolve
+        ? createJestResolveFilePathResolver(rootDir, projectRoot, workspaceRoot, jestResolve, rawConfig.moduleDirectories, resolvedModulePaths)
+        : createFilePathResolverWithoutJest(rootDir, projectRoot, workspaceRoot);
+    const configInputs = await getConfigFileInputs(rawConfig, rootDir, presetCache, resolveFilePath);
+    for (const fileInput of configInputs.fileInputs) {
+        if (fileInput !== presetInputPath) {
+            inputs.push(fileInput);
+        }
+    }
+    for (const dep of configInputs.externalDeps) {
+        if (!externalDependencies.includes(dep)) {
+            externalDependencies.push(dep);
+        }
+    }
     inputs.push({ externalDependencies });
     return inputs;
 }
-function resolvePresetInputWithoutJestResolver(presetValue, projectRoot, workspaceRoot) {
+function resolvePresetInputWithoutJestResolver(presetValue, rootDir, projectRoot, workspaceRoot) {
     if (!presetValue)
         return null;
-    const presetPath = replaceRootDirInPath(projectRoot, presetValue);
-    const isNpmPackage = !presetValue.startsWith('.') && !(0, node_path_1.isAbsolute)(presetPath);
-    if (isNpmPackage) {
-        return { externalDependencies: [presetValue] };
-    }
-    if (presetPath.startsWith('..')) {
-        const relativePath = (0, node_path_1.relative)(workspaceRoot, (0, node_path_1.join)(projectRoot, presetPath));
-        return (0, node_path_1.join)('{workspaceRoot}', relativePath);
-    }
-    else {
-        const relativePath = (0, node_path_1.relative)(projectRoot, presetPath);
-        return (0, node_path_1.join)('{projectRoot}', relativePath);
+    const presetPath = replaceRootDirInPath(rootDir, presetValue);
+    const isNpmLike = !presetValue.startsWith('.') && !(0, node_path_1.isAbsolute)(presetPath);
+    if (isNpmLike) {
+        return { externalDependencies: [extractPackageName(presetValue)] };
     }
+    const absoluteProjectRoot = (0, node_path_1.resolve)(workspaceRoot, projectRoot);
+    return classifyResolvedPath((0, node_path_1.resolve)(rootDir, presetPath), absoluteProjectRoot, workspaceRoot);
 }
 // preset resolution adapted from:
 // https://github.com/jestjs/jest/blob/c54bccd657fb4cf060898717c09f633b4da3eec4/packages/jest-config/src/normalize.ts#L122
-function resolvePresetInputWithJestResolver(presetValue, projectRoot, workspaceRoot) {
+function resolvePresetInputWithJestResolver(presetValue, rootDir, projectRoot, workspaceRoot, jestResolve, moduleDirectories, modulePaths) {
     if (!presetValue)
         return null;
-    let presetPath = replaceRootDirInPath(projectRoot, presetValue);
-    const isNpmPackage = !presetValue.startsWith('.') && !(0, node_path_1.isAbsolute)(presetPath);
+    let presetPath = replaceRootDirInPath(rootDir, presetValue);
     presetPath = presetPath.startsWith('.')
         ? presetPath
         : (0, node_path_1.join)(presetPath, 'jest-preset');
-    const { default: jestResolve } = requireJestUtil('jest-resolve', projectRoot, workspaceRoot);
-    const absoluteProjectRoot = (0, node_path_1.join)(workspaceRoot, projectRoot);
     const presetModule = jestResolve.findNodeModule(presetPath, {
-        basedir: absoluteProjectRoot,
+        basedir: rootDir,
         extensions: ['.json', '.js', '.cjs', '.mjs'],
+        moduleDirectory: moduleDirectories,
+        paths: modulePaths,
     });
     if (!presetModule) {
         return null;
     }
-    if (isNpmPackage) {
-        return { externalDependencies: [presetValue] };
-    }
-    const relativePath = (0, node_path_1.relative)(absoluteProjectRoot, presetModule);
-    return relativePath.startsWith('..')
-        ? (0, node_path_1.join)('{workspaceRoot}', (0, node_path_1.join)(projectRoot, relativePath))
-        : (0, node_path_1.join)('{projectRoot}', relativePath);
+    return classifyResolvedPath(presetModule, (0, node_path_1.resolve)(workspaceRoot, projectRoot), workspaceRoot);
 }
 // Adapted from here https://github.com/jestjs/jest/blob/c13bca3/packages/jest-config/src/utils.ts#L57-L69
 function replaceRootDirInPath(rootDir, filePath) {
@@ -414,6 +428,79 @@ function replaceRootDirInPath(rootDir, filePath) {
     }
     return (0, node_path_1.resolve)(rootDir, (0, node_path_1.normalize)(`./${filePath.slice('<rootDir>'.length)}`));
 }
+function classifyResolvedPath(absolutePath, absoluteProjectRoot, workspaceRoot) {
+    const relToWorkspace = (0, devkit_1.normalizePath)((0, node_path_1.relative)(workspaceRoot, absolutePath));
+    if (relToWorkspace.includes('node_modules/')) {
+        const nmIndex = relToWorkspace.lastIndexOf('node_modules/');
+        const afterNm = relToWorkspace.slice(nmIndex + 'node_modules/'.length);
+        return { externalDependencies: [extractPackageName(afterNm)] };
+    }
+    const relToProject = (0, devkit_1.normalizePath)((0, node_path_1.relative)(absoluteProjectRoot, absolutePath));
+    if (relToProject.startsWith('..')) {
+        return (0, devkit_1.joinPathFragments)('{workspaceRoot}', relToWorkspace);
+    }
+    return (0, devkit_1.joinPathFragments)('{projectRoot}', relToProject);
+}
+function extractPackageName(value) {
+    const parts = value.split('/');
+    return value.startsWith('@') ? `${parts[0]}/${parts[1]}` : parts[0];
+}
+function createFilePathResolverWithoutJest(rootDir, projectRoot, workspaceRoot) {
+    const absoluteProjectRoot = (0, node_path_1.resolve)(workspaceRoot, projectRoot);
+    return (filePath) => {
+        const resolvedPath = replaceRootDirInPath(rootDir, filePath);
+        if (looksLikePackageName(filePath, resolvedPath)) {
+            return { externalDependencies: [extractPackageName(filePath)] };
+        }
+        return classifyResolvedPath((0, node_path_1.resolve)(rootDir, resolvedPath), absoluteProjectRoot, workspaceRoot);
+    };
+}
+function resolveWithPrefixFallback(filePath, prefix, resolver) {
+    if (!filePath.startsWith('.') &&
+        !filePath.startsWith('<rootDir>') &&
+        !(0, node_path_1.isAbsolute)(filePath) &&
+        !filePath.startsWith(prefix)) {
+        const prefixed = resolver(`${prefix}${filePath}`);
+        if (prefixed)
+            return prefixed;
+    }
+    return resolver(filePath);
+}
+function looksLikePackageName(filePath, resolvedPath) {
+    return (!filePath.startsWith('.') &&
+        !filePath.startsWith('<rootDir>') &&
+        !(0, node_path_1.isAbsolute)(resolvedPath));
+}
+function createJestResolveFilePathResolver(rootDir, projectRoot, workspaceRoot, jestResolve, moduleDirectories, modulePaths) {
+    const absoluteProjectRoot = (0, node_path_1.resolve)(workspaceRoot, projectRoot);
+    const cache = new Map();
+    return (filePath) => {
+        if (cache.has(filePath)) {
+            return cache.get(filePath);
+        }
+        const resolvedPath = replaceRootDirInPath(rootDir, filePath);
+        let result;
+        const absolutePath = jestResolve.findNodeModule(resolvedPath, {
+            basedir: rootDir,
+            extensions: ['.js', '.json', '.cjs', '.mjs', '.mts', '.cts', '.node'],
+            moduleDirectory: moduleDirectories,
+            paths: modulePaths,
+        });
+        if (!absolutePath) {
+            if (looksLikePackageName(filePath, resolvedPath)) {
+                result = { externalDependencies: [extractPackageName(filePath)] };
+            }
+            else {
+                result = null;
+            }
+        }
+        else {
+            result = classifyResolvedPath(absolutePath, absoluteProjectRoot, workspaceRoot);
+        }
+        cache.set(filePath, result);
+        return result;
+    };
+}
 function getOutputs(projectRoot, coverageDirectory, outputFile, context) {
     function getOutput(path) {
         const relativePath = (0, node_path_1.relative)((0, node_path_1.join)(context.workspaceRoot, projectRoot), path);
@@ -465,14 +552,14 @@ function requireJestUtil(packageName, projectRoot, workspaceRoot) {
         paths: [(0, node_path_1.dirname)(resolvedJestCorePaths[jestPath])],
     }));
 }
-async function getTestPaths(projectRoot, rawConfig, absConfigFilePath, context, presetCache) {
-    const testMatch = await getJestOption(rawConfig, absConfigFilePath, 'testMatch', presetCache);
+async function getTestPaths(projectRoot, rawConfig, rootDir, context, presetCache) {
+    const testMatch = await getJestOption(rawConfig, rootDir, 'testMatch', presetCache);
     let paths = await (0, workspace_context_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) => (0, node_path_1.join)(projectRoot, pattern)), []);
-    const testRegex = await getJestOption(rawConfig, absConfigFilePath, 'testRegex', presetCache);
+    const testRegex = await getJestOption(rawConfig, rootDir, 'testRegex', presetCache);
     if (testRegex) {
         const testRegexes = Array.isArray(rawConfig.testRegex)
             ? rawConfig.testRegex.map((r) => new RegExp(r))
@@ -481,27 +568,151 @@ async function getTestPaths(projectRoot, rawConfig, absConfigFilePath, context,
     }
     return { specs: paths, testMatch };
 }
-async function getJestOption(rawConfig, absConfigFilePath, optionName, presetCache) {
-    if (rawConfig[optionName])
-        return rawConfig[optionName];
-    if (rawConfig.preset) {
-        const dir = (0, node_path_1.dirname)(absConfigFilePath);
-        const presetPath = (0, node_path_1.resolve)(dir, rawConfig.preset);
+async function loadPresetConfig(rawConfig, rootDir, presetCache) {
+    if (!rawConfig.preset)
+        return null;
+    const presetValue = replaceRootDirInPath(rootDir, rawConfig.preset);
+    let presetPath;
+    if (presetValue.startsWith('.') || (0, node_path_1.isAbsolute)(presetValue)) {
+        presetPath = (0, node_path_1.resolve)(rootDir, presetValue);
+    }
+    else {
         try {
-            let preset = presetCache[presetPath];
-            if (!preset) {
-                preset = await (0, config_utils_1.loadConfigFile)(presetPath);
-                presetCache[presetPath] = preset;
-            }
-            if (preset[optionName])
-                return preset[optionName];
+            presetPath = require.resolve((0, node_path_1.join)(presetValue, 'jest-preset'), {
+                paths: [rootDir],
+            });
         }
         catch {
-            // If preset fails to load, ignore the error and continue.
-            // This is safe and less jarring for users. They will need to fix the
-            // preset for Jest to run, and at that point we can read in the correct
-            // value.
+            return null;
+        }
+    }
+    try {
+        if (!presetCache[presetPath]) {
+            presetCache[presetPath] = (0, config_utils_1.loadConfigFile)(presetPath);
         }
+        return (await presetCache[presetPath]);
+    }
+    catch {
+        // If preset fails to load, ignore the error and continue.
+        // This is safe and less jarring for users. They will need to fix the
+        // preset for Jest to run, and at that point we can read in the correct
+        // value.
+        return null;
     }
+}
+async function getConfigFileInputs(rawConfig, rootDir, presetCache, resolveFilePath) {
+    const fileInputs = new Set();
+    const externalDeps = new Set();
+    const preset = await loadPresetConfig(rawConfig, rootDir, presetCache);
+    function addInput(input) {
+        if (!input)
+            return;
+        if (typeof input === 'string') {
+            fileInputs.add(input);
+        }
+        else {
+            input.externalDependencies.forEach((d) => externalDeps.add(d));
+        }
+    }
+    // Replaced properties: rawConfig[prop] wins over preset[prop]
+    for (const prop of [
+        'resolver',
+        'globalSetup',
+        'globalTeardown',
+        'snapshotResolver',
+        'testResultsProcessor',
+    ]) {
+        const value = rawConfig[prop] ?? preset?.[prop];
+        if (typeof value === 'string') {
+            addInput(resolveFilePath(value));
+        }
+    }
+    // runner uses jest-runner- prefix resolution
+    const runner = rawConfig.runner ?? preset?.runner;
+    if (typeof runner === 'string') {
+        addInput(resolveWithPrefixFallback(runner, 'jest-runner-', resolveFilePath));
+    }
+    // Concatenated properties: preset values + config values
+    for (const prop of ['setupFiles', 'setupFilesAfterEnv']) {
+        const values = [
+            ...(preset?.[prop] ?? []),
+            ...(rawConfig[prop] ?? []),
+        ];
+        for (const value of values) {
+            if (typeof value === 'string') {
+                addInput(resolveFilePath(value));
+            }
+        }
+    }
+    // Merged: moduleNameMapper — config keys win (skip values with backreferences like $1)
+    const moduleNameMapper = {
+        ...(preset?.moduleNameMapper ?? {}),
+        ...(rawConfig.moduleNameMapper ?? {}),
+    };
+    for (const value of Object.values(moduleNameMapper)) {
+        const values = Array.isArray(value) ? value : [value];
+        for (const v of values) {
+            if (typeof v !== 'string')
+                continue;
+            if (/\$\d/.test(v))
+                continue;
+            addInput(resolveFilePath(v));
+        }
+    }
+    // Merged: transform — config keys win
+    const transform = {
+        ...(preset?.transform ?? {}),
+        ...(rawConfig.transform ?? {}),
+    };
+    for (const value of Object.values(transform)) {
+        let transformPath;
+        if (Array.isArray(value)) {
+            transformPath = value[0];
+        }
+        else if (typeof value === 'string') {
+            transformPath = value;
+        }
+        else {
+            continue;
+        }
+        addInput(resolveFilePath(transformPath));
+    }
+    // Replaced: snapshotSerializers, reporters, watchPlugins
+    const snapshotSerializers = rawConfig.snapshotSerializers ??
+        preset?.snapshotSerializers ??
+        [];
+    for (const value of snapshotSerializers) {
+        if (typeof value === 'string') {
+            addInput(resolveFilePath(value));
+        }
+    }
+    const reporters = rawConfig.reporters ?? preset?.reporters ?? [];
+    for (const entry of reporters) {
+        const name = Array.isArray(entry) ? entry[0] : entry;
+        if (typeof name !== 'string')
+            continue;
+        if (REPORTER_BUILTINS.has(name))
+            continue;
+        addInput(resolveFilePath(name));
+    }
+    // watchPlugins uses jest-watch- prefix resolution
+    const watchPlugins = rawConfig.watchPlugins ?? preset?.watchPlugins ?? [];
+    for (const entry of watchPlugins) {
+        const name = Array.isArray(entry) ? entry[0] : entry;
+        if (typeof name !== 'string')
+            continue;
+        addInput(resolveWithPrefixFallback(name, 'jest-watch-', resolveFilePath));
+    }
+    return {
+        fileInputs: [...fileInputs],
+        externalDeps: [...externalDeps],
+    };
+}
+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;
 }