@nx/jest 17.3.0-beta.1 → 17.3.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/jest",
-  "version": "17.3.0-beta.1",
+  "version": "17.3.0-beta.3",
   "private": false,
   "description": "The Nx Plugin for Jest contains executors and generators allowing your workspace to use the powerful Jest testing capabilities.",
   "repository": {
@@ -42,11 +42,12 @@
     "jest-config": "^29.4.1",
     "jest-resolve": "^29.4.1",
     "jest-util": "^29.4.1",
+    "minimatch": "3.0.5",
     "resolve.exports": "1.1.0",
     "tslib": "^2.3.0",
-    "@nx/devkit": "17.3.0-beta.1",
-    "@nx/js": "17.3.0-beta.1",
-    "@nrwl/jest": "17.3.0-beta.1"
+    "@nx/devkit": "17.3.0-beta.3",
+    "@nx/js": "17.3.0-beta.3",
+    "@nrwl/jest": "17.3.0-beta.3"
   },
   "publishConfig": {
     "access": "public"

package/plugin.d.ts

@@ -0,0 +1 @@
+export { createNodes, createDependencies, JestPluginOptions, } from './src/plugins/plugin';

package/plugin.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDependencies = exports.createNodes = void 0;
+var plugin_1 = require("./src/plugins/plugin");
+Object.defineProperty(exports, "createNodes", { enumerable: true, get: function () { return plugin_1.createNodes; } });
+Object.defineProperty(exports, "createDependencies", { enumerable: true, get: function () { return plugin_1.createDependencies; } });

package/src/generators/configuration/configuration.js

@@ -45,7 +45,13 @@ async function configurationGenerator(tree, schema) {
     (0, check_for_test_target_1.checkForTestTarget)(tree, options);
     (0, create_files_1.createFiles)(tree, options);
     (0, update_tsconfig_1.updateTsConfig)(tree, options);
-    (0, update_workspace_1.updateWorkspace)(tree, options);
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const hasPlugin = nxJson.plugins?.some((p) => typeof p === 'string'
+        ? p === '@nx/jest/plugin'
+        : p.plugin === '@nx/jest/plugin');
+    if (!hasPlugin) {
+        (0, update_workspace_1.updateWorkspace)(tree, options);
+    }
     if (!schema.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }

package/src/generators/init/init.js

@@ -5,6 +5,7 @@ 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 versions_1 = require("../../utils/versions");
+const project_configuration_utils_1 = require("nx/src/project-graph/utils/project-configuration-utils");
 const schemaDefaults = {
     compiler: 'tsc',
     js: false,
@@ -27,15 +28,36 @@ function generateGlobalConfig(tree, isJS) {
     };`;
     tree.write(`jest.config.${isJS ? 'js' : 'ts'}`, contents);
 }
-function createJestConfig(tree, options) {
+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);
+}
+async 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 }`);
+        const shouldAddPlugin = process.env.NX_PCV3 === 'true';
+        if (shouldAddPlugin) {
+            addPlugin(tree);
+        }
         updateProductionFileSet(tree);
-        addJestTargetDefaults(tree);
+        if (!shouldAddPlugin) {
+            addJestTargetDefaults(tree, shouldAddPlugin);
+        }
     }
     if (options.rootProject) {
         // we don't want any config to be made because the `configurationGenerator` will do it.
@@ -53,22 +75,56 @@ function createJestConfig(tree, options) {
     }
     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 === '.');
+        const { nodes: projects } = await (0, devkit_1.createProjectGraphAsync)();
+        const projectConfigurations = Object.values(projects);
+        const rootProject = projectConfigurations.find((projectNode) => projectNode.data?.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;
+            const jestTarget = Object.entries(rootProject.data?.targets ?? {}).find(([_, t]) => ((t?.executor === '@nx/jest:jest' ||
+                t?.executor === '@nrwl/jest:jest') &&
+                t?.options?.jestConfig === rootJestPath) ||
+                (t?.executor === 'nx:run-commands' && t?.options?.command === 'jest'));
+            if (!jestTarget) {
+                return;
+            }
+            const [jestTargetName, jestTargetConfigInGraph] = jestTarget;
             // 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);
+            const rootProjectConfig = (0, devkit_1.readProjectConfiguration)(tree, rootProject.name);
+            if (rootProjectConfig.targets['test']?.executor === 'nx:run-commands'
+                ? rootProjectConfig.targets['test']?.command !== 'jest'
+                : rootProjectConfig.targets['test']?.options?.jestConfig !==
+                    rootJestPath) {
+                // Jest target has already been updated
+                return;
             }
+            const jestProjectConfig = `jest.config.${rootProjectConfig.projectType === 'application' ? 'app' : 'lib'}.${options.js ? 'js' : 'ts'}`;
+            tree.rename(rootJestPath, jestProjectConfig);
+            const nxJson = (0, devkit_1.readNxJson)(tree);
+            const targetDefaults = (0, project_configuration_utils_1.readTargetDefaultsForTarget)(jestTargetName, nxJson.targetDefaults, jestTargetConfigInGraph.executor);
+            const target = (rootProjectConfig.targets[jestTargetName] ??=
+                jestTargetConfigInGraph.executor === 'nx:run-commands'
+                    ? { command: `jest --config ${jestProjectConfig}` }
+                    : {
+                        executor: jestTargetConfigInGraph.executor,
+                        options: {},
+                    });
+            if (target.executor === '@nx/jest:jest') {
+                target.options.jestConfig = jestProjectConfig;
+            }
+            if (targetDefaults?.cache === undefined) {
+                target.cache = jestTargetConfigInGraph.cache;
+            }
+            if (targetDefaults?.inputs === undefined) {
+                target.inputs = jestTargetConfigInGraph.inputs;
+            }
+            if (targetDefaults?.outputs === undefined) {
+                target.outputs = jestTargetConfigInGraph.outputs;
+            }
+            if (targetDefaults?.dependsOn === undefined) {
+                target.dependsOn = jestTargetConfigInGraph.dependsOn;
+            }
+            (0, devkit_1.updateProjectConfiguration)(tree, rootProject.name, rootProjectConfig);
             // generate new global config as it was move to project config or is missing
             generateGlobalConfig(tree, options.js);
         }
@@ -94,18 +150,20 @@ function updateProductionFileSet(tree) {
     }
     (0, devkit_1.updateNxJson)(tree, nxJson);
 }
-function addJestTargetDefaults(tree) {
+function addJestTargetDefaults(tree, hasPlugin) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
-    const productionFileSet = nxJson.namedInputs?.production;
     nxJson.targetDefaults ??= {};
     nxJson.targetDefaults['@nx/jest:jest'] ??= {};
-    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.js',
-    ];
+    if (!hasPlugin) {
+        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.js',
+        ];
+    }
     nxJson.targetDefaults['@nx/jest:jest'].options ??= {
         passWithNoTests: true,
     };
@@ -167,7 +225,7 @@ async function jestInitGenerator(tree, schema) {
         ...schema,
         skipFormat: true,
     }));
-    createJestConfig(tree, options);
+    await createJestConfig(tree, options);
     if (!options.skipPackageJson) {
         (0, devkit_1.removeDependenciesFromPackageJson)(tree, ['@nx/jest'], []);
         const installTask = updateDependencies(tree, options);

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,123 @@
+"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/plugins/package-json-workspaces");
+const globs_1 = require("nx/src/utils/globs");
+const minimatch = 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 = minimatch(path, packageManagerWorkspacesGlob);
+            if (!isPackageJsonProject) {
+                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), true, null, undefined, true);
+    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;
+}