@nx/jest 17.0.2 → 17.0.4

package/src/generators/init/init.js

@@ -1,79 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.jestInitGenerator = void 0;
+exports.jestInitGeneratorInternal = exports.jestInitGenerator = void 0;
 const devkit_1 = require("@nx/devkit");
-const js_1 = require("@nx/js");
-const find_root_jest_files_1 = require("../../utils/config/find-root-jest-files");
+const update_package_scripts_1 = require("@nx/devkit/src/utils/update-package-scripts");
+const plugin_1 = require("../../plugins/plugin");
 const versions_1 = require("../../utils/versions");
-const schemaDefaults = {
-    compiler: 'tsc',
-    js: false,
-    rootProject: false,
-    testEnvironment: 'jsdom',
-};
-function generateGlobalConfig(tree, isJS) {
-    const contents = isJS
-        ? (0, devkit_1.stripIndents) `
-    const { getJestProjects } = require('@nx/jest');
-
-    module.exports = {
-      projects: getJestProjects()
-    };`
-        : (0, devkit_1.stripIndents) `
-    import { getJestProjects } from '@nx/jest';
-
-    export default {
-     projects: getJestProjects()
-    };`;
-    tree.write(`jest.config.${isJS ? 'js' : 'ts'}`, contents);
-}
-function createJestConfig(tree, options) {
-    if (!tree.exists('jest.preset.js')) {
-        // preset is always js file.
-        tree.write(`jest.preset.js`, `
-      const nxPreset = require('@nx/jest/preset').default;
-
-      module.exports = { ...nxPreset }`);
-        addTestInputs(tree);
-    }
-    if (options.rootProject) {
-        // we don't want any config to be made because the `configurationGenerator` will do it.
-        // will copy the template config file
-        return;
-    }
-    const rootJestPath = (0, find_root_jest_files_1.findRootJestConfig)(tree);
-    if (!rootJestPath) {
-        // if there's not root jest config, we will create one and return
-        // this can happen when:
-        // - root jest config was renamed => in which case there is migration needed
-        // - root project didn't have jest setup => again, no migration is needed
-        generateGlobalConfig(tree, options.js);
-        return;
-    }
-    if (tree.exists(rootJestPath)) {
-        // moving from root project config to monorepo-style config
-        const projects = (0, devkit_1.getProjects)(tree);
-        const projectNames = Array.from(projects.keys());
-        const rootProject = projectNames.find((projectName) => projects.get(projectName)?.root === '.');
-        // root project might have been removed,
-        // if it's missing there's nothing to migrate
-        if (rootProject) {
-            const rootProjectConfig = projects.get(rootProject);
-            const jestTarget = Object.values(rootProjectConfig.targets || {}).find((t) => t?.executor === '@nx/jest:jest' || t?.executor === '@nrwl/jest:jest');
-            const isProjectConfig = jestTarget?.options?.jestConfig === rootJestPath;
-            // if root project doesn't have jest target, there's nothing to migrate
-            if (isProjectConfig) {
-                const jestProjectConfig = `jest.config.${rootProjectConfig.projectType === 'application' ? 'app' : 'lib'}.${options.js ? 'js' : 'ts'}`;
-                tree.rename(rootJestPath, jestProjectConfig);
-                jestTarget.options.jestConfig = jestProjectConfig;
-                (0, devkit_1.updateProjectConfiguration)(tree, rootProject, rootProjectConfig);
-            }
-            // generate new global config as it was move to project config or is missing
-            generateGlobalConfig(tree, options.js);
-        }
+const is_preset_cjs_1 = require("../../utils/config/is-preset-cjs");
+function addPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.plugins ??= [];
+    if (!nxJson.plugins.some((p) => typeof p === 'string'
+        ? p === '@nx/jest/plugin'
+        : p.plugin === '@nx/jest/plugin')) {
+        nxJson.plugins.push({
+            plugin: '@nx/jest/plugin',
+            options: {
+                targetName: 'test',
+            },
+        });
     }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
 }
-function addTestInputs(tree) {
+function updateProductionFileSet(tree, presetExt) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const productionFileSet = nxJson.namedInputs?.production;
     if (productionFileSet) {
@@ -91,80 +39,68 @@ function addTestInputs(tree) {
         // Dedupe and set
         nxJson.namedInputs.production = Array.from(new Set(productionFileSet));
     }
-    // Test targets depend on all their project's sources + production sources of dependencies
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+function addJestTargetDefaults(tree, presetEnv) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
     nxJson.targetDefaults ??= {};
-    nxJson.targetDefaults.test ??= {};
-    nxJson.targetDefaults.test.inputs ??= [
+    nxJson.targetDefaults['@nx/jest:jest'] ??= {};
+    const productionFileSet = nxJson.namedInputs?.production;
+    nxJson.targetDefaults['@nx/jest:jest'].cache ??= true;
+    // Test targets depend on all their project's sources + production sources of dependencies
+    nxJson.targetDefaults['@nx/jest:jest'].inputs ??= [
         'default',
         productionFileSet ? '^production' : '^default',
+        `{workspaceRoot}/jest.preset.${presetEnv}`,
     ];
-    nxJson.targetDefaults.test.inputs.push('{workspaceRoot}/jest.preset.js');
+    nxJson.targetDefaults['@nx/jest:jest'].options ??= {
+        passWithNoTests: true,
+    };
+    nxJson.targetDefaults['@nx/jest:jest'].configurations ??= {
+        ci: {
+            ci: true,
+            codeCoverage: true,
+        },
+    };
     (0, devkit_1.updateNxJson)(tree, nxJson);
 }
 function updateDependencies(tree, options) {
-    const dependencies = {
-        tslib: versions_1.tslibVersion,
-    };
-    const devDeps = {
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
         '@nx/jest': versions_1.nxVersion,
         jest: versions_1.jestVersion,
-        // because the default jest-preset uses ts-jest,
-        // jest will throw an error if it's not installed
-        // even if not using it in overriding transformers
-        'ts-jest': versions_1.tsJestVersion,
-    };
-    if (options.testEnvironment !== 'none') {
-        devDeps[`jest-environment-${options.testEnvironment}`] = versions_1.jestVersion;
-    }
-    if (!options.js) {
-        devDeps['ts-node'] = versions_1.tsNodeVersion;
-        devDeps['@types/jest'] = versions_1.jestTypesVersion;
-        devDeps['@types/node'] = versions_1.typesNodeVersion;
-    }
-    if (options.compiler === 'babel' || options.babelJest) {
-        devDeps['babel-jest'] = versions_1.babelJestVersion;
-        // in some cases @nx/js will not already be present i.e. node only projects
-        devDeps['@nx/js'] = versions_1.nxVersion;
-    }
-    else if (options.compiler === 'swc') {
-        devDeps['@swc/jest'] = versions_1.swcJestVersion;
-    }
-    return (0, devkit_1.addDependenciesToPackageJson)(tree, dependencies, devDeps);
+    }, undefined, options.keepExistingVersions);
 }
-function updateExtensions(host) {
-    if (!host.exists('.vscode/extensions.json')) {
-        return;
-    }
-    (0, devkit_1.updateJson)(host, '.vscode/extensions.json', (json) => {
-        json.recommendations = json.recommendations || [];
-        const extension = 'firsttris.vscode-jest-runner';
-        if (!json.recommendations.includes(extension)) {
-            json.recommendations.push(extension);
-        }
-        return json;
-    });
+function jestInitGenerator(tree, options) {
+    return jestInitGeneratorInternal(tree, { addPlugin: false, ...options });
 }
-async function jestInitGenerator(tree, schema) {
-    const options = normalizeOptions(schema);
+exports.jestInitGenerator = jestInitGenerator;
+async function jestInitGeneratorInternal(tree, options) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    options.addPlugin ??= addPluginDefault;
+    const presetExt = (0, is_preset_cjs_1.isPresetCjs)(tree) ? 'cjs' : 'js';
+    if (!tree.exists('jest.preset.js') && !tree.exists('jest.preset.cjs')) {
+        updateProductionFileSet(tree, presetExt);
+        if (options.addPlugin) {
+            addPlugin(tree);
+        }
+        else {
+            addJestTargetDefaults(tree, presetExt);
+        }
+    }
     const tasks = [];
-    tasks.push(await (0, js_1.initGenerator)(tree, {
-        ...schema,
-        skipFormat: true,
-    }));
-    createJestConfig(tree, options);
     if (!options.skipPackageJson) {
-        (0, devkit_1.removeDependenciesFromPackageJson)(tree, ['@nx/jest'], []);
-        const installTask = updateDependencies(tree, options);
-        tasks.push(installTask);
+        tasks.push((0, devkit_1.removeDependenciesFromPackageJson)(tree, ['@nx/jest'], []));
+        tasks.push(updateDependencies(tree, options));
+    }
+    if (options.updatePackageScripts) {
+        await (0, update_package_scripts_1.updatePackageScripts)(tree, plugin_1.createNodes);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
     }
-    updateExtensions(tree);
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
-exports.jestInitGenerator = jestInitGenerator;
-function normalizeOptions(options) {
-    return {
-        ...schemaDefaults,
-        ...options,
-    };
-}
+exports.jestInitGeneratorInternal = jestInitGeneratorInternal;
 exports.default = jestInitGenerator;

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

@@ -1,11 +1,8 @@
 export interface JestInitSchema {
-  compiler?: 'tsc' | 'babel' | 'swc';
-  js?: boolean;
+  skipFormat?: boolean;
   skipPackageJson?: boolean;
-  testEnvironment?: 'node' | 'jsdom' | 'none';
-  /**
-   * @deprecated
-   */
-  babelJest?: boolean;
-  rootProject?: boolean;
+  keepExistingVersions?: boolean;
+  updatePackageScripts?: boolean;
+
+  addPlugin?: boolean;
 }

package/src/generators/init/schema.json

@@ -1,16 +1,16 @@
 {
-  "$schema": "http://json-schema.org/schema",
+  "$schema": "https://json-schema.org/schema",
   "$id": "NxJestInit",
   "cli": "nx",
   "title": "Jest init",
   "description": "Add Jest Configuration to a workspace.",
   "type": "object",
   "properties": {
-    "babelJest": {
+    "skipFormat": {
+      "description": "Skip formatting files.",
       "type": "boolean",
-      "alias": "babel-jest",
-      "description": "Use `babel-jest` instead of `ts-jest`.",
-      "default": false
+      "default": false,
+      "x-priority": "internal"
     },
     "skipPackageJson": {
       "type": "boolean",
@@ -18,24 +18,17 @@
       "description": "Do not add dependencies to `package.json`.",
       "x-priority": "internal"
     },
-    "testEnvironment": {
-      "type": "string",
-      "enum": ["jsdom", "node", "none"],
-      "description": "The test environment for jest. This controls which jest-environment-* package is installed",
-      "default": "jsdom",
-      "x-priority": "important"
-    },
-    "js": {
+    "keepExistingVersions": {
       "type": "boolean",
-      "default": false,
-      "description": "Use JavaScript instead of TypeScript for config files"
+      "x-priority": "internal",
+      "description": "Keep existing dependencies versions",
+      "default": false
     },
-    "rootProject": {
-      "description": "initialize Jest for an application at the root of the workspace",
+    "updatePackageScripts": {
       "type": "boolean",
-      "default": false,
-      "hidden": true,
-      "x-priority": "internal"
+      "x-priority": "internal",
+      "description": "Update `package.json` scripts with inferred targets",
+      "default": false
     }
   },
   "required": []

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

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+}
+exports.default = update;
+/**
+ * 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;
+}

package/src/plugins/plugin.d.ts

@@ -0,0 +1,6 @@
+import { CreateDependencies, CreateNodes } from '@nx/devkit';
+export interface JestPluginOptions {
+    targetName?: string;
+}
+export declare const createDependencies: CreateDependencies;
+export declare const createNodes: CreateNodes<JestPluginOptions>;

package/src/plugins/plugin.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.createDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const project_configuration_utils_1 = require("nx/src/project-graph/utils/project-configuration-utils");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const fs_1 = require("fs");
+const jest_config_1 = require("jest-config");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const package_json_workspaces_1 = require("nx/src/plugins/package-json-workspaces");
+const globs_1 = require("nx/src/utils/globs");
+const minimatch_1 = require("minimatch");
+const cachePath = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'jest.hash');
+const targetsCache = (0, fs_1.existsSync)(cachePath) ? readTargetsCache() : {};
+const calculatedTargets = {};
+function readTargetsCache() {
+    return (0, devkit_1.readJsonFile)(cachePath);
+}
+function writeTargetsToCache(targets) {
+    (0, devkit_1.writeJsonFile)(cachePath, targets);
+}
+const createDependencies = () => {
+    writeTargetsToCache(calculatedTargets);
+    return [];
+};
+exports.createDependencies = createDependencies;
+exports.createNodes = [
+    '**/jest.config.{cjs,mjs,js,cts,mts,ts}',
+    async (configFilePath, options, context) => {
+        const projectRoot = (0, path_1.dirname)(configFilePath);
+        const packageManagerWorkspacesGlob = (0, globs_1.combineGlobPatterns)((0, package_json_workspaces_1.getGlobPatternsFromPackageManagerWorkspaces)(context.workspaceRoot));
+        // 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 {};
+        }
+        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 {};
+            }
+        }
+        const jestConfigContent = (0, fs_1.readFileSync)((0, path_1.resolve)(context.workspaceRoot, configFilePath), 'utf-8');
+        if (jestConfigContent.includes('getJestProjectsAsync()')) {
+            // 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 {};
+        }
+        options = normalizeOptions(options);
+        const hash = (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context);
+        const targets = targetsCache[hash] ??
+            (await buildJestTargets(configFilePath, projectRoot, options, context));
+        calculatedTargets[hash] = targets;
+        return {
+            projects: {
+                [projectRoot]: {
+                    root: projectRoot,
+                    targets: targets,
+                },
+            },
+        };
+    },
+];
+async function buildJestTargets(configFilePath, projectRoot, options, context) {
+    const config = await (0, jest_config_1.readConfig)({
+        _: [],
+        $0: undefined,
+    }, (0, path_1.resolve)(context.workspaceRoot, configFilePath));
+    const targetDefaults = (0, project_configuration_utils_1.readTargetDefaultsForTarget)(options.targetName, context.nxJsonConfiguration.targetDefaults, 'nx:run-commands');
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const targets = {};
+    const target = (targets[options.targetName] = {
+        command: 'jest',
+        options: {
+            cwd: projectRoot,
+        },
+    });
+    if (!targetDefaults?.cache) {
+        target.cache = true;
+    }
+    if (!targetDefaults?.inputs) {
+        target.inputs = getInputs(namedInputs);
+    }
+    if (!targetDefaults?.outputs) {
+        target.outputs = getOutputs(projectRoot, config, context);
+    }
+    return targets;
+}
+function getInputs(namedInputs) {
+    return [
+        ...('production' in namedInputs
+            ? ['default', '^production']
+            : ['default', '^default']),
+        {
+            externalDependencies: ['jest'],
+        },
+    ];
+}
+function getOutputs(projectRoot, { globalConfig }, context) {
+    function getOutput(path) {
+        const relativePath = (0, path_1.relative)((0, path_1.join)(context.workspaceRoot, projectRoot), path);
+        if (relativePath.startsWith('..')) {
+            return (0, path_1.join)('{workspaceRoot}', (0, path_1.join)(projectRoot, relativePath));
+        }
+        else {
+            return (0, path_1.join)('{projectRoot}', relativePath);
+        }
+    }
+    const outputs = [];
+    for (const outputOption of [
+        globalConfig.coverageDirectory,
+        globalConfig.outputFile,
+    ]) {
+        if (outputOption) {
+            outputs.push(getOutput(outputOption));
+        }
+    }
+    return outputs;
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.targetName ??= 'test';
+    return options;
+}

package/src/utils/config/find-root-jest-files.js

@@ -15,6 +15,9 @@ function findRootJestPreset(tree) {
     if (tree.exists('jest.preset.js')) {
         return 'jest.preset.js';
     }
+    if (tree.exists('jest.preset.cjs')) {
+        return 'jest.preset.cjs';
+    }
     return null;
 }
 exports.findRootJestPreset = findRootJestPreset;

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

@@ -2,7 +2,8 @@
  * 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.
+ * 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 {
@@ -17,3 +18,17 @@ export declare function getJestProjects(): string[];
  * 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`
+ * running `jest`.
+ *
+ * This is used to configure Jest multi-project support.
+ *
+ * To add a project not using the Nx Jest executor:
+ * export default async () => ({
+ *   projects: [...(await getJestProjectsAsync()), '<rootDir>/path/to/jest.config.ts'];
+ * });
+ *
+ **/
+export declare function getJestProjectsAsync(): Promise<string[]>;