@nx/jest 22.7.0-beta.11 → 22.7.0-beta.13

package/package.json

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

package/plugins/resolver.js

@@ -18,6 +18,10 @@ function getCompilerSetup(rootDir) {
     const readResult = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
     const config = ts.parseJsonConfigFileContent(readResult.config, ts.sys, (0, path_1.dirname)(tsConfigPath));
     const compilerOptions = config.options;
+    if (!compilerOptions.baseUrl) {
+        const { resolvePathsBaseUrl, } = require('@nx/js/src/utils/typescript/ts-config');
+        compilerOptions.baseUrl = resolvePathsBaseUrl(tsConfigPath);
+    }
     const host = ts.createCompilerHost(compilerOptions, true);
     return { compilerOptions, host };
 }

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,EAUd,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;IAC7B;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAmBD,eAAO,MAAM,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAsFxD,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,EAUd,MAAM,YAAY,CAAC;AAiCpB,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;AAwBD,eAAO,MAAM,WAAW,EAAE,aAAa,CAAC,iBAAiB,CA8IxD,CAAC;AAEF,eAAO,MAAM,aAAa,kCAAc,CAAC"}

package/src/plugins/plugin.js

@@ -15,6 +15,8 @@ const globs_1 = require("nx/src/utils/globs");
 const installation_directory_1 = require("nx/src/utils/installation-directory");
 const plugins_1 = require("nx/src/utils/plugins");
 const workspace_context_1 = require("nx/src/utils/workspace-context");
