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

package/src/generators/remove/lib/check-dependencies.d.ts

@@ -0,0 +1,7 @@
+import { Schema } from '../schema';
+/**
+ * Check whether the project to be removed is depended on by another project
+ *
+ * Throws an error if the project is in use, unless the `--forceRemove` option is used.
+ */
+export declare function checkDependencies(_: any, schema: Schema): Promise<void>;

package/src/generators/remove/lib/check-dependencies.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+/**
+ * Check whether the project to be removed is depended on by another project
+ *
+ * Throws an error if the project is in use, unless the `--forceRemove` option is used.
+ */
+async function checkDependencies(_, schema) {
+    if (schema.forceRemove) {
+        return;
+    }
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    const reverseGraph = (0, devkit_1.reverse)(graph);
+    const deps = reverseGraph.dependencies[schema.projectName] || [];
+    if (deps.length > 0) {
+        throw new Error(`${schema.projectName} is still a dependency of the following projects:\n${deps
+            .map((x) => x.target)
+            .join('\n')}`);
+    }
+}
+exports.checkDependencies = checkDependencies;

package/src/generators/remove/lib/check-project-is-safe-to-remove.d.ts

@@ -0,0 +1,3 @@
+import { ProjectConfiguration, Tree } from '@nx/devkit';
+import { Schema } from '../schema';
+export declare function checkProjectIsSafeToRemove(tree: Tree, schema: Schema, project: ProjectConfiguration): void;

package/src/generators/remove/lib/check-project-is-safe-to-remove.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkProjectIsSafeToRemove = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+function checkProjectIsSafeToRemove(tree, schema, project) {
+    if (project.root === '.') {
+        throw new Error(`"${schema.projectName}" is the root project. Running this would delete every file in your workspace.`);
+    }
+    if (schema.forceRemove) {
+        devkit_1.logger.warn(`You have passed --forceRemove`);
+        return;
+    }
+    const containedProjects = [];
+    for (const [_, p] of (0, devkit_1.getProjects)(tree)) {
+        if (project.name !== p.name &&
+            !(0, devkit_1.normalizePath)((0, path_1.relative)(project.root, p.root)).startsWith('..')) {
+            containedProjects.push(p.name);
+        }
+    }
+    if (containedProjects.length > 0) {
+        throw new Error(`"${schema.projectName}" is a project that has nested projects within it. Removing this project would remove the following projects as well:\n - ${containedProjects.join('\n - ')}\nPass --forceRemove to remove all of the above projects`);
+    }
+}
+exports.checkProjectIsSafeToRemove = checkProjectIsSafeToRemove;

package/src/generators/remove/lib/check-targets.d.ts

@@ -0,0 +1,10 @@
+import { Tree } from '@nx/devkit';
+import { Schema } from '../schema';
+/**
+ * Check whether the project to be removed has builders targetted by another project
+ *
+ * Throws an error if the project is in use, unless the `--forceRemove` option is used.
+ *
+ * @param schema The options provided to the schematic
+ */
+export declare function checkTargets(tree: Tree, schema: Schema): Promise<void>;

package/src/generators/remove/lib/check-targets.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkTargets = void 0;
+const devkit_1 = require("@nx/devkit");
+/**
+ * Check whether the project to be removed has builders targetted by another project
+ *
+ * Throws an error if the project is in use, unless the `--forceRemove` option is used.
+ *
+ * @param schema The options provided to the schematic
+ */
+async function checkTargets(tree, schema) {
+    if (schema.forceRemove) {
+        return;
+    }
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    const errors = [];
+    (0, devkit_1.getProjects)(tree).forEach((projectConfig, projectName) => {
+        if (projectName === schema.projectName) {
+            return;
+        }
+        Object.entries(projectConfig.targets || {}).forEach(([, targetConfig]) => {
+            checkIfProjectIsUsed(targetConfig, (value) => {
+                try {
+                    const { project } = (0, devkit_1.parseTargetString)(value, graph);
+                    if (project === schema.projectName) {
+                        errors.push(`"${value}" is used by "${projectName}"`);
+                    }
+                }
+                catch (err) {
+                    /**
+                     * It threw because the target string was not
+                     * in the format of project:target:configuration
+                     *
+                     * In that case, we don't care about it.
+                     * So we can ignore this error.
+                     */
+                }
+            });
+        });
+    });
+    if (errors.length > 0) {
+        let message = `${schema.projectName} is still targeted by some projects:\n\n`;
+        for (let error of errors) {
+            message += `${error}\n`;
+        }
+        throw new Error(message);
+    }
+}
+exports.checkTargets = checkTargets;
+function checkIfProjectIsUsed(config, callback) {
+    function recur(obj, key, value) {
+        if (typeof value === 'string') {
+            callback(value);
+        }
+        else if (Array.isArray(value)) {
+            value.forEach((x, idx) => recur(value, idx, x));
+        }
+        else if (typeof value === 'object') {
+            Object.entries(value).forEach(([k, v]) => {
+                recur(value, k, v);
+            });
+        }
+    }
+    Object.entries(config).forEach(([k, v]) => {
+        recur(config, k, v);
+    });
+}

