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

package/src/utils/config/functions.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jestConfigObject = exports.jestConfigObjectAst = exports.removeProperty = exports.addOrUpdateProperty = void 0;
+const devkit_1 = require("@nx/devkit");
+const vm_1 = require("vm");
+const path_1 = require("path");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+let tsModule;
+function makeTextToInsert(value, precedingCommaNeeded) {
+    return `${precedingCommaNeeded ? ',' : ''}${value}`;
+}
+function findPropertyAssignment(object, propertyName) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    return object.properties.find((prop) => {
+        if (!tsModule.isPropertyAssignment(prop)) {
+            return false;
+        }
+        const propNameText = prop.name.getText();
+        if (propNameText.match(/^["'].+["']$/g)) {
+            return JSON.parse(propNameText.replace(/'/g, '"')) === propertyName;
+        }
+        return propNameText === propertyName;
+    });
+}
+function addOrUpdateProperty(tree, object, properties, value, path) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const { SyntaxKind } = tsModule;
+    const propertyName = properties.shift();
+    const propertyAssignment = findPropertyAssignment(object, propertyName);
+    const originalContents = tree.read(path, 'utf-8');
+    if (propertyAssignment) {
+        if (propertyAssignment.initializer.kind === SyntaxKind.StringLiteral ||
+            propertyAssignment.initializer.kind === SyntaxKind.NumericLiteral ||
+            propertyAssignment.initializer.kind === SyntaxKind.FalseKeyword ||
+            propertyAssignment.initializer.kind === SyntaxKind.TrueKeyword) {
+            const updatedContents = (0, devkit_1.applyChangesToString)(originalContents, [
+                {
+                    type: devkit_1.ChangeType.Delete,
+                    start: propertyAssignment.initializer.pos,
+                    length: propertyAssignment.initializer.getFullText().length,
+                },
+                {
+                    type: devkit_1.ChangeType.Insert,
+                    index: propertyAssignment.initializer.pos,
+                    text: value,
+                },
+            ]);
+            tree.write(path, updatedContents);
+            return;
+        }
+        if (propertyAssignment.initializer.kind === SyntaxKind.ArrayLiteralExpression) {
+            const arrayLiteral = propertyAssignment.initializer;
+            if (arrayLiteral.elements.some((element) => {
+                return element.getText().replace(/'/g, '"') === value;
+            })) {
+                return [];
+            }
+            if (arrayLiteral.elements.length === 0) {
+                const updatedContents = (0, devkit_1.applyChangesToString)(originalContents, [
+                    {
+                        type: devkit_1.ChangeType.Insert,
+                        index: arrayLiteral.elements.end,
+                        text: value,
+                    },
+                ]);
+                tree.write(path, updatedContents);
+                return;
+            }
+            else {
+                const text = makeTextToInsert(value, arrayLiteral.elements.length !== 0 &&
+                    !arrayLiteral.elements.hasTrailingComma);
+                const updatedContents = (0, devkit_1.applyChangesToString)(originalContents, [
+                    {
+                        type: devkit_1.ChangeType.Insert,
+                        index: arrayLiteral.elements.end,
+                        text,
+                    },
+                ]);
+                tree.write(path, updatedContents);
+                return;
+            }
+        }
+        else if (propertyAssignment.initializer.kind === SyntaxKind.ObjectLiteralExpression) {
+            return addOrUpdateProperty(tree, propertyAssignment.initializer, properties, value, path);
+        }
+    }
+    else {
+        if (propertyName === undefined) {
+            throw new Error(`Please use dot delimited paths to update an existing object. Eg. object.property `);
+        }
+        const text = makeTextToInsert(`${JSON.stringify(propertyName)}: ${value}`, object.properties.length !== 0 && !object.properties.hasTrailingComma);
+        const updatedContents = (0, devkit_1.applyChangesToString)(originalContents, [
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: object.properties.end,
+                text,
+            },
+        ]);
+        tree.write(path, updatedContents);
+        return;
+    }
+}
+exports.addOrUpdateProperty = addOrUpdateProperty;
+function removeProperty(object, properties) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const propertyName = properties.shift();
+    const propertyAssignment = findPropertyAssignment(object, propertyName);
+    if (propertyAssignment) {
+        if (properties.length > 0 &&
+            propertyAssignment.initializer.kind ===
+                tsModule.SyntaxKind.ObjectLiteralExpression) {
+            return removeProperty(propertyAssignment.initializer, properties);
+        }
+        return propertyAssignment;
+    }
+    else {
+        return null;
+    }
+}
+exports.removeProperty = removeProperty;
+function isModuleExport(node) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    return (tsModule.isExpressionStatement(node) &&
+        node.expression?.kind &&
+        tsModule.isBinaryExpression(node.expression) &&
+        node.expression.left.getText() === 'module.exports' &&
+        node.expression.operatorToken?.kind === tsModule.SyntaxKind.EqualsToken);
+}
+function isDefaultExport(node) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    return (tsModule.isExportAssignment(node) &&
+        node.expression?.kind &&
+        tsModule.isObjectLiteralExpression(node.expression) &&
+        node.getText().startsWith('export default'));
+}
+/**
+ * Should be used to get the jest config object as AST
+ */
+function jestConfigObjectAst(fileContent) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const sourceFile = tsModule.createSourceFile('jest.config.ts', fileContent, tsModule.ScriptTarget.Latest, true);
+    const exportStatement = sourceFile.statements.find((statement) => isModuleExport(statement) || isDefaultExport(statement));
+    let ast;
+    if (tsModule.isExpressionStatement(exportStatement)) {
+        const moduleExports = exportStatement.expression;
+        if (!moduleExports) {
+            throw new Error(`
+       The provided jest config file does not have the expected 'module.exports' expression. 
+       See https://jestjs.io/docs/en/configuration for more details.`);
+        }
+        ast = moduleExports.right;
+    }
+    else if (tsModule.isExportAssignment(exportStatement)) {
+        const defaultExport = exportStatement.expression;
+        if (!defaultExport) {
+            throw new Error(`
+       The provided jest config file does not have the expected 'export default' expression. 
+       See https://jestjs.io/docs/en/configuration for more details.`);
+        }
+        ast = defaultExport;
+    }
+    if (!ast) {
+        throw new Error(`
+      The provided jest config file does not have the expected 'module.exports' or 'export default' expression. 
+      See https://jestjs.io/docs/en/configuration for more details.`);
+    }
+    if (!tsModule.isObjectLiteralExpression(ast)) {
+        throw new Error(`The 'export default' or 'module.exports' expression is not an object literal.`);
+    }
+    return ast;
+}
+exports.jestConfigObjectAst = jestConfigObjectAst;
+/**
+ * Returns the jest config object
+ * @param host
+ * @param path
+ */
+function jestConfigObject(host, path) {
+    const __filename = (0, path_1.join)(host.root, path);
+    const contents = host.read(path, 'utf-8');
+    let module = { exports: {} };
+    // transform the export default syntax to module.exports
+    // this will work for the default config, but will break if there are any other ts syntax
+    // TODO(caleb): use the AST to transform back to the module.exports syntax so this will keep working
+    //  or deprecate and make a new method for getting the jest config object
+    const forcedModuleSyntax = contents.replace(/export\s+default/, 'module.exports =');
+    // Run the contents of the file with some stuff from this current context
+    // The module.exports will be mutated by the contents of the file...
+    (0, vm_1.runInContext)(forcedModuleSyntax, (0, vm_1.createContext)({
+        module,
+        require,
+        process,
+        __filename,
+        __dirname: (0, path_1.dirname)(__filename),
+    }));
+    // TODO: jest actually allows defining configs with async functions... we should be able to read that...
+    return module.exports;
+}
+exports.jestConfigObject = jestConfigObject;

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

