@nx/jest 19.4.0-beta.0 → 19.4.0-beta.2

package/generators.json

@@ -5,7 +5,7 @@
     "init": {
       "factory": "./src/generators/init/init#jestInitGeneratorInternal",
       "schema": "./src/generators/init/schema.json",
-      "description": "Initialize the `@nrwl/jest` plugin.",
+      "description": "Initialize the `@nx/jest` plugin.",
       "aliases": ["ng-add"],
       "hidden": true
     },
@@ -14,6 +14,11 @@
       "schema": "./src/generators/configuration/schema.json",
       "description": "Add Jest configuration to a project.",
       "hidden": true
+    },
+    "convert-to-inferred": {
+      "factory": "./src/generators/convert-to-inferred/convert-to-inferred",
+      "schema": "./src/generators/convert-to-inferred/schema.json",
+      "description": "Convert existing Jest project(s) using `@nx/jest:jest` executor to use `@nx/jest/plugin`."
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/jest",
-  "version": "19.4.0-beta.0",
+  "version": "19.4.0-beta.2",
   "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": "19.4.0-beta.0",
-    "@nx/js": "19.4.0-beta.0",
+    "@nx/devkit": "19.4.0-beta.2",
+    "@nx/js": "19.4.0-beta.2",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "chalk": "^4.1.0",
     "identity-obj-proxy": "3.0.0",
@@ -49,7 +49,7 @@
     "resolve.exports": "1.1.0",
     "tslib": "^2.3.0",
     "yargs-parser": "21.1.1",
-    "@nrwl/jest": "19.4.0-beta.0"
+    "@nrwl/jest": "19.4.0-beta.2"
   },
   "publishConfig": {
     "access": "public"

package/src/generators/convert-to-inferred/convert-to-inferred.d.ts

@@ -0,0 +1,7 @@
+import { type Tree } from '@nx/devkit';
+interface Schema {
+    project?: string;
+    skipFormat?: boolean;
+}
+export declare function convertToInferred(tree: Tree, options: Schema): Promise<void>;
+export default convertToInferred;

package/src/generators/convert-to-inferred/convert-to-inferred.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToInferred = void 0;
+const devkit_1 = require("@nx/devkit");
+const executor_to_plugin_migrator_1 = require("@nx/devkit/src/generators/plugin-migrations/executor-to-plugin-migrator");
+const plugin_migration_utils_1 = require("@nx/devkit/src/generators/plugin-migrations/plugin-migration-utils");
+const jest_config_1 = require("jest-config");
+const node_path_1 = require("node:path");
+const plugin_1 = require("../../plugins/plugin");
+const config_file_1 = require("../../utils/config/config-file");
+async function convertToInferred(tree, options) {
+    const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
+    const migratedProjects = await (0, executor_to_plugin_migrator_1.migrateProjectExecutorsToPlugin)(tree, projectGraph, '@nx/jest/plugin', plugin_1.createNodesV2, { targetName: 'test' }, [
+        {
+            executors: ['@nx/jest:jest', '@nrwl/jest:jest'],
+            postTargetTransformer,
+            targetPluginOptionMapper: (targetName) => ({ targetName }),
+        },
+    ], options.project);
+    if (migratedProjects.size === 0) {
+        throw new Error('Could not find any targets to migrate.');
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.convertToInferred = convertToInferred;
+async function postTargetTransformer(target, tree, projectDetails, inferredTarget) {
+    const jestConfigPath = config_file_1.jestConfigExtensions
+        .map((ext) => `jest.config.${ext}`)
+        .find((configFileName) => tree.exists(node_path_1.posix.join(projectDetails.root, configFileName)));
+    if (target.options) {
+        await updateOptionsObject(target.options, projectDetails.root, tree.root, jestConfigPath);
+    }
+    if (target.configurations) {
+        for (const [configName, config] of Object.entries(target.configurations)) {
+            await updateConfigurationObject(config, projectDetails.root, tree.root, jestConfigPath);
+            if (!Object.keys(config).length) {
+                delete target.configurations[configName];
+            }
+        }
+        if (!Object.keys(target.configurations).length) {
+            delete target.defaultConfiguration;
+            delete target.configurations;
+        }
+        if ('defaultConfiguration' in target &&
+            !target.configurations?.[target.defaultConfiguration]) {
+            delete target.defaultConfiguration;
+        }
+    }
+    if (target.outputs) {
+        (0, plugin_migration_utils_1.processTargetOutputs)(target, [], inferredTarget, {
+            projectName: projectDetails.projectName,
+            projectRoot: projectDetails.root,
+        });
+    }
+    return target;
+}
+exports.default = convertToInferred;
+async function updateOptionsObject(targetOptions, projectRoot, workspaceRoot, defaultJestConfigPath) {
+    const jestConfigPath = targetOptions.jestConfig ?? defaultJestConfigPath;
+    // inferred targets are only identified after known files that Jest would
+    // pick up, so we can safely remove the config options
+    delete targetOptions.jestConfig;
+    delete targetOptions.config;
+    await updateOptions(targetOptions, projectRoot, workspaceRoot, jestConfigPath);
+}
+async function updateConfigurationObject(targetOptions, projectRoot, workspaceRoot, defaultJestConfigPath) {
+    const jestConfigPath = targetOptions.jestConfig ?? defaultJestConfigPath;
+    if (targetOptions.jestConfig) {
+        targetOptions.config = (0, plugin_migration_utils_1.toProjectRelativePath)(targetOptions.jestConfig, projectRoot);
+        delete targetOptions.jestConfig;
+    }
+    else if (targetOptions.config) {
+        targetOptions.config = (0, plugin_migration_utils_1.toProjectRelativePath)(targetOptions.config, projectRoot);
+    }
+    await updateOptions(targetOptions, projectRoot, workspaceRoot, jestConfigPath);
+}
+async function updateOptions(targetOptions, projectRoot, workspaceRoot, jestConfigPath) {
+    // deprecated and unused
+    delete targetOptions.tsConfig;
+    if ('codeCoverage' in targetOptions) {
+        targetOptions.coverage = targetOptions.codeCoverage;
+        delete targetOptions.codeCoverage;
+    }
+    const testPathPatterns = [];
+    if ('testFile' in targetOptions) {
+        testPathPatterns.push(toProjectRelativeRegexPath(targetOptions.testFile, projectRoot));
+        delete targetOptions.testFile;
+    }
+    if ('testPathPattern' in targetOptions) {
+        testPathPatterns.push(...targetOptions.testPathPattern.map((pattern) => toProjectRelativeRegexPath(pattern, projectRoot)));
+    }
+    if (testPathPatterns.length > 1) {
+        targetOptions.testPathPattern = `\"${testPathPatterns.join('|')}\"`;
+    }
+    else if (testPathPatterns.length === 1) {
+        targetOptions.testPathPattern = testPathPatterns[0];
+    }
+    if ('testPathIgnorePatterns' in targetOptions) {
+        if (targetOptions.testPathIgnorePatterns.length > 1) {
+            targetOptions.testPathIgnorePatterns = `\"${targetOptions.testPathIgnorePatterns
+                .map((pattern) => toProjectRelativeRegexPath(pattern, projectRoot))
+                .join('|')}\"`;
+        }
+        else if (targetOptions.testPathIgnorePatterns.length === 1) {
+            targetOptions.testPathIgnorePatterns = toProjectRelativeRegexPath(targetOptions.testPathIgnorePatterns[0], projectRoot);
+        }
+    }
+    if ('testMatch' in targetOptions) {
+        targetOptions.testMatch = targetOptions.testMatch
+            .map((pattern) => `"${toProjectRelativeGlobPath(pattern, projectRoot)}"`)
+            .join(' ');
+    }
+    if ('findRelatedTests' in targetOptions) {
+        // the executor accepts a comma-separated string, while jest accepts a space-separated string
+        const parsedSourceFiles = targetOptions.findRelatedTests
+            .split(',')
+            .map((s) => (0, plugin_migration_utils_1.toProjectRelativePath)(s.trim(), projectRoot))
+            .join(' ');
+        targetOptions.args = [`--findRelatedTests ${parsedSourceFiles}`];
+        delete targetOptions.findRelatedTests;
+    }
+    if ('setupFile' in targetOptions) {
+        const setupFiles = await processSetupFiles(targetOptions.setupFile, targetOptions.setupFilesAfterEnv, projectRoot, workspaceRoot, jestConfigPath);
+        if (setupFiles.length > 1) {
+            targetOptions.setupFilesAfterEnv = setupFiles
+                .map((sf) => `"${sf}"`)
+                .join(' ');
+        }
+        else if (setupFiles.length === 1) {
+            targetOptions.setupFilesAfterEnv = setupFiles[0];
+        }
+        else {
+            // if there are no setup files, it means they are already defined in the
+            // jest config, so we can remove the option
+            delete targetOptions.setupFilesAfterEnv;
+        }
+        delete targetOptions.setupFile;
+    }
+    if ('outputFile' in targetOptions) {
+        // update the output file to be relative to the project root
+        targetOptions.outputFile = (0, plugin_migration_utils_1.toProjectRelativePath)(targetOptions.outputFile, projectRoot);
+    }
+    if ('coverageDirectory' in targetOptions) {
+        // update the coverage directory to be relative to the project root
+        targetOptions.coverageDirectory = (0, plugin_migration_utils_1.toProjectRelativePath)(targetOptions.coverageDirectory, projectRoot);
+    }
+}
+async function processSetupFiles(setupFile, setupFilesAfterEnv, projectRoot, workspaceRoot, jestConfigPath) {
+    // the jest executor merges the setupFile with the setupFilesAfterEnv, so
+    // to keep the task working as before we resolve the setupFilesAfterEnv
+    // from the options or the jest config and add the setupFile to it
+    // https://github.com/nrwl/nx/blob/bdd3375256613340899f649eb800d22abcc9f507/packages/jest/src/executors/jest/jest.impl.ts#L107-L113
+    const configSetupFilesAfterEnv = [];
+    if (jestConfigPath) {
+        const jestConfig = await (0, jest_config_1.readConfig)({ setupFilesAfterEnv }, (0, node_path_1.join)(workspaceRoot, jestConfigPath));
+        if (jestConfig.projectConfig.setupFilesAfterEnv) {
+            configSetupFilesAfterEnv.push(...jestConfig.projectConfig.setupFilesAfterEnv.map((file) => (0, plugin_migration_utils_1.toProjectRelativePath)(file, projectRoot)));
+        }
+    }
+    if (!configSetupFilesAfterEnv.length) {
+        return [(0, plugin_migration_utils_1.toProjectRelativePath)(setupFile, projectRoot)];
+    }
+    if (isSetupFileInConfig(configSetupFilesAfterEnv, setupFile, projectRoot, workspaceRoot)) {
+        // the setupFile is already included in the setupFilesAfterEnv
+        return [];
+    }
+    return [
+        ...configSetupFilesAfterEnv,
+        (0, plugin_migration_utils_1.toProjectRelativePath)(setupFile, projectRoot),
+    ];
+}
+function isSetupFileInConfig(setupFilesAfterEnv, setupFile, projectRoot, workspaceRoot) {
+    const normalizePath = (f) => f.startsWith('<rootDir>')
+        ? node_path_1.posix.join(workspaceRoot, projectRoot, f.slice('<rootDir>'.length))
+        : node_path_1.posix.join(workspaceRoot, projectRoot, f);
+    const normalizedSetupFiles = new Set(setupFilesAfterEnv.map(normalizePath));
+    return normalizedSetupFiles.has(normalizePath((0, plugin_migration_utils_1.toProjectRelativePath)(setupFile, projectRoot)));
+}
+function toProjectRelativeRegexPath(path, projectRoot) {
+    if (projectRoot === '.') {
+        // workspace and project root are the same, keep the path as is
+        return path;
+    }
+    const normalizedRoot = (0, node_path_1.normalize)(projectRoot);
+    if (new RegExp(`^(?:\\.[\\/\\\\])?${normalizedRoot}(?:[\\/\\\\])?$`).test(path)) {
+        // path includes everything inside project root
+        return '.*';
+    }
+    const normalizedPath = (0, node_path_1.normalize)(path);
+    const startWithProjectRootRegex = new RegExp(`^(?:\\.[\\/\\\\])?${normalizedRoot}[\\/\\\\]`);
+    return startWithProjectRootRegex.test(normalizedPath)
+        ? normalizedPath.replace(startWithProjectRootRegex, '')
+        : path;
+}
+function toProjectRelativeGlobPath(path, projectRoot) {
+    if (projectRoot === '.') {
+        // workspace and project root are the same, keep the path as is
+        return path;
+    }
+    // globs use forward slashes, so we make sure to normalize the path
+    const normalizedRoot = node_path_1.posix.normalize(projectRoot);
+    return path
+        .replace(new RegExp(`\/${normalizedRoot}\/`), '/')
+        .replace(/\*\*\/\*\*/g, '**');
+}

package/src/generators/convert-to-inferred/schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxJestConvertToInferred",
+  "description": "Convert existing Jest project(s) using `@nx/jest:jest` executor to use `@nx/jest/plugin`.",
+  "title": "Convert Jest project from executor to plugin",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The project to convert from using the `@nx/jest:jest` executor to use `@nx/jest/plugin`. If not provided, all projects using the `@nx/jest:jest` executor will be converted.",
+      "x-priority": "important"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Whether to format files.",
+      "default": false
+    }
+  }
+}

package/src/plugins/plugin.js

@@ -144,6 +144,7 @@ async function buildJestTargets(configFilePath, projectRoot, options, context) {
                 metadata: {
                     technologies: ['jest'],
                     description: 'Run Jest Tests in CI',
+                    nonAtomizedTarget: options.targetName,
                 },
             };
             targetGroup.push(options.ciTargetName);
@@ -162,6 +163,7 @@ async function buildJestTargets(configFilePath, projectRoot, options, context) {
                     metadata: {
                         technologies: ['jest'],
                         description: `Run Jest Tests in ${relativePath}`,
+                        nonAtomizedTarget: options.targetName,
                     },
                 };
                 targetGroup.push(targetName);