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

package/src/generators/plugin/schema.json

@@ -0,0 +1,104 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "NxPluginPlugin",
+  "title": "Create a Plugin for Nx",
+  "description": "Create a Plugin for Nx.",
+  "type": "object",
+  "examples": [
+    {
+      "command": "nx g plugin my-plugin --directory=plugins --importPath=@myorg/my-plugin",
+      "description": "Generates an Nx plugin project called `plugins-my-plugin` at `libs/plugins/my-plugin`. The project will have an npm package name and import path of `@myorg/my-plugin`."
+    }
+  ],
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Plugin name",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the plugin?",
+      "x-priority": "important",
+      "pattern": "(?:^@[a-zA-Z0-9-*~][a-zA-Z0-9-*._~]*\\/[a-zA-Z0-9-~][a-zA-Z0-9-._~]*|^[a-zA-Z][^:]*)$"
+    },
+    "directory": {
+      "type": "string",
+      "description": "A directory where the plugin is placed."
+    },
+    "projectNameAndRootFormat": {
+      "description": "Whether to generate the project name and root directory as provided (`as-provided`) or generate them composing their values and taking the configured layout into account (`derived`).",
+      "type": "string",
+      "enum": ["as-provided", "derived"]
+    },
+    "importPath": {
+      "type": "string",
+      "description": "How the plugin will be published, like `@myorg/my-awesome-plugin`. Note this must be a valid NPM name.",
+      "x-priority": "important"
+    },
+    "linter": {
+      "description": "The tool to use for running lint checks.",
+      "type": "string",
+      "enum": ["eslint"],
+      "default": "eslint"
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["jest", "none"],
+      "description": "Test runner to use for unit tests.",
+      "default": "jest"
+    },
+    "tags": {
+      "type": "string",
+      "description": "Add tags to the library (used for linting).",
+      "alias": "t"
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "skipTsConfig": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not update tsconfig.json for development experience.",
+      "x-priority": "internal"
+    },
+    "skipLintChecks": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not eslint configuration for plugin json files."
+    },
+    "e2eTestRunner": {
+      "type": "string",
+      "enum": ["jest", "none"],
+      "description": "Test runner to use for end to end (E2E) tests.",
+      "default": "none"
+    },
+    "standaloneConfig": {
+      "description": "Split the project configuration into `<projectRoot>/project.json` rather than including it inside `workspace.json`.",
+      "type": "boolean",
+      "default": true,
+      "x-deprecated": "Nx only supports standaloneConfig"
+    },
+    "setParserOptionsProject": {
+      "type": "boolean",
+      "description": "Whether or not to configure the ESLint `parserOptions.project` option. We do not do this by default for lint performance reasons.",
+      "default": false
+    },
+    "compiler": {
+      "type": "string",
+      "enum": ["tsc", "swc"],
+      "default": "tsc",
+      "description": "The compiler used by the build and test targets."
+    },
+    "publishable": {
+      "type": "boolean",
+      "description": "Generates a boilerplate for publishing the plugin to npm.",
+      "default": false
+    }
+  },
+  "required": ["name"]
+}

package/src/generators/plugin/utils/normalize-schema.d.ts

@@ -0,0 +1,13 @@
+import { Tree } from '@nx/devkit';
+import { Schema } from '../schema';
+export interface NormalizedSchema extends Schema {
+    name: string;
+    fileName: string;
+    projectRoot: string;
+    projectDirectory: string;
+    parsedTags: string[];
+    npmPackageName: string;
+    bundler: 'swc' | 'tsc';
+    publishable: boolean;
+}
+export declare function normalizeOptions(host: Tree, options: Schema): Promise<NormalizedSchema>;