+const js_1 = require("@nx/js");
+const internal_1 = require("@nx/js/src/internal");
 const versions_1 = require("../utils/versions");
 const REPORTER_BUILTINS = new Set(['default', 'github-actions', 'summary']);
 function readTargetsCache(cachePath) {
@@ -34,9 +36,15 @@ exports.createNodes = [
         const targetsCache = readTargetsCache(cachePath);
         // Cache jest preset(s) to avoid penalties of module load times. Most of jest configs will use the same preset.
         const presetCache = {};
+        // Cache tsconfig reads + isolatedModules resolution. Many projects share
+        // the same base tsconfig in their extends chain — read each file once.
+        const tsconfigJsonCache = new Map();
+        const tsconfigExistsCache = new Map();
+        const isolatedModulesCache = new Map();
         const isInPackageManagerWorkspaces = buildPackageJsonWorkspacesMatcher(context.workspaceRoot);
         options = normalizeOptions(options);
-        const pmc = (0, devkit_1.getPackageManagerCommand)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
+        const packageManager = (0, devkit_1.detectPackageManager)(context.workspaceRoot);
+        const pmc = (0, devkit_1.getPackageManagerCommand)(packageManager);
         const { roots: projectRoots, configFiles: validConfigFiles } = configFiles.reduce((acc, configFile) => {
             const potentialRoot = (0, node_path_1.dirname)(configFile);
             if (checkIfConfigFileShouldBeProject(configFile, potentialRoot, isInPackageManagerWorkspaces, context)) {
@@ -48,12 +56,47 @@ exports.createNodes = [
             roots: [],
             configFiles: [],
         });
-        const hashes = await (0, calculate_hash_for_create_nodes_1.calculateHashesForCreateNodes)(projectRoots, options, context);
+        const lockFilePattern = (0, js_1.getLockFileName)(packageManager);
+        // Load configs in parallel. `loadConfigFile` calls `registerTsProject`,
+        // whose transpiler dedup is refcounted: serial register/unregister cycles
+        // drop refCount to 0 between iterations and recreate a fresh ts-node
+        // service each time (ts-node has no cleanup — see
+        // packages/nx/src/plugins/js/utils/register.js), stacking N services in
+        // `require.extensions` and OOM'ing under NX_PREFER_TS_NODE. Parallel
+        // loads keep all registrations alive concurrently so the dedup holds and
+        // a single transpiler instance is shared.
+        let requireCacheCleared = false;
+        const loadedConfigs = await Promise.all(validConfigFiles.map(async (configFilePath, i) => {
+            const projectRoot = projectRoots[i];
+            const absConfigFilePath = (0, node_path_1.resolve)(context.workspaceRoot, configFilePath);
+            if (!requireCacheCleared && require.cache[absConfigFilePath]) {
+                (0, config_utils_1.clearRequireCache)();
+                requireCacheCleared = true;
+            }
+            const rawConfig = await (0, config_utils_1.loadConfigFile)(absConfigFilePath, [
+                'tsconfig.spec.json',
+                'tsconfig.test.json',
+                'tsconfig.jest.json',
+                'tsconfig.json',
+            ]);
+            const { externalFiles, needsDtsInputs } = await collectExternalFileReferences(rawConfig, absConfigFilePath, projectRoot, context.workspaceRoot, {
+                presetCache,
+                tsconfigJsonCache,
+                tsconfigExistsCache,
+                isolatedModulesCache,
+            });
+            return { rawConfig, externalFiles, needsDtsInputs };
+        }));
+        const hashes = await (0, calculate_hash_for_create_nodes_1.calculateHashesForCreateNodes)(projectRoots, options, context, loadedConfigs.map(({ externalFiles }) => [
+            lockFilePattern,
+            ...externalFiles,
+        ]));
         try {
             return await (0, devkit_1.createNodesFromFiles)(async (configFilePath, options, context, idx) => {
                 const projectRoot = projectRoots[idx];
                 const hash = hashes[idx];
-                targetsCache[hash] ??= await buildJestTargets(configFilePath, projectRoot, options, context, presetCache, pmc);
+                const { rawConfig, needsDtsInputs } = loadedConfigs[idx];
+                targetsCache[hash] ??= await buildJestTargets(rawConfig, needsDtsInputs, configFilePath, projectRoot, options, context, presetCache, pmc);
                 const { targets, metadata } = targetsCache[hash];
                 return {
                     projects: {
@@ -103,18 +146,8 @@ function checkIfConfigFileShouldBeProject(configFilePath, projectRoot, isInPacka
     }
     return true;
 }
-async function buildJestTargets(configFilePath, projectRoot, options, context, presetCache, pmc) {
+async function buildJestTargets(rawConfig, needsDtsInputs, configFilePath, projectRoot, options, context, presetCache, pmc) {
     const absConfigFilePath = (0, node_path_1.resolve)(context.workspaceRoot, configFilePath);
-    if (require.cache[absConfigFilePath])
-        (0, config_utils_1.clearRequireCache)();
-    const rawConfig = await (0, config_utils_1.loadConfigFile)(absConfigFilePath, 
-    // lookup for the same files we look for in the resolver and fall back to tsconfig.json
-    [
-        'tsconfig.spec.json',
-        'tsconfig.test.json',
-        'tsconfig.jest.json',
-        'tsconfig.json',
-    ]);
     const targets = {};
     const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
     const tsNodeCompilerOptions = JSON.stringify({
@@ -154,7 +187,7 @@ async function buildJestTargets(configFilePath, projectRoot, options, context, p
         ? (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 = await getInputs(namedInputs, rawConfig, rootDir, projectRoot, context.workspaceRoot, presetCache, useJestResolver));
+    const inputs = (target.inputs = await getInputs(namedInputs, rawConfig, rootDir, projectRoot, context.workspaceRoot, presetCache, needsDtsInputs, useJestResolver));
     let metadata;
     const groupName = options?.ciGroupName ?? (0, plugins_1.deriveGroupNameFromTarget)(options?.ciTargetName);
     if (disableJestRuntime) {
@@ -265,7 +298,7 @@ async function buildJestTargets(configFilePath, projectRoot, options, context, p
             });
             const jest = require(resolveJestPath(projectRoot, context.workspaceRoot));
             const source = new jest.SearchSource(jestContext);
-            const jestVersion = (0, versions_1.getInstalledJestMajorVersion)();
+            const jestVersion = getJestMajorVersion();
             const specs = jestVersion >= 30
                 ? await source.getTestPaths(config.globalConfig, config.projectConfig)
                 : // @ts-expect-error Jest v29 doesn't have the projectConfig parameter
@@ -347,7 +380,7 @@ async function buildJestTargets(configFilePath, projectRoot, options, context, p
     }
     return { targets, metadata };
 }
-async function getInputs(namedInputs, rawConfig, rootDir, projectRoot, workspaceRoot, presetCache, useJestResolver) {
+async function getInputs(namedInputs, rawConfig, rootDir, projectRoot, workspaceRoot, presetCache, needsDtsInputs, useJestResolver) {
     const inputs = [
         ...('production' in namedInputs
             ? ['default', '^production']
@@ -388,6 +421,16 @@ async function getInputs(namedInputs, rawConfig, rootDir, projectRoot, workspace
         }
     }
     inputs.push({ externalDependencies });
+    // When ts-jest runs without isolatedModules, it creates a TypeScript
+    // Language Service that reads .d.ts files from dependency projects.
+    // Declare these as dependentTasksOutputFiles so changes to dependency
+    // type declarations correctly invalidate the test cache.
+    if (needsDtsInputs) {
+        inputs.push({
+            dependentTasksOutputFiles: '**/*.d.ts',
+            transitive: true,
+        });
+    }
     return inputs;
 }
 function resolvePresetInputWithoutJestResolver(presetValue, rootDir, projectRoot, workspaceRoot) {
@@ -568,6 +611,96 @@ async function getTestPaths(projectRoot, rawConfig, rootDir, context, presetCach
     }
     return { specs: paths, testMatch };
 }
+/**
+ * Collects workspace-relative paths to files whose CONTENT the plugin reads
+ * when computing inferred targets and that live OUTSIDE the project root.
+ *
+ * Only two kinds of files qualify:
+ *  - The jest preset (loaded to read its `transform`, etc.)
+ *  - Tsconfig files in the extends chain referenced by ts-jest (read to
+ *    determine `isolatedModules`); only walked when ts-jest is not already
+ *    known to be in isolated mode.
+ *
+ * Other config references (setup files, custom resolvers, transformers,
+ * etc.) are NOT collected — the plugin only resolves their paths and emits
+ * them as task inputs; their content is not read by the plugin, so changes
+ * to them don't influence inference.
+ */
+async function collectExternalFileReferences(rawConfig, absConfigFilePath, projectRoot, workspaceRoot, caches) {
+    const { presetCache, tsconfigJsonCache, tsconfigExistsCache, isolatedModulesCache, } = caches;
+    const absWorkspaceRoot = (0, node_path_1.resolve)(workspaceRoot);
+    const rootDir = rawConfig.rootDir
+        ? (0, node_path_1.resolve)((0, node_path_1.dirname)(absConfigFilePath), rawConfig.rootDir)
+        : (0, node_path_1.resolve)(absWorkspaceRoot, projectRoot);
+    const absoluteProjectRoot = (0, node_path_1.resolve)(absWorkspaceRoot, projectRoot);
+    const externalFiles = new Set();
+    const addIfExternal = (absolutePath) => {
+        if (!absolutePath)
+            return;
+        const rel = (0, devkit_1.normalizePath)((0, node_path_1.relative)(absWorkspaceRoot, absolutePath));
+        if (rel.startsWith('..') || (0, node_path_1.isAbsolute)(rel))
+            return; // outside workspace
+        if (rel.includes('node_modules/'))
+            return; // covered by lockfile
+        const relToProject = (0, devkit_1.normalizePath)((0, node_path_1.relative)(absoluteProjectRoot, absolutePath));
+        if (!relToProject.startsWith('..') && !(0, node_path_1.isAbsolute)(relToProject))
+            return; // inside project root
+        externalFiles.add(rel);
+    };
+    // Preset path (content is loaded by the plugin to merge with rawConfig)
+    if (typeof rawConfig.preset === 'string') {
+        const replaced = replaceRootDirInPath(rootDir, rawConfig.preset);
+        if (replaced.startsWith('.') || (0, node_path_1.isAbsolute)(replaced)) {
+            addIfExternal((0, node_path_1.resolve)(rootDir, replaced));
+        }
+    }
+    // ts-jest tsconfig extends chain — only walked when ts-jest is in
+    // non-isolated mode (otherwise the chain doesn't influence the output).
+    // Loading the preset is required to merge its transform with the raw
+    // config, since presets are the common source of ts-jest configuration.
+    const presetConfig = await loadPresetConfig(rawConfig, rootDir, presetCache);
+    const transform = {
+        ...(presetConfig?.transform ?? {}),
+        ...(rawConfig.transform ?? {}),
+    };
+    let needsDtsInputs = false;
+    for (const value of Object.values(transform)) {
+        let transformPath;
+        let transformOptions;
+        if (Array.isArray(value)) {
+            transformPath = value[0];
+            transformOptions = value[1];
+        }
+        else if (typeof value === 'string') {
+            transformPath = value;
+        }
+        else {
+            continue;
+        }
+        if (!isTsJestTransformer(transformPath))
+            continue;
+        if (transformOptions?.isolatedModules === true) {
+            const tsJestMajor = getTsJestMajorVersion();
+            if (tsJestMajor !== null && tsJestMajor < 30)
+                continue;
+        }
+        const tsconfigAbsPath = transformOptions?.tsconfig
+            ? (0, node_path_1.resolve)(rootDir, replaceRootDirInPath(rootDir, transformOptions.tsconfig))
+            : findNearestTsconfig(rootDir, absWorkspaceRoot, tsconfigExistsCache);
+        if (!tsconfigAbsPath) {
+            // No tsconfig found — ts-jest defaults to non-isolated mode
+            needsDtsInputs = true;
+            continue;
+        }
+        const { value: isolatedValue, visitedFiles } = resolveIsolatedModules(tsconfigAbsPath, tsconfigJsonCache, isolatedModulesCache);
+        for (const visitedFile of visitedFiles) {
+            addIfExternal(visitedFile);
+        }
+        if (isolatedValue !== true)
+            needsDtsInputs = true;
+    }
+    return { externalFiles: [...externalFiles], needsDtsInputs };
+}
 async function loadPresetConfig(rawConfig, rootDir, presetCache) {
     if (!rawConfig.preset)
         return null;
@@ -708,6 +841,93 @@ async function getConfigFileInputs(rawConfig, rootDir, presetCache, resolveFileP
         externalDeps: [...externalDeps],
     };
 }
+/**
+ * Walks up from `startDir` looking for `tsconfig.json`, stopping at
+ * `stopDir` (inclusive). Mirrors `ts.findConfigFile` but capped at the
+ * workspace root to avoid escaping the monorepo.
+ */
+function findNearestTsconfig(startDir, stopDir, existsCache) {
+    let dir = startDir;
+    while (true) {
+        const candidate = (0, node_path_1.join)(dir, 'tsconfig.json');
+        let exists = existsCache.get(candidate);
+        if (exists === undefined) {
+            exists = (0, node_fs_1.existsSync)(candidate);
+            existsCache.set(candidate, exists);
+        }
+        if (exists)
+            return candidate;
+        if (dir === stopDir)
+            return null;
+        const parent = (0, node_path_1.dirname)(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function isTsJestTransformer(value) {
+    if (value === 'ts-jest' || value.startsWith('ts-jest/')) {
+        return true;
+    }
+    // Handle resolved paths (e.g. from require.resolve('ts-jest') in configs)
+    const normalized = (0, devkit_1.normalizePath)(value);
+    return (normalized.includes('/node_modules/ts-jest/') ||
+        normalized.endsWith('/node_modules/ts-jest'));
+}
+/**
+ * Returns the effective `compilerOptions.isolatedModules` for a tsconfig,
+ * walking the `extends` chain via `walkTsconfigExtendsChain`. Tri-state:
+ * `value` is `undefined` when the option is not set anywhere in the chain.
+ */
+function resolveIsolatedModules(tsconfigPath, jsonCache, resultCache) {
+    const cached = resultCache.get(tsconfigPath);
+    if (cached)
+        return cached;
+    let value;
+    const visitedFiles = new Set();
+    (0, internal_1.walkTsconfigExtendsChain)(tsconfigPath, (absPath, rawJson) => {
+        visitedFiles.add(absPath);
+        const opts = rawJson?.compilerOptions;
+        if (opts?.isolatedModules !== undefined) {
+            value = opts.isolatedModules === true;
+            return 'stop';
+        }
+        // verbatimModuleSyntax: true implies isolatedModules: true (TS 5.0+,
+        // the minimum TS version Nx supports)
+        if (opts?.verbatimModuleSyntax === true) {
+            value = true;
+            return 'stop';
+        }
+        return 'continue';
+    }, { jsonCache });
+    const result = { value, visitedFiles };
+    resultCache.set(tsconfigPath, result);
+    return result;
+}
+// Module-level memoization: package versions don't change during a process
+// lifetime, so it's safe to cache across createNodes invocations.
+let cachedJestMajorVersion;
+function getJestMajorVersion() {
+    if (cachedJestMajorVersion === undefined) {
+        cachedJestMajorVersion = (0, versions_1.getInstalledJestMajorVersion)();
+    }
+    return cachedJestMajorVersion;
+}
+let cachedTsJestMajorVersion;
+function getTsJestMajorVersion() {
+    if (cachedTsJestMajorVersion !== undefined) {
+        return cachedTsJestMajorVersion;
+    }
+    try {
+        const { major } = require('semver');
+        const version = require('ts-jest/package.json').version;
+        cachedTsJestMajorVersion = major(version);
+    }
+    catch {
+        cachedTsJestMajorVersion = null;
+    }
+    return cachedTsJestMajorVersion;
+}
 async function getJestOption(rawConfig, rootDir, optionName, presetCache) {
     if (rawConfig[optionName])
         return rawConfig[optionName];