@nx/jest 20.0.7 → 20.1.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/jest",
-  "version": "20.0.7",
+  "version": "20.1.0-beta.0",
   "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": "^29.4.1",
     "@jest/test-result": "^29.4.1",
-    "@nx/devkit": "20.0.7",
-    "@nx/js": "20.0.7",
+    "@nx/devkit": "20.1.0-beta.0",
+    "@nx/js": "20.1.0-beta.0",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "chalk": "^4.1.0",
     "identity-obj-proxy": "3.0.0",

package/src/plugins/plugin.d.ts

@@ -2,6 +2,12 @@ import { CreateNodes, CreateNodesV2 } from '@nx/devkit';
 export interface JestPluginOptions {
     targetName?: string;
     ciTargetName?: string;
+    /**
+     *  Whether to use jest-config and jest-runtime to load Jest configuration and context.
+     *  Disabling this is much faster but could be less correct since we are using our own config loader
+     *  and test matcher instead of Jest's.
+     */
+    disableJestRuntime?: boolean;
 }
 export declare const createNodesV2: CreateNodesV2<JestPluginOptions>;
 /**

package/src/plugins/plugin.js

@@ -13,6 +13,8 @@ const cache_directory_1 = require("nx/src/utils/cache-directory");
 const globs_1 = require("nx/src/utils/globs");
 const path_1 = require("path");
 const version_utils_1 = require("../utils/version-utils");
+const workspace_context_1 = require("nx/src/utils/workspace-context");
+const node_path_1 = require("node:path");
 const pmc = (0, devkit_1.getPackageManagerCommand)();
 function readTargetsCache(cachePath) {
     return (0, fs_1.existsSync)(cachePath) ? (0, devkit_1.readJsonFile)(cachePath) : {};
@@ -27,8 +29,10 @@ exports.createNodesV2 = [
         const optionsHash = (0, devkit_internals_1.hashObject)(options);
         const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, `jest-${optionsHash}.hash`);
         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 = {};
         try {
-            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => createNodesInternal(configFile, options, context, targetsCache), configFiles, options, context);
+            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => createNodesInternal(configFile, options, context, targetsCache, presetCache), configFiles, options, context);
         }
         finally {
             writeTargetsToCache(cachePath, targetsCache);
@@ -43,10 +47,10 @@ exports.createNodes = [
     jestConfigGlob,
     (...args) => {
         devkit_1.logger.warn('`createNodes` is deprecated. Update your plugin to utilize createNodesV2 instead. In Nx 20, this will change to the createNodesV2 API.');
-        return createNodesInternal(...args, {});
+        return createNodesInternal(...args, {}, {});
     },
 ];
-async function createNodesInternal(configFilePath, options, context, targetsCache) {
+async function createNodesInternal(configFilePath, options, context, targetsCache, presetCache) {
     const projectRoot = (0, path_1.dirname)(configFilePath);
     const packageManagerWorkspacesGlob = (0, globs_1.combineGlobPatterns)((0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(context.workspaceRoot));
     // Do not create a project if package.json and project.json isn't there.
@@ -72,7 +76,7 @@ async function createNodesInternal(configFilePath, options, context, targetsCach
     }
     options = normalizeOptions(options);
     const hash = await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context);
-    targetsCache[hash] ??= await buildJestTargets(configFilePath, projectRoot, options, context);
+    targetsCache[hash] ??= await buildJestTargets(configFilePath, projectRoot, options, context, presetCache);
     const { targets, metadata } = targetsCache[hash];
     return {
         projects: {
@@ -84,19 +88,13 @@ async function createNodesInternal(configFilePath, options, context, targetsCach
         },
     };
 }
-async function buildJestTargets(configFilePath, projectRoot, options, context) {
+async function buildJestTargets(configFilePath, projectRoot, options, context, presetCache) {
     const absConfigFilePath = (0, path_1.resolve)(context.workspaceRoot, configFilePath);
-    if (require.cache[absConfigFilePath]) {
+    if (require.cache[absConfigFilePath])
         (0, config_utils_1.clearRequireCache)();
-    }
     const rawConfig = await (0, config_utils_1.loadConfigFile)(absConfigFilePath);
-    const { readConfig } = requireJestUtil('jest-config', projectRoot, context.workspaceRoot);
-    const config = await readConfig({
-        _: [],
-        $0: undefined,
-    }, rawConfig, undefined, (0, path_1.dirname)(absConfigFilePath));
-    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
     const targets = {};
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
     const target = (targets[options.targetName] = {
         command: 'jest',
         options: {
@@ -116,56 +114,28 @@ async function buildJestTargets(configFilePath, projectRoot, options, context) {
         },
     });
     const cache = (target.cache = true);
-    const inputs = (target.inputs = getInputs(namedInputs, rawConfig, projectRoot, context.workspaceRoot));
-    const outputs = (target.outputs = getOutputs(projectRoot, config, context));
+    const inputs = (target.inputs = getInputs(namedInputs, rawConfig.preset, projectRoot, context.workspaceRoot, options.disableJestRuntime));
     let metadata;
-    if (options?.ciTargetName) {
-        // nx-ignore-next-line
-        const { default: Runtime } = requireJestUtil('jest-runtime', projectRoot, context.workspaceRoot);
-        const jestContext = await Runtime.createContext(config.projectConfig, {
-            maxWorkers: 1,
-            watchman: false,
-        });
-        const jest = require(resolveJestPath(projectRoot, context.workspaceRoot));
-        const source = new jest.SearchSource(jestContext);
-        const jestVersion = (0, version_utils_1.getInstalledJestMajorVersion)();
-        const specs = jestVersion >= 30
-            ? // @ts-expect-error Jest 30+ expects the project config as the second argument
-                await source.getTestPaths(config.globalConfig, config.projectConfig)
-            : await source.getTestPaths(config.globalConfig);
-        const testPaths = new Set(specs.tests.map(({ path }) => path));
-        if (testPaths.size > 0) {
-            const groupName = 'E2E (CI)';
+    const groupName = 'E2E (CI)';
+    if (options.disableJestRuntime) {
+        const outputs = (target.outputs = getOutputs(projectRoot, rawConfig.coverageDirectory
+            ? (0, path_1.join)(context.workspaceRoot, projectRoot, rawConfig.coverageDirectory)
+            : undefined, undefined, context));
+        if (options?.ciTargetName) {
+            const testPaths = await getTestPaths(projectRoot, rawConfig, absConfigFilePath, context, presetCache);
             const targetGroup = [];
+            const dependsOn = [];
             metadata = {
                 targetGroups: {
                     [groupName]: targetGroup,
                 },
             };
-            const dependsOn = [];
-            targets[options.ciTargetName] = {
-                executor: 'nx:noop',
-                cache: true,
-                inputs,
-                outputs,
-                dependsOn,
-                metadata: {
-                    technologies: ['jest'],
-                    description: 'Run Jest Tests in CI',
-                    nonAtomizedTarget: options.targetName,
-                    help: {
-                        command: `${pmc.exec} jest --help`,
-                        example: {
-                            options: {
-                                coverage: true,
-                            },
-                        },
-                    },
-                },
-            };
-            targetGroup.push(options.ciTargetName);
+            const specIgnoreRegexes = rawConfig.testPathIgnorePatterns?.map((p) => new RegExp(replaceRootDirInPath(projectRoot, p)));
             for (const testPath of testPaths) {
                 const relativePath = (0, devkit_1.normalizePath)((0, path_1.relative)((0, path_1.join)(context.workspaceRoot, projectRoot), testPath));
+                if (specIgnoreRegexes?.some((regex) => regex.test(relativePath))) {
+                    continue;
+                }
                 const targetName = `${options.ciTargetName}--${relativePath}`;
                 dependsOn.push(targetName);
                 targets[targetName] = {
@@ -191,18 +161,124 @@ async function buildJestTargets(configFilePath, projectRoot, options, context) {
                 };
                 targetGroup.push(targetName);
             }
+            if (targetGroup.length > 0) {
+                targets[options.ciTargetName] = {
+                    executor: 'nx:noop',
+                    cache: true,
+                    inputs,
+                    outputs,
+                    dependsOn,
+                    metadata: {
+                        technologies: ['jest'],
+                        description: 'Run Jest Tests in CI',
+                        nonAtomizedTarget: options.targetName,
+                        help: {
+                            command: `${pmc.exec} jest --help`,
+                            example: {
+                                options: {
+                                    coverage: true,
+                                },
+                            },
+                        },
+                    },
+                };
+                targetGroup.unshift(options.ciTargetName);
+            }
+        }
+    }
+    else {
+        const { readConfig } = requireJestUtil('jest-config', projectRoot, context.workspaceRoot);
+        const config = await readConfig({
+            _: [],
+            $0: undefined,
+        }, rawConfig, undefined, (0, path_1.dirname)(absConfigFilePath));
+        const outputs = (target.outputs = getOutputs(projectRoot, config.globalConfig?.coverageDirectory, config.globalConfig?.outputFile, context));
+        if (options?.ciTargetName) {
+            // nx-ignore-next-line
+            const { default: Runtime } = requireJestUtil('jest-runtime', projectRoot, context.workspaceRoot);
+            const jestContext = await Runtime.createContext(config.projectConfig, {
+                maxWorkers: 1,
+                watchman: false,
+            });
+            const jest = require(resolveJestPath(projectRoot, context.workspaceRoot));
+            const source = new jest.SearchSource(jestContext);
+            const jestVersion = (0, version_utils_1.getInstalledJestMajorVersion)();
+            const specs = jestVersion >= 30
+                ? // @ts-expect-error Jest 30+ expects the project config as the second argument
+                    await source.getTestPaths(config.globalConfig, config.projectConfig)
+                : await source.getTestPaths(config.globalConfig);
+            const testPaths = new Set(specs.tests.map(({ path }) => path));
+            if (testPaths.size > 0) {
+                const targetGroup = [];
+                metadata = {
+                    targetGroups: {
+                        [groupName]: targetGroup,
+                    },
+                };
+                const dependsOn = [];
+                targets[options.ciTargetName] = {
+                    executor: 'nx:noop',
+                    cache: true,
+                    inputs,
+                    outputs,
+                    dependsOn,
+                    metadata: {
+                        technologies: ['jest'],
+                        description: 'Run Jest Tests in CI',
+                        nonAtomizedTarget: options.targetName,
+                        help: {
+                            command: `${pmc.exec} jest --help`,
+                            example: {
+                                options: {
+                                    coverage: true,
+                                },
+                            },
+                        },
+                    },
+                };
+                targetGroup.push(options.ciTargetName);
+                for (const testPath of testPaths) {
+                    const relativePath = (0, devkit_1.normalizePath)((0, path_1.relative)((0, path_1.join)(context.workspaceRoot, projectRoot), testPath));
+                    const targetName = `${options.ciTargetName}--${relativePath}`;
+                    dependsOn.push(targetName);
+                    targets[targetName] = {
+                        command: `jest ${relativePath}`,
+                        cache,
+                        inputs,
+                        outputs,
+                        options: {
+                            cwd: projectRoot,
+                        },
+                        metadata: {
+                            technologies: ['jest'],
+                            description: `Run Jest Tests in ${relativePath}`,
+                            help: {
+                                command: `${pmc.exec} jest --help`,
+                                example: {
+                                    options: {
+                                        coverage: true,
+                                    },
+                                },
+                            },
+                        },
+                    };
+                    targetGroup.push(targetName);
+                }
+            }
         }
     }
     return { targets, metadata };
 }
-function getInputs(namedInputs, jestConfig, projectRoot, workspaceRoot) {
+function getInputs(namedInputs, preset, projectRoot, workspaceRoot, disableJestRuntime) {
     const inputs = [
         ...('production' in namedInputs
             ? ['default', '^production']
             : ['default', '^default']),
     ];
     const externalDependencies = ['jest'];
-    const presetInput = resolvePresetInput(jestConfig.preset, projectRoot, workspaceRoot);
+    const presetInput = disableJestRuntime
+        ? resolvePresetInputWithoutJestResolver(preset, projectRoot, workspaceRoot)
+        : resolvePresetInputWithJestResolver(preset, projectRoot, workspaceRoot);
     if (presetInput) {
         if (typeof presetInput !== 'string' &&
             'externalDependencies' in presetInput) {
@@ -215,13 +291,28 @@ function getInputs(namedInputs, jestConfig, projectRoot, workspaceRoot) {
     inputs.push({ externalDependencies });
     return inputs;
 }
+function resolvePresetInputWithoutJestResolver(presetValue, projectRoot, workspaceRoot) {
+    if (!presetValue)
+        return null;
+    const presetPath = replaceRootDirInPath(projectRoot, presetValue);
+    const isNpmPackage = !presetValue.startsWith('.') && !(0, path_1.isAbsolute)(presetPath);
+    if (isNpmPackage) {
+        return { externalDependencies: [presetValue] };
+    }
+    if (presetPath.startsWith('..')) {
+        const relativePath = (0, path_1.relative)(workspaceRoot, (0, path_1.join)(projectRoot, presetPath));
+        return (0, path_1.join)('{workspaceRoot}', relativePath);
+    }
+    else {
+        const relativePath = (0, path_1.relative)(projectRoot, presetPath);
+        return (0, path_1.join)('{projectRoot}', relativePath);
+    }
+}
 // preset resolution adapted from:
 // https://github.com/jestjs/jest/blob/c54bccd657fb4cf060898717c09f633b4da3eec4/packages/jest-config/src/normalize.ts#L122
-function resolvePresetInput(presetValue, projectRoot, workspaceRoot) {
-    if (!presetValue) {
+function resolvePresetInputWithJestResolver(presetValue, projectRoot, workspaceRoot) {
+    if (!presetValue)
         return null;
-    }
-    const { replaceRootDirInPath } = requireJestUtil('jest-config', projectRoot, workspaceRoot);
     let presetPath = replaceRootDirInPath(projectRoot, presetValue);
     const isNpmPackage = !presetValue.startsWith('.') && !(0, path_1.isAbsolute)(presetPath);
     presetPath = presetPath.startsWith('.')
@@ -243,7 +334,14 @@ function resolvePresetInput(presetValue, projectRoot, workspaceRoot) {
         ? (0, path_1.join)('{workspaceRoot}', (0, path_1.join)(projectRoot, relativePath))
         : (0, path_1.join)('{projectRoot}', relativePath);
 }
-function getOutputs(projectRoot, { globalConfig }, context) {
+// Adapted from here https://github.com/jestjs/jest/blob/c13bca3/packages/jest-config/src/utils.ts#L57-L69
+function replaceRootDirInPath(rootDir, filePath) {
+    if (!filePath.startsWith('<rootDir>')) {
+        return filePath;
+    }
+    return (0, path_1.resolve)(rootDir, (0, node_path_1.normalize)(`./${filePath.slice('<rootDir>'.length)}`));
+}
+function getOutputs(projectRoot, coverageDirectory, outputFile, context) {
     function getOutput(path) {
         const relativePath = (0, path_1.relative)((0, path_1.join)(context.workspaceRoot, projectRoot), path);
         if (relativePath.startsWith('..')) {
@@ -254,10 +352,7 @@ function getOutputs(projectRoot, { globalConfig }, context) {
         }
     }
     const outputs = [];
-    for (const outputOption of [
-        globalConfig.coverageDirectory,
-        globalConfig.outputFile,
-    ]) {
+    for (const outputOption of [coverageDirectory, outputFile]) {
         if (outputOption) {
             outputs.push(getOutput(outputOption));
         }
@@ -297,3 +392,56 @@ function requireJestUtil(packageName, projectRoot, workspaceRoot) {
         paths: [(0, path_1.dirname)(resolvedJestCorePaths[jestPath])],
     }));
 }
+async function getTestPaths(projectRoot, rawConfig, absConfigFilePath, context, presetCache) {
+    const testMatch = await getJestOption(rawConfig, absConfigFilePath, 'testMatch', presetCache);
+    if (testMatch) {
+        return await (0, workspace_context_1.globWithWorkspaceContext)(context.workspaceRoot, testMatch.map((pattern) => (0, path_1.join)(projectRoot, pattern)), []);
+    }
+    else {
+        const testRegex = await getJestOption(rawConfig, absConfigFilePath, 'testRegex', presetCache);
+        if (testRegex) {
+            const files = [];
+            const testRegexes = Array.isArray(rawConfig.testRegex)
+                ? rawConfig.testRegex.map((r) => new RegExp(r))
+                : [new RegExp(rawConfig.testRegex)];
+            const projectFiles = await (0, workspace_context_1.getFilesInDirectoryUsingContext)(context.workspaceRoot, projectRoot);
+            for (const file of projectFiles) {
+                if (testRegexes.some((r) => r.test(file)))
+                    files.push(file);
+            }
+            return files;
+        }
+        else {
+            // Default copied from https://github.com/jestjs/jest/blob/d1a2ed7/packages/jest-config/src/Defaults.ts#L84
+            const defaultTestMatch = [
+                '**/__tests__/**/*.?([mc])[jt]s?(x)',
+                '**/?(*.)+(spec|test).?([mc])[jt]s?(x)',
+            ];
+            return await (0, workspace_context_1.globWithWorkspaceContext)(context.workspaceRoot, defaultTestMatch.map((pattern) => (0, path_1.join)(projectRoot, pattern)), []);
+        }
+    }
+}
+async function getJestOption(rawConfig, absConfigFilePath, optionName, presetCache) {
+    if (rawConfig[optionName])
+        return rawConfig[optionName];
+    if (rawConfig.preset) {
+        const dir = (0, path_1.dirname)(absConfigFilePath);
+        const presetPath = (0, path_1.resolve)(dir, rawConfig.preset);
+        try {
+            let preset = presetCache[presetPath];
+            if (!preset) {
+                preset = await (0, config_utils_1.loadConfigFile)(presetPath);
+                presetCache[presetPath] = preset;
+            }
+            if (preset[optionName])
+                return preset[optionName];
+        }
+        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 undefined;
+}