package/src/generators/plugin/utils/normalize-schema.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+const devkit_1 = require("@nx/devkit");
+const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
+async function normalizeOptions(host, options) {
+    const { projectName, projectRoot, importPath: npmPackageName, projectNameAndRootFormat, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(host, {
+        name: options.name,
+        projectType: 'library',
+        directory: options.directory,
+        importPath: options.importPath,
+        projectNameAndRootFormat: options.projectNameAndRootFormat,
+        rootProject: options.rootProject,
+        callingGenerator: '@nx/plugin:plugin',
+    });
+    options.projectNameAndRootFormat = projectNameAndRootFormat;
+    options.rootProject = projectRoot === '.';
+    let projectDirectory = projectRoot;
+    if (options.projectNameAndRootFormat === 'derived') {
+        let { layoutDirectory } = (0, devkit_1.extractLayoutDirectory)(options.directory);
+        if (!layoutDirectory) {
+            const { libsDir } = (0, devkit_1.getWorkspaceLayout)(host);
+            layoutDirectory = libsDir;
+        }
+        if (projectRoot.startsWith(`${layoutDirectory}/`)) {
+            projectDirectory = projectRoot.replace(`${layoutDirectory}/`, '');
+        }
+    }
+    const parsedTags = options.tags
+        ? options.tags.split(',').map((s) => s.trim())
+        : [];
+    return {
+        ...options,
+        bundler: options.compiler ?? 'tsc',
+        fileName: projectName,
+        name: projectName,
+        projectRoot,
+        projectDirectory,
+        parsedTags,
+        npmPackageName,
+        publishable: options.publishable ?? false,
+    };
+}
+exports.normalizeOptions = normalizeOptions;

package/src/generators/preset/generator.d.ts

@@ -0,0 +1,3 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { PresetGeneratorSchema } from './schema';
+export default function (tree: Tree, options: PresetGeneratorSchema): Promise<GeneratorCallback>;

package/src/generators/preset/generator.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const eslint_1 = require("@nx/eslint");
+const plugin_1 = require("../plugin/plugin");
+const create_package_1 = require("../create-package/create-package");
+async function default_1(tree, options) {
+    const tasks = [];
+    const pluginProjectName = (0, devkit_1.names)(options.pluginName.includes('/')
+        ? options.pluginName.split('/')[1]
+        : options.pluginName).fileName;
+    options.createPackageName =
+        options.createPackageName === 'false' // for command line in e2e, it is passed as a string
+            ? undefined
+            : options.createPackageName;
+    const pluginTask = await (0, plugin_1.pluginGenerator)(tree, {
+        compiler: 'tsc',
+        linter: eslint_1.Linter.EsLint,
+        name: pluginProjectName,
+        skipFormat: true,
+        unitTestRunner: 'jest',
+        importPath: options.pluginName,
+        e2eTestRunner: 'jest',
+        publishable: true,
+        // when creating a CLI package, the plugin will be in the packages folder
+        directory: options.createPackageName && options.createPackageName !== 'false'
+            ? 'packages'
+            : undefined,
+        rootProject: options.createPackageName ? false : true,
+    });
+    tasks.push(pluginTask);
+    moveNxPluginToDevDeps(tree);
+    if (options.createPackageName) {
+        const e2eProject = `${options.pluginName}-e2e`;
+        const cliTask = await (0, create_package_1.default)(tree, {
+            directory: 'packages',
+            name: options.createPackageName,
+            e2eProject: e2eProject,
+            project: options.pluginName,
+            skipFormat: true,
+            unitTestRunner: 'jest',
+            linter: eslint_1.Linter.EsLint,
+            compiler: 'tsc',
+        });
+        tasks.push(cliTask);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.default = default_1;
+function moveNxPluginToDevDeps(tree) {
+    (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
+        const nxPluginEntry = json.dependencies['@nx/plugin'];
+        delete json.dependencies['@nx/plugin'];
+        json.devDependencies['@nx/plugin'] = nxPluginEntry;
+        return json;
+    });
+}

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

@@ -0,0 +1,4 @@
+export interface PresetGeneratorSchema {
+  pluginName: string;
+  createPackageName?: string;
+}

package/src/generators/preset/schema.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "NxPluginPreset",
+  "title": "Generator ran by create-nx-plugin",
+  "description": "Initializes a workspace with an nx-plugin inside of it. Use as: `create-nx-plugin` or `create-nx-workspace --preset @nx/nx-plugin`.",
+  "examples": [
+    {
+      "command": "npx create-nx-plugin",
+      "description": "Creates a new Nx workspace containing an Nx plugin."
+    },
+    {
+      "command": "npx create-nx-workspace --preset @nx/plugin",
+      "description": "Creates a new Nx workspace containing an Nx plugin."
+    }
+  ],
+  "type": "object",
+  "properties": {
+    "pluginName": {
+      "type": "string",
+      "description": "Plugin name",
+      "aliases": ["name"]
+    },
+    "createPackageName": {
+      "type": "string",
+      "description": "Name of package which creates a workspace"
+    }
+  },
+  "required": ["pluginName"]
+}

package/src/migrations/update-15-0-0/specify-output-capture.d.ts

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

package/src/migrations/update-15-0-0/specify-output-capture.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+async function update(tree) {
+    for (const [project, { root }] of (0, devkit_1.getProjects)(tree)) {
+        const packageJsonPath = (0, devkit_1.joinPathFragments)(root, 'package.json');
+        if (!tree.exists(packageJsonPath)) {
+            continue;
+        }
+        const packageJson = (0, devkit_1.readJson)(tree, packageJsonPath);
+        if (!packageJson.executors && !packageJson.builders) {
+            continue;
+        }
+        const paths = [packageJson.executors, packageJson.builders].filter(Boolean);
+        for (const collectionPathSegment of paths) {
+            const collectionPath = (0, devkit_1.joinPathFragments)(root, collectionPathSegment);
+            if (!tree.exists(collectionPath)) {
+                continue;
+            }
+            const collectionFile = (0, devkit_1.readJson)(tree, collectionPath);
+            const collections = [
+                collectionFile.builders,
+                collectionFile.executors,
+            ].filter(Boolean);
+            for (const collection of collections) {
+                if (!collection) {
+                    continue;
+                }
+                for (const entry of Object.values(collection)) {
+                    const schemaPath = (0, devkit_1.joinPathFragments)(root, entry.schema);
+                    if (tree.exists(schemaPath)) {
+                        (0, devkit_1.updateJson)(tree, schemaPath, (json) => {
+                            if (json.version) {
+                                return json;
+                            }
+                            else {
+                                const newProperties = {
+                                    version: 2,
+                                };
+                                if (!json.outputCapture) {
+                                    newProperties.outputCapture = 'direct-nodejs';
+                                }
+                                return { ...newProperties, ...json };
+                            }
+                        });
+                    }
+                }
+            }
+        }
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = update;

package/src/migrations/update-15-9-0/jest-29-configs.d.ts

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

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

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateConfigsJest29 = void 0;
+const devkit_1 = require("@nx/devkit");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const ts = require("typescript");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const ast_utils_1 = require("@nx/jest/src/utils/ast-utils");
+const find_root_jest_files_1 = require("@nx/jest/src/utils/config/find-root-jest-files");
+// NOTE: this is a copy of the @nrwl/jest v15.8.0 migrations
+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/nx-plugin:e2e', (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-9-0/jest-29-tests.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-9-0/jest-29-tests.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateJestMocked = exports.updateJestMockTypes = exports.updateTestsJest29 = void 0;
+const devkit_1 = require("@nx/devkit");
+const ast_utils_1 = require("@nx/jest/src/utils/ast-utils");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+// NOTE: this is a copy of the @nrwl/jest v15.8.0 migrations
+async function updateTestsJest29(tree) {
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    (0, executor_options_utils_1.forEachExecutorOptionsInGraph)(graph, '@nrwl/nx-plugin:e2e', (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/cli-in-schema-json.d.ts

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