@nx/jest 0.0.0-pr-22179-271588f

package/src/migrations/update-15-8-0/update-configs-jest-29.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateConfigsJest29 = void 0;
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const ast_utils_1 = require("../../utils/ast-utils");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const ts = require("typescript");
+const find_root_jest_files_1 = require("../../utils/config/find-root-jest-files");
+async function updateConfigsJest29(tree) {
+    const rootPreset = (0, find_root_jest_files_1.findRootJestPreset)(tree);
+    const targetsWithJest = new Set();
+    // have to use graph so the negative configuration targets are expanded
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    (0, executor_options_utils_1.forEachExecutorOptionsInGraph)(graph, '@nrwl/jest:jest', (options, projectName, targetName) => {
+        if (options.jestConfig && tree.exists(options.jestConfig)) {
+            targetsWithJest.add(targetName);
+            // if the default root preset exists or if the project doesn't have a 'preset' configured
+            //  -> update snapshot config
+            if (!rootPreset || !hasPresetConfigured(tree, options.jestConfig)) {
+                addSnapshotOptionsToConfig(tree, options.jestConfig, `From within the project directory, run "nx test --update-snapshot"`);
+            }
+            updateTsJestOptions(tree, options.jestConfig);
+            updateNgJestOptions(tree, options.jestConfig);
+        }
+    });
+    if (rootPreset && tree.exists(rootPreset)) {
+        const cmd = `"nx affected --targets=${Array.from(targetsWithJest).join(',')} --update-snapshot"`;
+        addSnapshotOptionsToConfig(tree, rootPreset, cmd);
+        updateTsJestOptions(tree, rootPreset);
+        updateNgJestOptions(tree, rootPreset);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+    devkit_1.logger.info((0, devkit_1.stripIndents) `NX Jest Snapshot format changed in v29.
+By default Nx kept the older style to prevent breaking of existing tests with snapshots.
+It's recommend you update to the latest format.
+You can do this in your project's jest config file.
+Remove the snapshotFormat property and re-run tests with the --update-snapshot flag.
+More info: https://jestjs.io/docs/upgrading-to-jest29#snapshot-format`);
+}
+exports.updateConfigsJest29 = updateConfigsJest29;
+function addSnapshotOptionsToConfig(tree, configPath, updateSnapshotExample) {
+    const config = tree.read(configPath, 'utf-8');
+    const hasSnapshotOptions = tsquery_1.tsquery.query(config, `${ast_utils_1.TS_QUERY_JEST_CONFIG_PREFIX} > ObjectLiteralExpression PropertyAssignment:has(Identifier[name="snapshotFormat"])`);
+    if (hasSnapshotOptions.length > 0) {
+        return;
+    }
+    const updatedConfig = tsquery_1.tsquery.replace(config, `${ast_utils_1.TS_QUERY_JEST_CONFIG_PREFIX} > ObjectLiteralExpression`, (node) => {
+        return `{
+${node.properties.map((p) => getNodeWithComments(config, p)).join(',\n')},
+/* TODO: Update to latest Jest snapshotFormat
+ * By default Nx has kept the older style of Jest Snapshot formats
+ * to prevent breaking of any existing tests with snapshots.
+ * It's recommend you update to the latest format.
+ * You can do this by removing snapshotFormat property
+ * and running tests with --update-snapshot flag.
+ * Example: ${updateSnapshotExample}
+ * More info: https://jestjs.io/docs/upgrading-to-jest29#snapshot-format
+ */
+snapshotFormat: { escapeString: true, printBasicPrototype: true }
+}`;
+    }, { visitAllChildren: false });
+    tree.write(configPath, updatedConfig);
+}
+function hasPresetConfigured(tree, configPath) {
+    const contents = tree.read(configPath, 'utf-8');
+    return (tsquery_1.tsquery.query(contents, `${ast_utils_1.TS_QUERY_JEST_CONFIG_PREFIX} > ObjectLiteralExpression PropertyAssignment:has(Identifier[name="preset"])`)?.length > 0);
+}
+function updateTsJestOptions(tree, configPath) {
+    // query for the globals property, if they don't have one then there's nothing to modify.
+    const contents = tree.read(configPath, 'utf-8');
+    let tsJestGlobalsConfig;
+    const noTsJestGlobals = tsquery_1.tsquery.replace(contents, `${ast_utils_1.TS_QUERY_JEST_CONFIG_PREFIX} > ObjectLiteralExpression PropertyAssignment:has(Identifier[name="globals"])`, (node) => {
+        if (tsJestGlobalsConfig) {
+            devkit_1.logger.warn((0, devkit_1.stripIndents) `Found more than one "globals" object in the jest config, ${configPath}
+          Will use the first one`);
+            return;
+        }
+        tsJestGlobalsConfig = getGlobalTsJestConfig(node);
+        return getGlobalConfigWithoutTsJest(node);
+    });
+    if (!tsJestGlobalsConfig) {
+        return;
+    }
+    const updatedTsJestTransformer = tsquery_1.tsquery.replace(noTsJestGlobals, `${ast_utils_1.TS_QUERY_JEST_CONFIG_PREFIX}> ObjectLiteralExpression PropertyAssignment:has(Identifier[name="transform"]) PropertyAssignment > :has(StringLiteral[value="ts-jest"], StringLiteral[value="jest-preset-angular"])`, (node) => {
+        return `[${node.getText()}, ${tsJestGlobalsConfig}]`;
+    });
+    tree.write(configPath, updatedTsJestTransformer);
+}
+function updateNgJestOptions(tree, configPath) {
+    const contents = tree.read(configPath, 'utf-8');
+    let ngJestTeardownConfig;
+    const noTeardownConfig = tsquery_1.tsquery.replace(contents, 'BinaryExpression:has(PropertyAccessExpression:has(Identifier[name=ngJest]))  PropertyAssignment:has(Identifier[name=teardown])', (node) => {
+        ngJestTeardownConfig = node.initializer.getText();
+        return ' ';
+    });
+    if (!ngJestTeardownConfig) {
+        return;
+    }
+    let maybeUpdatedTestEnvOpts = tsquery_1.tsquery.replace(noTeardownConfig, `${ast_utils_1.TS_QUERY_JEST_CONFIG_PREFIX} > ObjectLiteralExpression PropertyAssignment:has(Identifier[name="testEnvironmentOptions"]) ObjectLiteralExpression`, (node) => {
+        return `{
+  ${node.properties
+            .map((p) => getNodeWithComments(noTeardownConfig, p))
+            .join(',\n')},
+   teardown: ${ngJestTeardownConfig}
+  }`;
+    });
+    if (maybeUpdatedTestEnvOpts !== noTeardownConfig) {
+        tree.write(configPath, maybeUpdatedTestEnvOpts);
+        return;
+    }
+    // didn't find existing testEnvironmentOptions, so add the new property
+    const updatedConfig = tsquery_1.tsquery.replace(maybeUpdatedTestEnvOpts, `${ast_utils_1.TS_QUERY_JEST_CONFIG_PREFIX} > ObjectLiteralExpression`, (node) => {
+        return `{
+${node.properties
+            .map((p) => getNodeWithComments(maybeUpdatedTestEnvOpts, p))
+            .join(',\n')},
+testEnvironmentOptions: { teardown: ${ngJestTeardownConfig} }, 
+}`;
+    }, { visitAllChildren: false });
+    tree.write(configPath, updatedConfig);
+}
+function getGlobalTsJestConfig(node) {
+    const globalObject = node.initializer;
+    const foundConfig = globalObject.properties.find((p) => ts.isPropertyAssignment(p) && p.name.getText().includes('ts-jest'));
+    return foundConfig?.initializer?.getText() || '';
+}
+function getGlobalConfigWithoutTsJest(node) {
+    const globalObject = node?.initializer;
+    const withoutTsJest = globalObject?.properties?.filter((p) => {
+        return !(ts.isPropertyAssignment(p) && p.name.getText().includes('ts-jest'));
+    });
+    const globalConfigs = withoutTsJest.map((c) => c.getText()).join(',\n');
+    return `globals: { ${globalConfigs} }`;
+}
+function getNodeWithComments(fullText, node) {
+    const commentRanges = ts.getLeadingCommentRanges(fullText, node.getFullStart());
+    if (commentRanges?.length > 0) {
+        const withComments = `${commentRanges
+            .map((r) => fullText.slice(r.pos, r.end))
+            .join('\n')}\n${node.getText()}`;
+        return withComments;
+    }
+    return node.getText();
+}
+exports.default = updateConfigsJest29;

package/src/migrations/update-15-8-0/update-tests-jest-29.d.ts

@@ -0,0 +1,5 @@
+import { Tree } from '@nx/devkit';
+export declare function updateTestsJest29(tree: Tree): Promise<void>;
+export declare function updateJestMockTypes(tree: Tree, filePath: string): void;
+export declare function updateJestMocked(tree: Tree, filePath: string): void;
+export default updateTestsJest29;

package/src/migrations/update-15-8-0/update-tests-jest-29.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateJestMocked = exports.updateJestMockTypes = exports.updateTestsJest29 = void 0;
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const ast_utils_1 = require("../../utils/ast-utils");
+async function updateTestsJest29(tree) {
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    (0, executor_options_utils_1.forEachExecutorOptionsInGraph)(graph, '@nrwl/jest:jest', (options, projectName) => {
+        const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+        (0, devkit_1.visitNotIgnoredFiles)(tree, projectConfig.sourceRoot || projectConfig.root, (file) => {
+            if (!ast_utils_1.TEST_FILE_PATTERN.test(file)) {
+                return;
+            }
+            updateJestMockTypes(tree, file);
+            updateJestMocked(tree, file);
+        });
+    });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.updateTestsJest29 = updateTestsJest29;
+function updateJestMockTypes(tree, filePath) {
+    const contents = tree.read(filePath, 'utf-8');
+    const updatedContent = tsquery_1.tsquery.replace(contents, ':matches(ImportDeclaration, VariableStatement):has(Identifier[name="MaybeMockedDeep"], Identifier[name="MaybeMocked"]):has(StringLiteral[value="jest-mock"])', (node) => {
+        const text = node.getText();
+        return (text
+            // MaybeMockedDeep and MaybeMocked now are exported as Mocked and MockedShallow
+            .replace('MaybeMockedDeep', 'Mocked')
+            .replace('MaybeMocked', 'MockedShallow'));
+    });
+    tree.write(filePath, updatedContent);
+}
+exports.updateJestMockTypes = updateJestMockTypes;
+function updateJestMocked(tree, filePath) {
+    const contents = tree.read(filePath, 'utf-8');
+    const jestGlobalNodes = tsquery_1.tsquery.query(contents, ':matches(ImportDeclaration, VariableStatement):has(Identifier[name="jest"]):has(StringLiteral[value="@jest/globals"])');
+    // this only applies if using jest from @jest/globals
+    if (jestGlobalNodes.length === 0) {
+        return;
+    }
+    const updatedJestMockTypes = tsquery_1.tsquery.replace(contents, 'CallExpression:has(Identifier[name="jest"]):has(Identifier[name="mocked"])', (node) => {
+        if (node.arguments.length === 2 &&
+            node.getText().startsWith('jest.mocked(')) {
+            const text = node.getText();
+            // jest.mocked(someObject, true); => jest.mocked(someObject);
+            if (node.arguments[1].getText() === 'true') {
+                return text.replace(/,\s*true/g, '');
+            }
+            // jest.mocked(someObject, false); => jest.mocked(someObject, {shallow: true});
+            // opt into the new behavior unless explicitly opting out
+            if (node.arguments[1].getText() === 'false') {
+                return text.replace('false', '{shallow: true}');
+            }
+        }
+    });
+    tree.write(filePath, updatedJestMockTypes);
+}
+exports.updateJestMocked = updateJestMocked;
+exports.default = updateTestsJest29;

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.d.ts

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

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const replace_package_1 = require("@nx/devkit/src/utils/replace-package");
+async function replacePackage(tree) {
+    await (0, replace_package_1.replaceNrwlPackageWithNxPackage)(tree, '@nrwl/jest', '@nx/jest');
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = replacePackage;

package/src/migrations/update-16-5-0/add-test-setup-to-inputs-ignore.d.ts

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

package/src/migrations/update-16-5-0/add-test-setup-to-inputs-ignore.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTestSetupToIgnoredInputs = void 0;
+const devkit_1 = require("@nx/devkit");
+async function addTestSetupToIgnoredInputs(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (!nxJson) {
+        return;
+    }
+    if (nxJson.namedInputs?.production &&
+        !nxJson.namedInputs.production.includes('!{projectRoot}/src/test-setup.[jt]s')) {
+        nxJson.namedInputs.production.push('!{projectRoot}/src/test-setup.[jt]s');
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.addTestSetupToIgnoredInputs = addTestSetupToIgnoredInputs;
+exports.default = addTestSetupToIgnoredInputs;

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/ast-utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * match testing file based on their name file
+ */
+export declare const TEST_FILE_PATTERN: RegExp;
+/**
+ * Match right hand side of `export default` or `module.exports` = statements
+ */
+export declare const TS_QUERY_JEST_CONFIG_PREFIX = ":matches(ExportAssignment, BinaryExpression:has(Identifier[name=\"module\"]):has(Identifier[name=\"exports\"]))";
+export declare function addTransformerToConfig(configContents: string, transformer: string): string;

package/src/utils/ast-utils.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTransformerToConfig = exports.TS_QUERY_JEST_CONFIG_PREFIX = exports.TEST_FILE_PATTERN = void 0;
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+/**
+ * match testing file based on their name file
+ */
+exports.TEST_FILE_PATTERN = new RegExp('.*(spec|test).[jt]sx?$');
+/**
+ * Match right hand side of `export default` or `module.exports` = statements
+ */
+exports.TS_QUERY_JEST_CONFIG_PREFIX = ':matches(ExportAssignment, BinaryExpression:has(Identifier[name="module"]):has(Identifier[name="exports"]))';
+function addTransformerToConfig(configContents, transformer) {
+    // TODO make sure there isn't an existing matching transformer regex
+    const transformerConfig = tsquery_1.tsquery.query(configContents, `${exports.TS_QUERY_JEST_CONFIG_PREFIX} > ObjectLiteralExpression PropertyAssignment:has(Identifier[name="transform"])`);
+    if (transformerConfig.length === 0) {
+        return tsquery_1.tsquery.replace(configContents, `${exports.TS_QUERY_JEST_CONFIG_PREFIX} > ObjectLiteralExpression`, (node) => {
+            return `{
+${node.properties.map((p) => p.getText()).join(',\n')},
+transform: { ${transformer} }
+}`;
+        });
+    }
+    return tsquery_1.tsquery.replace(configContents, `${exports.TS_QUERY_JEST_CONFIG_PREFIX} > ObjectLiteralExpression PropertyAssignment:has(Identifier[name="transform"])`, (node) => {
+        const transformObject = node.initializer;
+        const transformProperties = transformObject.properties
+            .map((p) => p.getText())
+            .join(',\n');
+        return `transform: { ${transformer}, ${transformProperties} }`;
+    });
+}
+exports.addTransformerToConfig = addTransformerToConfig;

package/src/utils/config/find-root-jest-files.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export declare function findRootJestConfig(tree: Tree): string | null;
+export declare function findRootJestPreset(tree: Tree): string | null;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRootJestPreset = exports.findRootJestConfig = void 0;
+function findRootJestConfig(tree) {
+    if (tree.exists('jest.config.js')) {
+        return 'jest.config.js';
+    }
+    if (tree.exists('jest.config.ts')) {
+        return 'jest.config.ts';
+    }
+    return null;
+}
+exports.findRootJestConfig = findRootJestConfig;
+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/functions.d.ts

@@ -0,0 +1,17 @@
+import type * as ts from 'typescript';
+import { Tree } from '@nx/devkit';
+import { Config } from '@jest/types';
+export declare function addOrUpdateProperty(tree: Tree, object: ts.ObjectLiteralExpression, properties: string[], value: unknown, path: string): any[];
+export declare function removeProperty(object: ts.ObjectLiteralExpression, properties: string[]): ts.PropertyAssignment | null;
+/**
+ * Should be used to get the jest config object as AST
+ */
+export declare function jestConfigObjectAst(fileContent: string): ts.ObjectLiteralExpression;
+/**
+ * Returns the jest config object
+ * @param host
+ * @param path
+ */
+export declare function jestConfigObject(host: Tree, path: string): Partial<Config.InitialOptions> & {
+    [index: string]: any;
+};