@@ -0,0 +1,34 @@
+/**
+ * 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`
+ * 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[]>;

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

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJestProjectsAsync = exports.getNestedJestProjects = exports.getJestProjects = void 0;
+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);
+}
+/**
+ * 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);
+}
+exports.getJestProjects = getJestProjects;
+/**
+ * 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/'];
+}
+exports.getNestedJestProjects = getNestedJestProjects;
+/**
+ * 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'];
+ * });
+ *
+ **/
+async function getJestProjectsAsync() {
+    const graph = await (0, devkit_1.createProjectGraphAsync)({
+        exitOnError: false,
+        resetDaemonClient: true,
+    });
+    const jestConfigurations = new Set();
+    for (const node of Object.values(graph.nodes)) {
+        const projectConfig = node.data;
+        if (!projectConfig.targets) {
+            continue;
+        }
+        for (const targetConfiguration of Object.values(projectConfig.targets)) {
+            if (targetConfiguration.executor === '@nx/jest:jest' ||
+                targetConfiguration.executor === '@nrwl/jest:jest') {
+                collectJestConfigFromJestExecutor(targetConfiguration, jestConfigurations);
+            }
+            else if (targetConfiguration.executor === 'nx:run-commands') {
+                collectJestConfigFromRunCommandsExecutor(targetConfiguration, projectConfig.root, jestConfigurations);
+            }
+        }
+    }
+    return Array.from(jestConfigurations);
+}
+exports.getJestProjectsAsync = getJestProjectsAsync;
+function collectJestConfigFromJestExecutor(targetConfiguration, jestConfigurations) {
+    if (targetConfiguration.options?.jestConfig) {
+        jestConfigurations.add(getJestConfigProjectPath(targetConfiguration.options.jestConfig));
+    }
+    if (targetConfiguration.configurations) {
+        for (const configurationObject of Object.values(targetConfiguration.configurations)) {
+            if (configurationObject.jestConfig) {
+                jestConfigurations.add(getJestConfigProjectPath(configurationObject.jestConfig));
+            }
+        }
+    }
+}
+function collectJestConfigFromRunCommandsExecutor(targetConfiguration, projectRoot, jestConfigurations) {
+    if (targetConfiguration.options?.command) {
+        collectJestConfigFromCommand(targetConfiguration.options.command, targetConfiguration.options.cwd ?? projectRoot, jestConfigurations);
+    }
+    else if (targetConfiguration.options?.commands) {
+        for (const command of targetConfiguration.options.commands) {
+            const commandScript = typeof command === 'string' ? command : command.command;
+            collectJestConfigFromCommand(commandScript, targetConfiguration.options.cwd ?? projectRoot, jestConfigurations);
+        }
+    }
+    if (targetConfiguration.configurations) {
+        for (const configurationObject of Object.values(targetConfiguration.configurations)) {
+            if (configurationObject.command) {
+                collectJestConfigFromCommand(configurationObject.command, configurationObject.cwd ?? projectRoot, jestConfigurations);
+            }
+            else if (configurationObject.commands) {
+                for (const command of configurationObject.commands) {
+                    const commandScript = typeof command === 'string' ? command : command.command;
+                    collectJestConfigFromCommand(commandScript, configurationObject.cwd ?? projectRoot, jestConfigurations);
+                }
+            }
+        }
+    }
+}
+function collectJestConfigFromCommand(command, cwd, jestConfigurations) {
+    const jestCommandRegex = /(?<=^|&)(?:[^&\r\n\s]* )*jest(?: [^&\r\n\s]*)*(?=$|&)/g;
+    const matches = command.match(jestCommandRegex);
+    if (!matches) {
+        return;
+    }
+    for (const match of matches) {
+        const parsed = yargs(match, {
+            configuration: { 'strip-dashed': true },
+            string: ['config'],
+        });
+        if (parsed.config) {
+            jestConfigurations.add(getJestConfigProjectPath((0, path_1.join)(cwd, parsed.config)));
+        }
+        else {
+            jestConfigurations.add(getJestConfigProjectPath(cwd));
+        }
+    }
+}