package/src/generators/remove/lib/remove-project-references-in-config.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from '../schema';
+import { Tree } from '@nx/devkit';
+export declare function removeProjectReferencesInConfig(tree: Tree, schema: Schema): void;

package/src/generators/remove/lib/remove-project-references-in-config.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeProjectReferencesInConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+function removeProjectReferencesInConfig(tree, schema) {
+    // Unset default project if deleting the default project
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (nxJson.defaultProject && nxJson.defaultProject === schema.projectName) {
+        delete nxJson.defaultProject;
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+    // Remove implicit dependencies onto removed project
+    (0, devkit_1.getProjects)(tree).forEach((project, projectName) => {
+        if (project.implicitDependencies &&
+            project.implicitDependencies.some((projectName) => projectName === schema.projectName)) {
+            project.implicitDependencies = project.implicitDependencies.filter((projectName) => projectName !== schema.projectName);
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
+        }
+    });
+}
+exports.removeProjectReferencesInConfig = removeProjectReferencesInConfig;

package/src/generators/remove/lib/remove-project.d.ts

@@ -0,0 +1,5 @@
+import { ProjectConfiguration, Tree } from '@nx/devkit';
+/**
+ * Removes (deletes) a project's files from the folder tree
+ */
+export declare function removeProject(tree: Tree, project: ProjectConfiguration): void;

package/src/generators/remove/lib/remove-project.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeProject = void 0;
+const devkit_1 = require("@nx/devkit");
+/**
+ * Removes (deletes) a project's files from the folder tree
+ */
+function removeProject(tree, project) {
+    (0, devkit_1.visitNotIgnoredFiles)(tree, project.root, (file) => {
+        tree.delete(file);
+    });
+    tree.delete(project.root);
+}
+exports.removeProject = removeProject;

package/src/generators/remove/lib/update-jest-config.d.ts

@@ -0,0 +1,6 @@
+import { ProjectConfiguration, Tree } from '@nx/devkit';
+import { Schema } from '../schema';
+/**
+ * Updates the root jest config projects array and removes the project.
+ */
+export declare function updateJestConfig(tree: Tree, schema: Schema, projectConfig: ProjectConfiguration): void;

package/src/generators/remove/lib/update-jest-config.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateJestConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const get_source_nodes_1 = require("../../../utilities/typescript/get-source-nodes");
+const path_1 = require("path");
+const typescript_1 = require("../../../utilities/typescript");
+const jest_config_1 = require("../../utils/jest-config");
+let tsModule;
+function isUsingUtilityFunction(host) {
+    const rootConfigPath = (0, jest_config_1.findRootJestConfig)(host);
+    if (!rootConfigPath) {
+        return false;
+    }
+    const rootConfig = host.read(rootConfigPath, 'utf-8');
+    return (rootConfig.includes('getJestProjects()') ||
+        rootConfig.includes('getJestProjectsAsync()'));
+}
+/**
+ * in a standalone project, the root jest.config.ts is a project config instead
+ * of multi-project config.
+ * in that case we do not need to edit it to remove it
+ **/
+function isMonorepoConfig(tree) {
+    const rootConfigPath = (0, jest_config_1.findRootJestConfig)(tree);
+    if (!rootConfigPath) {
+        return false;
+    }
+    return tree.read(rootConfigPath, 'utf-8').includes('projects:');
+}
+/**
+ * Updates the root jest config projects array and removes the project.
+ */
+function updateJestConfig(tree, schema, projectConfig) {
+    if (!tsModule) {
+        tsModule = (0, typescript_1.ensureTypescript)();
+    }
+    const { createSourceFile, ScriptTarget, isPropertyAssignment, isArrayLiteralExpression, isStringLiteral, } = tsModule;
+    const projectToRemove = schema.projectName;
+    const rootConfigPath = (0, jest_config_1.findRootJestConfig)(tree);
+    if (!tree.exists(rootConfigPath) ||
+        !tree.exists((0, path_1.join)(projectConfig.root, 'jest.config.ts')) ||
+        isUsingUtilityFunction(tree) ||
+        !isMonorepoConfig(tree)) {
+        return;
+    }
+    const contents = tree.read(rootConfigPath, 'utf-8');
+    const sourceFile = createSourceFile(rootConfigPath, contents, ScriptTarget.Latest);
+    const sourceNodes = (0, get_source_nodes_1.getSourceNodes)(sourceFile);
+    const projectsAssignment = sourceNodes.find((node) => isPropertyAssignment(node) &&
+        node.name.getText(sourceFile) === 'projects' &&
+        isArrayLiteralExpression(node.initializer));
+    if (!projectsAssignment) {
+        throw Error(`Could not remove ${projectToRemove} from projects in /jest.config.ts. Please remove ${projectToRemove} from your projects.`);
+    }
+    const projectsArray = projectsAssignment.initializer;
+    const project = projectsArray.elements.find((item) => isStringLiteral(item) &&
+        item.text.startsWith(`<rootDir>/${projectConfig.root}`));
+    if (!project) {
+        console.warn(`Could not find ${projectToRemove} in projects in /jest.config.ts.`);
+        return;
+    }
+    const previousProject = projectsArray.elements[projectsArray.elements.indexOf(project) - 1];
+    const start = previousProject
+        ? previousProject.getEnd()
+        : project.getStart(sourceFile);
+    tree.write(rootConfigPath, (0, devkit_1.applyChangesToString)(contents, [
+        {
+            type: devkit_1.ChangeType.Delete,
+            start,
+            length: project.getEnd() - start,
+        },
+    ]));
+}
+exports.updateJestConfig = updateJestConfig;

package/src/generators/remove/lib/update-tsconfig.d.ts

@@ -0,0 +1,8 @@
+import { Tree } from '@nx/devkit';
+import { Schema } from '../schema';
+/**
+ * Updates the tsconfig paths to remove the project.
+ *
+ * @param schema The options provided to the schematic
+ */
+export declare function updateTsconfig(tree: Tree, schema: Schema): Promise<void>;

package/src/generators/remove/lib/update-tsconfig.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTsconfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const ts_config_1 = require("../../../utilities/ts-config");
+const find_project_for_path_1 = require("nx/src/project-graph/utils/find-project-for-path");
+/**
+ * Updates the tsconfig paths to remove the project.
+ *
+ * @param schema The options provided to the schematic
+ */
+async function updateTsconfig(tree, schema) {
+    const tsConfigPath = (0, ts_config_1.getRootTsConfigPathInTree)(tree);
+    if (tree.exists(tsConfigPath)) {
+        const graph = await (0, devkit_1.createProjectGraphAsync)();
+        const projectMapping = (0, find_project_for_path_1.createProjectRootMappings)(graph.nodes);
+        (0, devkit_1.updateJson)(tree, tsConfigPath, (json) => {
+            for (const importPath in json.compilerOptions.paths) {
+                for (const path of json.compilerOptions.paths[importPath]) {
+                    const project = (0, find_project_for_path_1.findProjectForPath)((0, devkit_1.normalizePath)(path), projectMapping);
+                    if (project === schema.projectName) {
+                        delete json.compilerOptions.paths[importPath];
+                        break;
+                    }
+                }
+            }
+            return json;
+        });
+    }
+}
+exports.updateTsconfig = updateTsconfig;

package/src/generators/remove/remove.d.ts

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

package/src/generators/remove/remove.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const check_project_is_safe_to_remove_1 = require("./lib/check-project-is-safe-to-remove");
+const check_dependencies_1 = require("./lib/check-dependencies");
+const check_targets_1 = require("./lib/check-targets");
+const remove_project_1 = require("./lib/remove-project");
+const update_tsconfig_1 = require("./lib/update-tsconfig");
+const remove_project_references_in_config_1 = require("./lib/remove-project-references-in-config");
+const update_jest_config_1 = require("./lib/update-jest-config");
+async function removeGenerator(tree, schema) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, schema.projectName);
+    await (0, check_project_is_safe_to_remove_1.checkProjectIsSafeToRemove)(tree, schema, project);
+    await (0, check_dependencies_1.checkDependencies)(tree, schema);
+    await (0, check_targets_1.checkTargets)(tree, schema);
+    (0, update_jest_config_1.updateJestConfig)(tree, schema, project);
+    (0, remove_project_references_in_config_1.removeProjectReferencesInConfig)(tree, schema);
+    (0, remove_project_1.removeProject)(tree, project);
+    await (0, update_tsconfig_1.updateTsconfig)(tree, schema);
+    if (!schema.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.removeGenerator = removeGenerator;
+exports.default = removeGenerator;

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

@@ -0,0 +1,10 @@
+export interface Json {
+  [k: string]: any;
+}
+
+export interface Schema extends Json {
+  projectName: string;
+  skipFormat: boolean;
+  forceRemove: boolean;
+  importPath?: string;
+}

package/src/generators/remove/schema.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxWorkspaceRemove",
+  "cli": "nx",
+  "title": "Nx Remove",
+  "description": "Remove a project from the workspace.",
+  "type": "object",
+  "examples": [
+    {
+      "command": "nx g @nx/workspace:remove my-feature-lib",
+      "description": "Remove `my-feature-lib` from the workspace"
+    },
+    {
+      "command": "nx g @nx/workspace:remove my-feature-lib --forceRemove",
+      "description": "Force removal of `my-feature-lib` from the workspace"
+    }
+  ],
+  "properties": {
+    "projectName": {
+      "type": "string",
+      "alias": "project",
+      "description": "The name of the project to remove.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      }
+    },
+    "forceRemove": {
+      "type": "boolean",
+      "aliases": ["force-remove"],
+      "description": "When `true`, forces removal even if the project is still in use.",
+      "default": false
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "aliases": ["skip-format"],
+      "description": "Skip formatting files.",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "importPath": {
+      "type": "string",
+      "description": "The library name used at creation time"
+    }
+  },
+  "required": ["projectName"]
+}

package/src/generators/run-commands/run-commands.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from './schema';
+import { Tree } from '@nx/devkit';
+export declare function runCommandsGenerator(host: Tree, schema: Schema): Promise<void>;
+export default runCommandsGenerator;

package/src/generators/run-commands/run-commands.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommandsGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+async function runCommandsGenerator(host, schema) {
+    const project = (0, devkit_1.readProjectConfiguration)(host, schema.project);
+    project.targets = project.targets || {};
+    project.targets[schema.name] = {
+        executor: 'nx:run-commands',
+        outputs: schema.outputs
+            ? schema.outputs
+                .split(',')
+                .map((s) => (0, devkit_1.joinPathFragments)('{workspaceRoot}', s.trim()))
+            : [],
+        options: {
+            command: schema.command,
+            cwd: schema.cwd,
+            envFile: schema.envFile,
+        },
+    };
+    (0, devkit_1.updateProjectConfiguration)(host, schema.project, project);
+    await (0, devkit_1.formatFiles)(host);
+}
+exports.runCommandsGenerator = runCommandsGenerator;
+exports.default = runCommandsGenerator;

package/src/generators/run-commands/schema.d.ts

@@ -0,0 +1,8 @@
+export interface Schema {
+  name: string;
+  command: string;
+  project: string;
+  cwd?: string;
+  outputs?: string;
+  envFile?: string;
+}

package/src/generators/run-commands/schema.json

@@ -0,0 +1,49 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "SchematicsRunCommands",
+  "title": "Create a custom target to run any command",
+  "description": "Create a custom target to run any command.",
+  "type": "object",
+  "cli": "nx",
+  "examples": [
+    {
+      "command": "nx g @nx/workspace:run-commands printhello --project my-feature-lib --command 'echo hello'",
+      "description": "Add the `printhello` target to `my-feature-lib`"
+    }
+  ],
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Target name.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use to invoke the command?"
+    },
+    "project": {
+      "description": "Project name.",
+      "type": "string",
+      "x-prompt": "What project does the target belong to?",
+      "x-dropdown": "projects"
+    },
+    "command": {
+      "description": "Command to run.",
+      "type": "string",
+      "x-prompt": "What command would you like to run?"
+    },
+    "cwd": {
+      "description": "Current working directory of the command.",
+      "type": "string"
+    },
+    "outputs": {
+      "description": "Allows you to specify where the build artifacts are stored. This allows Nx Cloud to pick them up correctly, in the case that the build artifacts are placed somewhere other than the top level dist folder.",
+      "type": "string"
+    },
+    "envFile": {
+      "description": "Env files to be loaded before executing the commands.",
+      "type": "string"
+    }
+  },
+  "required": ["name", "command", "project"]
+}

