@nx/jest 21.0.0-beta.0 → 21.0.0-beta.10

package/index.d.ts

@@ -5,4 +5,4 @@ export declare const jestProjectGenerator: typeof configurationGenerator;
 export { addPropertyToJestConfig, removePropertyFromJestConfig, } from './src/utils/config/update-config';
 export { jestConfigObjectAst } from './src/utils/config/functions';
 export { jestInitGenerator } from './src/generators/init/init';
-export { getJestProjects, getJestProjectsAsync, getNestedJestProjects, } from './src/utils/config/get-jest-projects';
+export { getJestProjectsAsync } from './src/utils/config/get-jest-projects';

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNestedJestProjects = exports.getJestProjectsAsync = exports.getJestProjects = exports.jestInitGenerator = exports.jestConfigObjectAst = exports.removePropertyFromJestConfig = exports.addPropertyToJestConfig = exports.jestProjectGenerator = exports.configurationGenerator = void 0;
+exports.getJestProjectsAsync = exports.jestInitGenerator = exports.jestConfigObjectAst = exports.removePropertyFromJestConfig = exports.addPropertyToJestConfig = exports.jestProjectGenerator = exports.configurationGenerator = void 0;
 const configuration_1 = require("./src/generators/configuration/configuration");
 Object.defineProperty(exports, "configurationGenerator", { enumerable: true, get: function () { return configuration_1.configurationGenerator; } });
 // Exported for backwards compatibility in case a plugin is using the old name.