package/src/utils/config/is-preset-cjs.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function isPresetCjs(tree: Tree): boolean;

package/src/utils/config/is-preset-cjs.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPresetCjs = void 0;
+const devkit_1 = require("@nx/devkit");
+function isPresetCjs(tree) {
+    if (tree.exists('jest.preset.cjs')) {
+        return true;
+    }
+    const rootPkgJson = (0, devkit_1.readJson)(tree, 'package.json');
+    if (rootPkgJson.type && rootPkgJson.type === 'module') {
+        return true;
+    }
+    return false;
+}
+exports.isPresetCjs = isPresetCjs;

package/src/utils/config/update-config.d.ts

@@ -0,0 +1,20 @@
+import { Tree } from '@nx/devkit';
+/**
+ * Add a property to the jest config
+ * @param host
+ * @param path - path to the jest config file
+ * @param propertyName - Property to update. Can be dot delimited or an array to access deeply nested properties
+ * @param value
+ * @param options - set `valueAsString` option to true if the `value` being passed represents a string of the code that should be associated with the `propertyName`
+ */
+export declare function addPropertyToJestConfig(host: Tree, path: string, propertyName: string | string[], value: unknown, options?: {
+    valueAsString: boolean;
+}): void;
+/**
+ * Remove a property value from the jest config
+ * @param host
+ * @param path
+ * @param propertyName - Property to remove. Can be dot delimited or an array to access deeply nested properties
+ */
+export declare function removePropertyFromJestConfig(host: Tree, path: string, propertyName: string | string[]): void;
+export declare function addImportStatementToJestConfig(host: Tree, path: string, importStatement: string): void;