package/src/generators/utils/get-npm-package-version.d.ts

@@ -0,0 +1 @@
+export declare function getNpmPackageVersion(packageName: string, packageVersion?: string): string | null;

package/src/generators/utils/get-npm-package-version.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNpmPackageVersion = void 0;
+function getNpmPackageVersion(packageName, packageVersion) {
+    try {
+        const version = require('child_process').execSync(`npm view ${packageName}${packageVersion ? '@' + packageVersion : ''} version --json`, { stdio: ['pipe', 'pipe', 'ignore'] });
+        if (version) {
+            // package@1.12 => ["1.12.0", "1.12.1"]
+            // package@1.12.1 => "1.12.1"
+            // package@latest => "1.12.1"
+            const versionOrArray = JSON.parse(version.toString());
+            if (typeof versionOrArray === 'string') {
+                return versionOrArray;
+            }
+            return versionOrArray.pop();
+        }
+    }
+    catch (err) { }
+    return packageVersion ?? null;
+}
+exports.getNpmPackageVersion = getNpmPackageVersion;

package/src/generators/utils/insert-import.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function insertImport(tree: Tree, path: string, name: string, modulePath: string): void;

package/src/generators/utils/insert-import.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertImport = void 0;
+const insert_statement_1 = require("./insert-statement");
+const devkit_1 = require("@nx/devkit");
+const typescript_1 = require("../../utilities/typescript");
+let tsModule;
+function insertImport(tree, path, name, modulePath) {
+    if (!tsModule) {
+        tsModule = (0, typescript_1.ensureTypescript)();
+    }
+    const { createSourceFile, ScriptTarget, isStringLiteral, isImportDeclaration, isNamedImports, } = tsModule;
+    const contents = tree.read(path, 'utf-8');
+    const sourceFile = createSourceFile(path, contents, ScriptTarget.ESNext);
+    const importStatements = sourceFile.statements.filter(isImportDeclaration);
+    const existingImport = importStatements.find((statement) => isStringLiteral(statement.moduleSpecifier) &&
+        statement.moduleSpecifier
+            .getText(sourceFile)
+            .replace(/['"`]/g, '')
+            .trim() === modulePath &&
+        statement.importClause.namedBindings &&
+        isNamedImports(statement.importClause.namedBindings));
+    if (!existingImport) {
+        (0, insert_statement_1.insertStatement)(tree, path, `import { ${name} } from '${modulePath}';`);
+        return;
+    }
+    // TODO: Also check if the namedImport already exists
+    const namedImports = existingImport.importClause
+        .namedBindings;
+    const index = namedImports.getEnd() - 1;
+    let text;
+    if (namedImports.elements.hasTrailingComma) {
+        text = `${name},`;
+    }
+    else {
+        text = `,${name}`;
+    }
+    const newContents = (0, devkit_1.applyChangesToString)(contents, [
+        {
+            type: devkit_1.ChangeType.Insert,
+            index,
+            text,
+        },
+    ]);
+    tree.write(path, newContents);
+}
+exports.insertImport = insertImport;

package/src/generators/utils/insert-statement.d.ts

@@ -0,0 +1,5 @@
+import { Tree } from '@nx/devkit';
+/**
+ * Insert a statement after the last import statement in a file
+ */
+export declare function insertStatement(tree: Tree, path: string, statement: string): void;

package/src/generators/utils/insert-statement.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertStatement = void 0;
+const devkit_1 = require("@nx/devkit");
+const typescript_1 = require("../../utilities/typescript");
+let tsModule;
+/**
+ * Insert a statement after the last import statement in a file
+ */
+function insertStatement(tree, path, statement) {
+    if (!tsModule) {
+        tsModule = (0, typescript_1.ensureTypescript)();
+    }
+    const { createSourceFile, isImportDeclaration, ScriptTarget } = tsModule;
+    const contents = tree.read(path, 'utf-8');
+    const sourceFile = createSourceFile(path, contents, ScriptTarget.ESNext);
+    const importStatements = sourceFile.statements.filter(isImportDeclaration);
+    const index = importStatements.length > 0
+        ? importStatements[importStatements.length - 1].getEnd()
+        : 0;
+    if (importStatements.length > 0) {
+        statement = `\n${statement}`;
+    }
+    const newContents = (0, devkit_1.applyChangesToString)(contents, [
+        {
+            type: devkit_1.ChangeType.Insert,
+            index,
+            text: statement,
+        },
+    ]);
+    tree.write(path, newContents);
+}
+exports.insertStatement = insertStatement;

package/src/generators/utils/jest-config.d.ts

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

package/src/generators/utils/jest-config.js

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