@@ -14,6 +14,4 @@ Object.defineProperty(exports, "jestConfigObjectAst", { enumerable: true, get: f
 var init_1 = require("./src/generators/init/init");
 Object.defineProperty(exports, "jestInitGenerator", { enumerable: true, get: function () { return init_1.jestInitGenerator; } });
 var get_jest_projects_1 = require("./src/utils/config/get-jest-projects");
-Object.defineProperty(exports, "getJestProjects", { enumerable: true, get: function () { return get_jest_projects_1.getJestProjects; } });
 Object.defineProperty(exports, "getJestProjectsAsync", { enumerable: true, get: function () { return get_jest_projects_1.getJestProjectsAsync; } });
-Object.defineProperty(exports, "getNestedJestProjects", { enumerable: true, get: function () { return get_jest_projects_1.getNestedJestProjects; } });

package/migrations.json

@@ -1,27 +1,19 @@
 {
   "generators": {
-    "move-options-to-target-defaults": {
-      "version": "17.1.0-beta.2",
-      "description": "Move jest executor options to nx.json targetDefaults",
-      "implementation": "./src/migrations/update-17-1-0/move-options-to-target-defaults"
-    },
     "replace-getJestProjects-with-getJestProjectsAsync": {
       "cli": "nx",
       "version": "20.0.0-beta.5",
-      "description": "replace getJestProjects with getJestProjectsAsync",
+      "description": "Replace usage of `getJestProjects` with `getJestProjectsAsync`.",
       "implementation": "./src/migrations/update-20-0-0/replace-getJestProjects-with-getJestProjectsAsync"
+    },
+    "replace-getJestProjects-with-getJestProjectsAsync-v21": {
+      "cli": "nx",
+      "version": "21.0.0-beta.9",
+      "description": "Replace usage of `getJestProjects` with `getJestProjectsAsync`.",
+      "implementation": "./src/migrations/update-21-0-0/replace-getJestProjects-with-getJestProjectsAsync"
     }
   },
   "packageJsonUpdates": {
-    "17.2.0": {
-      "version": "17.2.0-beta.2",
-      "packages": {
-        "@types/node": {
-          "version": "18.16.9",
-          "alwaysAddToPackageJson": false
-        }
-      }
-    },
     "19.2.0": {
       "version": "19.2.0-beta.0",
       "packages": {

package/package.json

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

package/src/executors/jest/jest.impl.js

@@ -16,7 +16,13 @@ process.env.NODE_ENV ??= 'test';
 async function jestExecutor(options, context) {
     // Jest registers ts-node with module CJS https://github.com/SimenB/jest/blob/v29.6.4/packages/jest-config/src/readConfigFileAndSetRootDir.ts#L117-L119
     // We want to support of ESM via 'module':'nodenext', we need to override the resolution until Jest supports it.
-    process.env.TS_NODE_COMPILER_OPTIONS ??= '{"moduleResolution":"node10"}';
+    const existingValue = process.env['TS_NODE_COMPILER_OPTIONS'];
+    process.env['TS_NODE_COMPILER_OPTIONS'] = JSON.stringify({
+        ...(existingValue ? JSON.parse(existingValue) : {}),
+        moduleResolution: 'Node10',
+        module: 'commonjs',
+        customConditions: null,
+    });
     const config = await parseJestConfig(options, context);
     const { results } = await (0, jest_1.runCLI)(config, [options.jestConfig]);
     return { success: results.success };

package/src/generators/configuration/files/common/src/test-setup.ts__tmpl__

@@ -1 +1,7 @@
-<% if(setupFile === 'react-native') { %>import '@testing-library/jest-native/extend-expect';<% } %>
+<% if(setupFile === 'react-native') { %>import '@testing-library/jest-native/extend-expect';<% } %>
+<%_ if(setupFile === 'react-router') { _%>
+import { TextEncoder, TextDecoder as NodeTextDecoder } from "util";
+
+global.TextEncoder = TextEncoder;
+global.TextDecoder = NodeTextDecoder as typeof TextDecoder; // necessary because there is a mismatch between ts type and node type
+<%_ } _%>

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

@@ -99,9 +99,10 @@ function generateGlobalConfig(tree, isJS) {
 module.exports = async () => ({
   projects: await getJestProjectsAsync()
 });`
-        : `import { getJestProjectsAsync } from '@nx/jest';
+        : `import type { Config } from 'jest';
+import { getJestProjectsAsync } from '@nx/jest';
 
-export default async () => ({
+export default async (): Promise<Config> => ({
   projects: await getJestProjectsAsync()
 });`;
     tree.write(`jest.config.${isJS ? 'js' : 'ts'}`, contents);

package/src/generators/configuration/schema.d.ts

@@ -6,7 +6,12 @@ export interface JestProjectSchema {
    * @deprecated use setupFile instead
    */
   skipSetupFile?: boolean;
-  setupFile?: 'angular' | 'web-components' | 'react-native' | 'none';
+  setupFile?:
+    | 'angular'
+    | 'web-components'
+    | 'react-native'
+    | 'react-router'
+    | 'none';
   skipSerializers?: boolean;
   testEnvironment?: 'node' | 'jsdom' | 'none';
   /**

package/src/migrations/update-21-0-0/replace-getJestProjects-with-getJestProjectsAsync.js

@@ -0,0 +1,86 @@
+"use strict";
+// go through the jest.config files
+// see if it imports from @nx/jest and if it uses getJestProjects
+// replace getJestProjects with getJestProjectsAsync
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+let tsModule;
+async function update(tree) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const jestConfigPaths = await (0, devkit_1.globAsync)(tree, [
+        '**/jest.config.{cjs,mjs,js,cts,mts,ts}',
+    ]);
+    jestConfigPaths.forEach((jestConfigPath) => {
+        const oldContent = tree.read(jestConfigPath).toString();
+        if (oldContent?.includes('projects: getJestProjects()')) {
+            let sourceFile = tsModule.createSourceFile(jestConfigPath, oldContent, tsModule.ScriptTarget.Latest, true);
+            // find `require('@nx/jest')` or `import { getJestProjects } from '@nx/jest`
+            const requireStatement = sourceFile.statements.find((statement) => tsModule.isVariableStatement(statement) &&
+                statement.declarationList.declarations.some((declaration) => tsModule.isCallExpression(declaration.initializer) &&
+                    tsModule.isIdentifier(declaration.initializer.expression) &&
+                    declaration.initializer.expression.escapedText === 'require' &&
+                    tsModule.isStringLiteral(declaration.initializer.arguments[0]) &&
+                    declaration.initializer.arguments[0].text === '@nx/jest'));
+            const importStatement = sourceFile.statements.find((statement) => tsModule.isImportDeclaration(statement) &&
+                statement.moduleSpecifier.getText() === `'@nx/jest'`);
+            if (requireStatement || importStatement) {
+                // find `module.exports` statement with `projects: getJestProjects()`
+                const moduleExports = sourceFile.statements.find((statement) => tsModule.isExpressionStatement(statement) &&
+                    tsModule.isBinaryExpression(statement.expression) &&
+                    tsModule.isPropertyAccessExpression(statement.expression.left) &&
+                    tsModule.isObjectLiteralExpression(statement.expression.right) &&
+                    statement.expression.operatorToken.kind ===
+                        tsModule.SyntaxKind.EqualsToken &&
+                    tsModule.isIdentifier(statement.expression.left.expression) &&
+                    statement.expression.left.expression.escapedText === 'module' &&
+                    tsModule.isIdentifier(statement.expression.left.name) &&
+                    statement.expression.left.name.escapedText === 'exports' &&
+                    statement.expression.right.properties.some((property) => tsModule.isPropertyAssignment(property) &&
+                        tsModule.isIdentifier(property.name) &&
+                        property.name.escapedText === 'projects' &&
+                        tsModule.isCallExpression(property.initializer) &&
+                        tsModule.isIdentifier(property.initializer.expression) &&
+                        property.initializer.expression.escapedText ===
+                            'getJestProjects'));
+                if (moduleExports) {
+                    // replace getJestProjects with getJestProjectsAsync in export statement
+                    const rightExpression = moduleExports.expression.right.getText();
+                    const newExpression = rightExpression.replace('getJestProjects()', 'await getJestProjectsAsync()');
+                    const newStatement = `module.exports = async () => (${newExpression});`;
+                    let newContent = oldContent.replace(moduleExports.getText(), newStatement);
+                    // replace getJestProjects with getJestProjectsAsync in import statement
+                    newContent = newContent.replace('getJestProjects', 'getJestProjectsAsync');
+                    tree.write(jestConfigPath, newContent);
+                }
+                else {
+                    // find `export default` statement with `projects: getJestProjects()`
+                    const exportAssignment = sourceFile.statements.find((statement) => tsModule.isExportAssignment(statement));
+                    const defaultExport = exportAssignment?.expression &&
+                        tsModule.isObjectLiteralExpression(exportAssignment?.expression)
+                        ? exportAssignment?.expression
+                        : null;
+                    const projectProperty = defaultExport?.properties.find((property) => tsModule.isPropertyAssignment(property) &&
+                        property.name.getText() === 'projects' &&
+                        tsModule.isCallExpression(property.initializer) &&
+                        tsModule.isIdentifier(property.initializer.expression) &&
+                        property.initializer.expression.escapedText === 'getJestProjects');
+                    if (projectProperty) {
+                        // replace getJestProjects with getJestProjectsAsync in export statement
+                        const newExpression = defaultExport
+                            .getText()
+                            .replace('getJestProjects()', 'await getJestProjectsAsync()');
+                        const newStatement = `export default async () => (${newExpression});`;
+                        let newContent = oldContent.replace(exportAssignment.getText(), newStatement);
+                        // replace getJestProjects with getJestProjectsAsync in import statement
+                        newContent = newContent.replace('getJestProjects', 'getJestProjectsAsync');
+                        tree.write(jestConfigPath, newContent);
+                    }
+                }
+            }
+        }
+    });
+}

package/src/plugins/plugin.d.ts

@@ -7,7 +7,7 @@ export interface JestPluginOptions {
      */
     ciGroupName?: string;
     /**
-     *  Whether to use jest-config and jest-runtime to load Jest configuration and context.
+     *  Whether to use jest-config and jest-runtime are used 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.
      */

package/src/plugins/plugin.js

@@ -15,6 +15,7 @@ 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 installation_directory_1 = require("nx/src/utils/installation-directory");
 const pmc = (0, devkit_1.getPackageManagerCommand)();
 function readTargetsCache(cachePath) {
     return (0, fs_1.existsSync)(cachePath) ? (0, devkit_1.readJsonFile)(cachePath) : {};
@@ -31,8 +32,36 @@ exports.createNodesV2 = [
         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 = {};
+        const packageManagerWorkspacesGlob = (0, globs_1.combineGlobPatterns)((0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(context.workspaceRoot));
+        options = normalizeOptions(options);
+        const { roots: projectRoots, configFiles: validConfigFiles } = configFiles.reduce((acc, configFile) => {
+            const potentialRoot = (0, path_1.dirname)(configFile);
+            if (checkIfConfigFileShouldBeProject(configFile, potentialRoot, packageManagerWorkspacesGlob, context)) {
+                acc.roots.push(potentialRoot);
+                acc.configFiles.push(configFile);
+            }
+            return acc;
+        }, {
+            roots: [],
+            configFiles: [],
+        });
+        const hashes = await (0, calculate_hash_for_create_nodes_1.calculateHashesForCreateNodes)(projectRoots, options, context);
         try {
-            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => createNodesInternal(configFile, options, context, targetsCache, presetCache), configFiles, options, context);
+            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);
+                const { targets, metadata } = targetsCache[hash];
+                return {
+                    projects: {
+                        [projectRoot]: {
+                            root: projectRoot,
+                            targets,
+                            metadata,
+                        },
+                    },
+                };
+            }, validConfigFiles, options, context);
         }
         finally {
             writeTargetsToCache(cachePath, targetsCache);
@@ -45,26 +74,39 @@ exports.createNodesV2 = [
  */
 exports.createNodes = [
     jestConfigGlob,
-    (...args) => {
+    async (configFilePath, options, context) => {
         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, {}, {});
+        const projectRoot = (0, path_1.dirname)(configFilePath);
+        const packageManagerWorkspacesGlob = (0, globs_1.combineGlobPatterns)((0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(context.workspaceRoot));
+        if (!checkIfConfigFileShouldBeProject(configFilePath, projectRoot, packageManagerWorkspacesGlob, context)) {
+            return {};
+        }
+        options = normalizeOptions(options);
+        const { targets, metadata } = await buildJestTargets(configFilePath, projectRoot, options, context, {});
+        return {
+            projects: {
+                [projectRoot]: {
+                    root: projectRoot,
+                    targets,
+                    metadata,
+                },
+            },
+        };
     },
 ];
-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));
+function checkIfConfigFileShouldBeProject(configFilePath, projectRoot, packageManagerWorkspacesGlob, context) {
     // Do not create a project if package.json and project.json isn't there.
     const siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
     if (!siblingFiles.includes('package.json') &&
         !siblingFiles.includes('project.json')) {
-        return {};
+        return false;
     }
     else if (!siblingFiles.includes('project.json') &&
         siblingFiles.includes('package.json')) {
         const path = (0, devkit_1.joinPathFragments)(projectRoot, 'package.json');
         const isPackageJsonProject = (0, minimatch_1.minimatch)(path, packageManagerWorkspacesGlob);
         if (!isPackageJsonProject) {
-            return {};
+            return false;
         }
     }
     const jestConfigContent = (0, fs_1.readFileSync)((0, path_1.resolve)(context.workspaceRoot, configFilePath), 'utf-8');
@@ -72,21 +114,9 @@ async function createNodesInternal(configFilePath, options, context, targetsCach
         // The `getJestProjectsAsync` function uses the project graph, which leads to a
         // circular dependency. We can skip this since it's no intended to be used for
         // an Nx project.
-        return {};
+        return false;
     }
-    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, presetCache);
-    const { targets, metadata } = targetsCache[hash];
-    return {
-        projects: {
-            [projectRoot]: {
-                root: projectRoot,
-                targets,
-                metadata,
-            },
-        },
-    };
+    return true;
 }
 async function buildJestTargets(configFilePath, projectRoot, options, context, presetCache) {
     const absConfigFilePath = (0, path_1.resolve)(context.workspaceRoot, configFilePath);
@@ -95,13 +125,18 @@ async function buildJestTargets(configFilePath, projectRoot, options, context, p
     const rawConfig = await (0, config_utils_1.loadConfigFile)(absConfigFilePath);
     const targets = {};
     const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const tsNodeCompilerOptions = JSON.stringify({
+        moduleResolution: 'node10',
+        module: 'commonjs',
+        customConditions: null,
+    });
     const target = (targets[options.targetName] = {
         command: 'jest',
         options: {
             cwd: projectRoot,
             // Jest registers ts-node with module CJS https://github.com/SimenB/jest/blob/v29.6.4/packages/jest-config/src/readConfigFileAndSetRootDir.ts#L117-L119
             // We want to support of ESM via 'module':'nodenext', we need to override the resolution until Jest supports it.
-            env: { TS_NODE_COMPILER_OPTIONS: '{"moduleResolution":"node10"}' },
+            env: { TS_NODE_COMPILER_OPTIONS: tsNodeCompilerOptions },
         },
         metadata: {
             technologies: ['jest'],
@@ -116,11 +151,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 cache = (target.cache = true);
-    const inputs = (target.inputs = getInputs(namedInputs, rawConfig.preset, projectRoot, context.workspaceRoot, options.disableJestRuntime));
+    const inputs = (target.inputs = getInputs(namedInputs, rawConfig.preset, projectRoot, context.workspaceRoot, disableJestRuntime));
     let metadata;
     const groupName = options?.ciGroupName ?? deductGroupNameFromTarget(options?.ciTargetName);
-    if (options.disableJestRuntime) {
+    if (disableJestRuntime) {
         const outputs = (target.outputs = getOutputs(projectRoot, rawConfig.coverageDirectory
             ? (0, path_1.join)(context.workspaceRoot, projectRoot, rawConfig.coverageDirectory)
             : undefined, undefined, context));
@@ -148,7 +185,7 @@ async function buildJestTargets(configFilePath, projectRoot, options, context, p
                     outputs,
                     options: {
                         cwd: projectRoot,
-                        env: { TS_NODE_COMPILER_OPTIONS: '{"moduleResolution":"node10"}' },
+                        env: { TS_NODE_COMPILER_OPTIONS: tsNodeCompilerOptions },
                     },
                     metadata: {
                         technologies: ['jest'],
@@ -192,10 +229,17 @@ async function buildJestTargets(configFilePath, projectRoot, options, context, p
     }
     else {
         const { readConfig } = requireJestUtil('jest-config', projectRoot, context.workspaceRoot);
-        const config = await readConfig({
-            _: [],
-            $0: undefined,
-        }, rawConfig, undefined, (0, path_1.dirname)(absConfigFilePath));
+        let config;
+        try {
+            config = await readConfig({
+                _: [],
+                $0: undefined,
+            }, rawConfig, undefined, (0, path_1.dirname)(absConfigFilePath));
+        }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
         const outputs = (target.outputs = getOutputs(projectRoot, config.globalConfig?.coverageDirectory, config.globalConfig?.outputFile, context));
         if (options?.ciTargetName) {
             // nx-ignore-next-line
@@ -208,8 +252,7 @@ async function buildJestTargets(configFilePath, projectRoot, options, context, p
             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, config.projectConfig)
                 : await source.getTestPaths(config.globalConfig);
             const testPaths = new Set(specs.tests.map(({ path }) => path));
             if (testPaths.size > 0) {
@@ -252,9 +295,7 @@ async function buildJestTargets(configFilePath, projectRoot, options, context, p
                         outputs,
                         options: {
                             cwd: projectRoot,
-                            env: {
-                                TS_NODE_COMPILER_OPTIONS: '{"moduleResolution":"node10"}',
-                            },
+                            env: { TS_NODE_COMPILER_OPTIONS: tsNodeCompilerOptions },
                         },
                         metadata: {
                             technologies: ['jest'],
@@ -378,7 +419,7 @@ function resolveJestPath(projectRoot, workspaceRoot) {
         return resolvedJestPaths[projectRoot];
     }
     resolvedJestPaths[projectRoot] = require.resolve('jest', {
-        paths: [projectRoot, workspaceRoot, __dirname],
+        paths: [projectRoot, ...(0, installation_directory_1.getNxRequirePaths)(workspaceRoot), __dirname],
     });
     return resolvedJestPaths[projectRoot];
 }
@@ -401,32 +442,19 @@ function requireJestUtil(packageName, projectRoot, workspaceRoot) {
 }
 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)), []);
-        }
+    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, path_1.join)(projectRoot, pattern)), []);
+    const testRegex = await getJestOption(rawConfig, absConfigFilePath, '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 paths;
 }
 async function getJestOption(rawConfig, absConfigFilePath, optionName, presetCache) {
     if (rawConfig[optionName])

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

@@ -1,25 +1,3 @@
-/**
- * TODO(v21): Remove this function
- * @deprecated To get projects use {@link getJestProjectsAsync} instead. This will be removed in v21.
- * Get a list of paths to all the jest config files
- * using the Nx Jest executor.
- *
- * This is used to configure Jest multi-project support. To support projects
- * using inferred targets @see getJestProjectsAsync
- *
- * To add a project not using the Nx Jest executor:
- * export default {
- *   projects: [...getJestProjects(), '<rootDir>/path/to/jest.config.ts'];
- * }
- *
- **/
-export declare function getJestProjects(): string[];
-/**
- * a list of nested projects that have jest configured
- * to be used in the testPathIgnorePatterns property of a given jest config
- * https://jestjs.io/docs/configuration#testpathignorepatterns-arraystring
- * */
-export declare function getNestedJestProjects(): string[];
 /**
  * Get a list of paths to all the jest config files
  * using the Nx Jest executor and `@nx/run:commands`

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

@@ -1,70 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getJestProjects = getJestProjects;
-exports.getNestedJestProjects = getNestedJestProjects;
 exports.getJestProjectsAsync = getJestProjectsAsync;
 const devkit_1 = require("@nx/devkit");
-const file_utils_1 = require("nx/src/project-graph/file-utils");
 const path_1 = require("path");
 const yargs = require("yargs-parser");
 function getJestConfigProjectPath(projectJestConfigPath) {
     return (0, path_1.join)('<rootDir>', projectJestConfigPath);
 }
-/**
- * TODO(v21): Remove this function
- * @deprecated To get projects use {@link getJestProjectsAsync} instead. This will be removed in v21.
- * Get a list of paths to all the jest config files
- * using the Nx Jest executor.
- *
- * This is used to configure Jest multi-project support. To support projects
- * using inferred targets @see getJestProjectsAsync
- *
- * To add a project not using the Nx Jest executor:
- * export default {
- *   projects: [...getJestProjects(), '<rootDir>/path/to/jest.config.ts'];
- * }
- *
- **/
-function getJestProjects() {
-    const ws = (0, file_utils_1.readWorkspaceConfig)({
-        format: 'nx',
-    });
-    const jestConfigurationSet = new Set();
-    for (const projectConfig of Object.values(ws.projects)) {
-        if (!projectConfig.targets) {
-            continue;
-        }
-        for (const targetConfiguration of Object.values(projectConfig.targets)) {
-            if (targetConfiguration.executor !== '@nx/jest:jest' &&
-                targetConfiguration.executor !== '@nrwl/jest:jest') {
-                continue;
-            }
-            if (targetConfiguration.options?.jestConfig) {
-                jestConfigurationSet.add(getJestConfigProjectPath(targetConfiguration.options.jestConfig));
-            }
-            if (targetConfiguration.configurations) {
-                for (const configurationObject of Object.values(targetConfiguration.configurations)) {
-                    if (configurationObject.jestConfig) {
-                        jestConfigurationSet.add(getJestConfigProjectPath(configurationObject.jestConfig));
-                    }
-                }
-            }
-        }
-    }
-    return Array.from(jestConfigurationSet);
-}
-/**
- * a list of nested projects that have jest configured
- * to be used in the testPathIgnorePatterns property of a given jest config
- * https://jestjs.io/docs/configuration#testpathignorepatterns-arraystring
- * */
-function getNestedJestProjects() {
-    // TODO(caleb): get current project path and list of all projects and their rootDir
-    // return a list of all projects that are nested in the current projects path
-    // always include node_modules as that's the default
-    const allProjects = getJestProjects();
-    return ['/node_modules/'];
-}
 /**
  * Get a list of paths to all the jest config files
  * using the Nx Jest executor and `@nx/run:commands`

package/src/generators/configuration/lib/update-jestconfig.d.ts

@@ -1,3 +0,0 @@
-import { type Tree } from '@nx/devkit';
-import type { NormalizedJestProjectSchema } from '../schema';
-export declare function updateJestConfig(host: Tree, options: NormalizedJestProjectSchema): void;

package/src/generators/configuration/lib/update-jestconfig.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateJestConfig = updateJestConfig;
-const devkit_1 = require("@nx/devkit");
-const config_file_1 = require("../../../utils/config/config-file");
-const update_config_1 = require("../../../utils/config/update-config");
-function isUsingUtilityFunction(host) {
-    const rootConfig = (0, config_file_1.findRootJestConfig)(host);
-    if (!rootConfig) {
-        return false;
-    }
-    const rootConfigContent = host.read(rootConfig, 'utf-8');
-    return (rootConfigContent.includes('getJestProjects()') ||
-        rootConfigContent.includes('getJestProjectsAsync()'));
-}
-function updateJestConfig(host, options) {
-    if (isUsingUtilityFunction(host)) {
-        return;
-    }
-    const project = (0, devkit_1.readProjectConfiguration)(host, options.project);
-    const rootConfig = (0, config_file_1.findRootJestConfig)(host);
-    if (rootConfig) {
-        (0, update_config_1.addPropertyToJestConfig)(host, (0, config_file_1.findRootJestConfig)(host), 'projects', `<rootDir>/${project.root}`);
-    }
-}

package/src/migrations/update-17-1-0/move-options-to-target-defaults.js

@@ -1,117 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = update;
-const devkit_1 = require("@nx/devkit");
-const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
-const project_configuration_utils_1 = require("nx/src/project-graph/utils/project-configuration-utils");
-async function update(tree) {
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    // Don't override anything if there are already target defaults for jest
-    if (nxJson.targetDefaults?.['@nx/jest:jest']) {
-        return;
-    }
-    nxJson.targetDefaults ??= {};
-    /**
-     * A set of targets which does not use any other executors
-     */
-    const jestTargets = new Set();
-    const graph = await (0, devkit_1.createProjectGraphAsync)();
-    (0, executor_options_utils_1.forEachExecutorOptionsInGraph)(graph, '@nx/jest:jest', (value, proj, targetName) => {
-        jestTargets.add(targetName);
-    });
-    // Workspace does not use jest?
-    if (jestTargets.size === 0) {
-        return;
-    }
-    // Use the project graph so targets which are inferred are considered
-    const projects = graph.nodes;
-    const projectMap = (0, devkit_1.getProjects)(tree);
-    const jestDefaults = (nxJson.targetDefaults['@nx/jest:jest'] = {});
-    // All jest targets have the same name
-    if (jestTargets.size === 1) {
-        const targetName = Array.from(jestTargets)[0];
-        if (nxJson.targetDefaults[targetName]) {
-            Object.assign(jestDefaults, nxJson.targetDefaults[targetName]);
-        }
-    }
-    jestDefaults.cache ??= true;
-    const inputs = ['default'];
-    inputs.push(nxJson.namedInputs?.production ? '^production' : '^default');
-    if (tree.exists('jest.preset.js')) {
-        inputs.push('{workspaceRoot}/jest.preset.js');
-    }
-    jestDefaults.inputs ??= inputs;
-    // Remember if there were already defaults so we don't assume the executor default
-    const passWithNoTestsPreviouslyInDefaults = jestDefaults.options?.passWithNoTests !== undefined;
-    const ciCiPreviouslyInDefaults = jestDefaults.configurations?.ci?.ci !== undefined;
-    const ciCodeCoveragePreviouslyInDefaults = jestDefaults.configurations?.ci?.codeCoverage !== undefined;
-    jestDefaults.options ??= {};
-    jestDefaults.options.passWithNoTests ??= true;
-    jestDefaults.configurations ??= {};
-    jestDefaults.configurations.ci ??= {};
-    jestDefaults.configurations.ci.ci ??= true;
-    jestDefaults.configurations.ci.codeCoverage ??= true;
-    // Cleanup old target defaults
-    for (const [targetDefaultKey, targetDefault] of Object.entries(nxJson.targetDefaults)) {
-        if (!isTargetDefaultUsed(targetDefault, nxJson.targetDefaults, projects, projectMap)) {
-            delete nxJson.targetDefaults[targetDefaultKey];
-        }
-    }
-    (0, devkit_1.updateNxJson)(tree, nxJson);
-    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/jest:jest', (value, proj, targetName, configuration) => {
-        const projConfig = projectMap.get(proj);
-        if (!configuration) {
-            // Options
-            if (value.passWithNoTests === jestDefaults.options.passWithNoTests) {
-                delete projConfig.targets[targetName].options.passWithNoTests;
-            }
-            else if (!passWithNoTestsPreviouslyInDefaults) {
-                projConfig.targets[targetName].options.passWithNoTests ??= false;
-            }
-            if (Object.keys(projConfig.targets[targetName].options).length === 0) {
-                delete projConfig.targets[targetName].options;
-            }
-        }
-        else if (configuration === 'ci') {
-            // CI Config
-            if (value.ci === jestDefaults.configurations.ci.ci) {
-                delete projConfig.targets[targetName].configurations.ci.ci;
-            }
-            else if (ciCiPreviouslyInDefaults) {
-                projConfig.targets[targetName].configurations.ci.ci ??= false;
-            }
-            if (value.codeCoverage === jestDefaults.configurations.ci.codeCoverage) {
-                delete projConfig.targets[targetName].configurations.ci.codeCoverage;
-            }
-            else if (ciCodeCoveragePreviouslyInDefaults) {
-                projConfig.targets[targetName].configurations.ci.codeCoverage ??=
-                    false;
-            }
-            if (Object.keys(projConfig.targets[targetName].configurations.ci)
-                .length === 0) {
-                delete projConfig.targets[targetName].configurations.ci;
-            }
-            if (Object.keys(projConfig.targets[targetName].configurations).length ===
-                0) {
-                delete projConfig.targets[targetName].configurations;
-            }
-        }
-        (0, devkit_1.updateProjectConfiguration)(tree, proj, projConfig);
-    });
-    await (0, devkit_1.formatFiles)(tree);
-}
-/**
- * Checks every target on every project to see if one of them uses the target default
- */
-function isTargetDefaultUsed(targetDefault, targetDefaults, projects, projectMap) {
-    for (const p of Object.values(projects)) {
-        for (const targetName in p.data?.targets ?? {}) {
-            if ((0, project_configuration_utils_1.readTargetDefaultsForTarget)(targetName, targetDefaults, 
-            // It might seem like we should use the graph here too but we don't want to pass an executor which was processed in the graph
-            projectMap.get(p.name)?.targets?.[targetName]?.executor) === targetDefault) {
-                return true;
-            }
-        }
-    }
-    return false;
-}