package/src/utils/config/update-config.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addImportStatementToJestConfig = exports.removePropertyFromJestConfig = exports.addPropertyToJestConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const functions_1 = require("./functions");
+/**
+ * Add a property to the jest config
+ * @param host
+ * @param path - path to the jest config file
+ * @param propertyName - Property to update. Can be dot delimited or an array to access deeply nested properties
+ * @param value
+ * @param options - set `valueAsString` option to true if the `value` being passed represents a string of the code that should be associated with the `propertyName`
+ */
+function addPropertyToJestConfig(host, path, propertyName, value, options = { valueAsString: false }) {
+    if (!host.exists(path)) {
+        throw new Error(`Cannot find '${path}' in your workspace.`);
+    }
+    const { propertyString, properties } = parsePropertyName(propertyName);
+    try {
+        const configObject = (0, functions_1.jestConfigObjectAst)(host.read(path, 'utf-8'));
+        (0, functions_1.addOrUpdateProperty)(host, configObject, properties, options.valueAsString ? value : JSON.stringify(value), path);
+    }
+    catch (e) {
+        devkit_1.logger.info(`NX Please manually update ${path}`);
+        devkit_1.logger.warn(`Could not automatically add the following property to ${path}:`);
+        devkit_1.logger.warn(`${propertyString}: ${JSON.stringify(value)}`);
+        devkit_1.logger.warn(`Error: ${e.message}`);
+    }
+}
+exports.addPropertyToJestConfig = addPropertyToJestConfig;
+/**
+ * Remove a property value from the jest config
+ * @param host
+ * @param path
+ * @param propertyName - Property to remove. Can be dot delimited or an array to access deeply nested properties
+ */
+function removePropertyFromJestConfig(host, path, propertyName) {
+    if (!host.exists(path)) {
+        throw new Error(`Cannot find '${path}' in your workspace.`);
+    }
+    const { propertyString, properties } = parsePropertyName(propertyName);
+    try {
+        const configObject = (0, functions_1.jestConfigObjectAst)(host.read(path, 'utf-8'));
+        const propertyAssignment = (0, functions_1.removeProperty)(configObject, properties);
+        if (propertyAssignment) {
+            const file = host.read(path, 'utf-8');
+            const commaNeeded = file[propertyAssignment.end] === ',';
+            const updatedFile = (0, devkit_1.applyChangesToString)(file, [
+                {
+                    type: devkit_1.ChangeType.Delete,
+                    start: propertyAssignment.getStart(),
+                    length: `${propertyAssignment.getText()}${commaNeeded ? ',' : ''}`
+                        .length,
+                },
+            ]);
+            host.write(path, updatedFile);
+            return;
+        }
+    }
+    catch (e) {
+        devkit_1.logger.info(`NX Please manually update ${path}`);
+        devkit_1.logger.warn(`Could not automatically remove the '${propertyString}' property from ${path}:`);
+    }
+}
+exports.removePropertyFromJestConfig = removePropertyFromJestConfig;
+function parsePropertyName(propertyName) {
+    return {
+        properties: Array.isArray(propertyName)
+            ? propertyName
+            : propertyName.split('.'),
+        propertyString: Array.isArray(propertyName)
+            ? propertyName.join('.')
+            : propertyName,
+    };
+}
+function addImportStatementToJestConfig(host, path, importStatement) {
+    const currentContents = host.read(path, 'utf-8');
+    const newContents = `${importStatement}
+  
+${currentContents}`;
+    host.write(path, newContents);
+}
+exports.addImportStatementToJestConfig = addImportStatementToJestConfig;

package/src/utils/versions.d.ts

@@ -0,0 +1,9 @@
+export declare const nxVersion: any;
+export declare const jestVersion = "^29.4.1";
+export declare const babelJestVersion = "^29.4.1";
+export declare const jestTypesVersion = "^29.4.0";
+export declare const tsJestVersion = "^29.1.0";
+export declare const tslibVersion = "^2.3.0";
+export declare const swcJestVersion = "0.2.20";
+export declare const typesNodeVersion = "18.16.9";
+export declare const tsNodeVersion = "10.9.1";

package/src/utils/versions.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsNodeVersion = exports.typesNodeVersion = exports.swcJestVersion = exports.tslibVersion = exports.tsJestVersion = exports.jestTypesVersion = exports.babelJestVersion = exports.jestVersion = exports.nxVersion = void 0;
+exports.nxVersion = require('../../package.json').version;
+exports.jestVersion = '^29.4.1';
+exports.babelJestVersion = '^29.4.1';
+exports.jestTypesVersion = '^29.4.0';
+exports.tsJestVersion = '^29.1.0';
+exports.tslibVersion = '^2.3.0';
+exports.swcJestVersion = '0.2.20';
+exports.typesNodeVersion = '18.16.9';
+exports.tsNodeVersion = '10.9.1';