@nx/devkit 0.0.0-pr-22179-271588f → 0.0.0-pr-26482-ebe2dba

package/src/generators/plugin-migrations/executor-to-plugin-migrator.js

@@ -0,0 +1,286 @@
+"use strict";
+var _ExecutorToPluginMigrator_instances, _ExecutorToPluginMigrator_projectGraph, _ExecutorToPluginMigrator_executor, _ExecutorToPluginMigrator_pluginPath, _ExecutorToPluginMigrator_pluginOptionsBuilder, _ExecutorToPluginMigrator_postTargetTransformer, _ExecutorToPluginMigrator_skipTargetFilter, _ExecutorToPluginMigrator_specificProjectToMigrate, _ExecutorToPluginMigrator_nxJson, _ExecutorToPluginMigrator_targetDefaultsForExecutor, _ExecutorToPluginMigrator_targetAndProjectsToMigrate, _ExecutorToPluginMigrator_pluginToAddForTarget, _ExecutorToPluginMigrator_createNodes, _ExecutorToPluginMigrator_createNodesV2, _ExecutorToPluginMigrator_createNodesResultsForTargets, _ExecutorToPluginMigrator_init, _ExecutorToPluginMigrator_migrateTarget, _ExecutorToPluginMigrator_migrateProject, _ExecutorToPluginMigrator_mergeInputs, _ExecutorToPluginMigrator_pluginRequiresIncludes, _ExecutorToPluginMigrator_addPlugins, _ExecutorToPluginMigrator_getTargetAndProjectsToMigrate, _ExecutorToPluginMigrator_getTargetDefaultsForExecutor, _ExecutorToPluginMigrator_getCreatedTargetForProjectRoot, _ExecutorToPluginMigrator_getCreateNodesResults;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateExecutorToPluginV1 = exports.migrateExecutorToPlugin = void 0;
+const tslib_1 = require("tslib");
+const minimatch_1 = require("minimatch");
+const node_assert_1 = require("node:assert");
+const executor_options_utils_1 = require("../executor-options-utils");
+const plugin_migration_utils_1 = require("./plugin-migration-utils");
+const devkit_exports_1 = require("nx/src/devkit-exports");
+const devkit_internals_1 = require("nx/src/devkit-internals");
+class ExecutorToPluginMigrator {
+    constructor(tree, projectGraph, executor, pluginPath, pluginOptionsBuilder, postTargetTransformer, createNodes, createNodesV2, specificProjectToMigrate, skipTargetFilter) {
+        _ExecutorToPluginMigrator_instances.add(this);
+        _ExecutorToPluginMigrator_projectGraph.set(this, void 0);
+        _ExecutorToPluginMigrator_executor.set(this, void 0);
+        _ExecutorToPluginMigrator_pluginPath.set(this, void 0);
+        _ExecutorToPluginMigrator_pluginOptionsBuilder.set(this, void 0);
+        _ExecutorToPluginMigrator_postTargetTransformer.set(this, void 0);
+        _ExecutorToPluginMigrator_skipTargetFilter.set(this, void 0);
+        _ExecutorToPluginMigrator_specificProjectToMigrate.set(this, void 0);
+        _ExecutorToPluginMigrator_nxJson.set(this, void 0);
+        _ExecutorToPluginMigrator_targetDefaultsForExecutor.set(this, void 0);
+        _ExecutorToPluginMigrator_targetAndProjectsToMigrate.set(this, void 0);
+        _ExecutorToPluginMigrator_pluginToAddForTarget.set(this, void 0);
+        _ExecutorToPluginMigrator_createNodes.set(this, void 0);
+        _ExecutorToPluginMigrator_createNodesV2.set(this, void 0);
+        _ExecutorToPluginMigrator_createNodesResultsForTargets.set(this, void 0);
+        this.tree = tree;
+        tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_projectGraph, projectGraph, "f");
+        tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_executor, executor, "f");
+        tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_pluginPath, pluginPath, "f");
+        tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_pluginOptionsBuilder, pluginOptionsBuilder, "f");
+        tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_postTargetTransformer, postTargetTransformer, "f");
+        tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_createNodes, createNodes, "f");
+        tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_createNodesV2, createNodesV2, "f");
+        tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_specificProjectToMigrate, specificProjectToMigrate, "f");
+        tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_skipTargetFilter, skipTargetFilter ?? ((...args) => [false, '']), "f");
+    }
+    async run() {
+        await tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_instances, "m", _ExecutorToPluginMigrator_init).call(this);
+        if (tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_targetAndProjectsToMigrate, "f").size > 0) {
+            for (const targetName of tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_targetAndProjectsToMigrate, "f").keys()) {
+                tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_instances, "m", _ExecutorToPluginMigrator_migrateTarget).call(this, targetName);
+            }
+            await tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_instances, "m", _ExecutorToPluginMigrator_addPlugins).call(this);
+        }
+        return tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_targetAndProjectsToMigrate, "f");
+    }
+}
+_ExecutorToPluginMigrator_projectGraph = new WeakMap(), _ExecutorToPluginMigrator_executor = new WeakMap(), _ExecutorToPluginMigrator_pluginPath = new WeakMap(), _ExecutorToPluginMigrator_pluginOptionsBuilder = new WeakMap(), _ExecutorToPluginMigrator_postTargetTransformer = new WeakMap(), _ExecutorToPluginMigrator_skipTargetFilter = new WeakMap(), _ExecutorToPluginMigrator_specificProjectToMigrate = new WeakMap(), _ExecutorToPluginMigrator_nxJson = new WeakMap(), _ExecutorToPluginMigrator_targetDefaultsForExecutor = new WeakMap(), _ExecutorToPluginMigrator_targetAndProjectsToMigrate = new WeakMap(), _ExecutorToPluginMigrator_pluginToAddForTarget = new WeakMap(), _ExecutorToPluginMigrator_createNodes = new WeakMap(), _ExecutorToPluginMigrator_createNodesV2 = new WeakMap(), _ExecutorToPluginMigrator_createNodesResultsForTargets = new WeakMap(), _ExecutorToPluginMigrator_instances = new WeakSet(), _ExecutorToPluginMigrator_init = async function _ExecutorToPluginMigrator_init() {
+    const nxJson = (0, devkit_exports_1.readNxJson)(this.tree);
+    nxJson.plugins ??= [];
+    tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_nxJson, nxJson, "f");
+    tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_targetAndProjectsToMigrate, new Map(), "f");
+    tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_pluginToAddForTarget, new Map(), "f");
+    tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_createNodesResultsForTargets, new Map(), "f");
+    tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_instances, "m", _ExecutorToPluginMigrator_getTargetDefaultsForExecutor).call(this);
+    tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_instances, "m", _ExecutorToPluginMigrator_getTargetAndProjectsToMigrate).call(this);
+    await tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_instances, "m", _ExecutorToPluginMigrator_getCreateNodesResults).call(this);
+}, _ExecutorToPluginMigrator_migrateTarget = function _ExecutorToPluginMigrator_migrateTarget(targetName) {
+    const include = [];
+    for (const projectName of tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_targetAndProjectsToMigrate, "f").get(targetName)) {
+        include.push(tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_instances, "m", _ExecutorToPluginMigrator_migrateProject).call(this, projectName, targetName));
+    }
+    tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_pluginToAddForTarget, "f").set(targetName, {
+        plugin: tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_pluginPath, "f"),
+        options: tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_pluginOptionsBuilder, "f").call(this, targetName),
+        include,
+    });
+}, _ExecutorToPluginMigrator_migrateProject = function _ExecutorToPluginMigrator_migrateProject(projectName, targetName) {
+    const projectFromGraph = tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_projectGraph, "f").nodes[projectName];
+    const projectConfig = (0, devkit_exports_1.readProjectConfiguration)(this.tree, projectName);
+    const createdTarget = tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_instances, "m", _ExecutorToPluginMigrator_getCreatedTargetForProjectRoot).call(this, targetName, projectFromGraph.data.root);
+    let projectTarget = projectConfig.targets[targetName];
+    projectTarget = (0, devkit_internals_1.mergeTargetConfigurations)(projectTarget, tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_targetDefaultsForExecutor, "f"));
+    delete projectTarget.executor;
+    (0, plugin_migration_utils_1.deleteMatchingProperties)(projectTarget, createdTarget);
+    if (projectTarget.inputs && createdTarget.inputs) {
+        tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_instances, "m", _ExecutorToPluginMigrator_mergeInputs).call(this, projectTarget, createdTarget);
+    }
+    projectTarget = tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_postTargetTransformer, "f").call(this, projectTarget, this.tree, { projectName, root: projectFromGraph.data.root }, createdTarget);
+    if (projectTarget.options &&
+        Object.keys(projectTarget.options).length === 0) {
+        delete projectTarget.options;
+    }
+    if (Object.keys(projectTarget).length > 0) {
+        projectConfig.targets[targetName] = projectTarget;
+    }
+    else {
+        delete projectConfig.targets[targetName];
+    }
+    if (!projectConfig['// targets']) {
+        projectConfig['// targets'] = `to see all targets run: nx show project ${projectName} --web`;
+    }
+    (0, devkit_exports_1.updateProjectConfiguration)(this.tree, projectName, projectConfig);
+    return `${projectFromGraph.data.root}/**/*`;
+}, _ExecutorToPluginMigrator_mergeInputs = function _ExecutorToPluginMigrator_mergeInputs(target, inferredTarget) {
+    const isInputInferred = (input) => {
+        return inferredTarget.inputs.some((inferredInput) => {
+            try {
+                (0, node_assert_1.deepStrictEqual)(input, inferredInput);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+    };
+    if (target.inputs.every(isInputInferred)) {
+        delete target.inputs;
+        return;
+    }
+    const inferredTargetExternalDependencyInput = inferredTarget.inputs.find((i) => typeof i !== 'string' && 'externalDependencies' in i);
+    if (!inferredTargetExternalDependencyInput) {
+        // plugins should normally have an externalDependencies input, but if it
+        // doesn't, there's nothing to merge
+        return;
+    }
+    const targetExternalDependencyInput = target.inputs.find((i) => typeof i !== 'string' && 'externalDependencies' in i);
+    if (!targetExternalDependencyInput) {
+        // the target doesn't have an externalDependencies input, so we can just
+        // add the inferred one
+        target.inputs.push(inferredTargetExternalDependencyInput);
+    }
+    else {
+        // the target has an externalDependencies input, so we need to merge them
+        targetExternalDependencyInput.externalDependencies = Array.from(new Set([
+            ...targetExternalDependencyInput.externalDependencies,
+            ...inferredTargetExternalDependencyInput.externalDependencies,
+        ]));
+    }
+}, _ExecutorToPluginMigrator_pluginRequiresIncludes = async function _ExecutorToPluginMigrator_pluginRequiresIncludes(targetName, plugin) {
+    const loadedPlugin = new devkit_internals_1.LoadedNxPlugin({
+        createNodesV2: tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_createNodesV2, "f"),
+        createNodes: tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_createNodes, "f"),
+        name: tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_pluginPath, "f"),
+    }, plugin);
+    const originalResults = tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_createNodesResultsForTargets, "f").get(targetName);
+    let resultsWithIncludes;
+    try {
+        resultsWithIncludes = await (0, devkit_internals_1.retrieveProjectConfigurations)([loadedPlugin], this.tree.root, tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_nxJson, "f"));
+    }
+    catch (e) {
+        if (e instanceof devkit_internals_1.ProjectConfigurationsError) {
+            resultsWithIncludes = e.partialProjectConfigurationsResult;
+        }
+        else {
+            throw e;
+        }
+    }
+    return !deepEqual(originalResults, resultsWithIncludes);
+}, _ExecutorToPluginMigrator_addPlugins = async function _ExecutorToPluginMigrator_addPlugins() {
+    for (const [targetName, plugin] of tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_pluginToAddForTarget, "f").entries()) {
+        const pluginOptions = tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_pluginOptionsBuilder, "f").call(this, targetName);
+        const existingPlugin = tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_nxJson, "f").plugins.find((plugin) => {
+            if (typeof plugin === 'string' ||
+                plugin.plugin !== tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_pluginPath, "f")) {
+                return;
+            }
+            for (const key in plugin.options) {
+                if (plugin.options[key] !== pluginOptions[key]) {
+                    return false;
+                }
+            }
+            return true;
+        });
+        if (existingPlugin?.include) {
+            // Add to the existing plugin includes
+            existingPlugin.include = existingPlugin.include.concat(
+            // Any include that is in the new plugin's include list
+            plugin.include.filter((projectPath) => 
+            // And is not already covered by the existing plugin's include list
+            !existingPlugin.include.some((pluginIncludes) => (0, minimatch_1.minimatch)(projectPath, pluginIncludes, { dot: true }))));
+            if (!(await tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_instances, "m", _ExecutorToPluginMigrator_pluginRequiresIncludes).call(this, targetName, existingPlugin))) {
+                delete existingPlugin.include;
+            }
+        }
+        if (!existingPlugin) {
+            if (!(await tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_instances, "m", _ExecutorToPluginMigrator_pluginRequiresIncludes).call(this, targetName, plugin))) {
+                plugin.include = undefined;
+            }
+            tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_nxJson, "f").plugins.push(plugin);
+        }
+    }
+    (0, devkit_exports_1.updateNxJson)(this.tree, tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_nxJson, "f"));
+}, _ExecutorToPluginMigrator_getTargetAndProjectsToMigrate = function _ExecutorToPluginMigrator_getTargetAndProjectsToMigrate() {
+    (0, executor_options_utils_1.forEachExecutorOptions)(this.tree, tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_executor, "f"), (targetConfiguration, projectName, targetName, configurationName) => {
+        if (configurationName) {
+            return;
+        }
+        if (tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_specificProjectToMigrate, "f") &&
+            projectName !== tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_specificProjectToMigrate, "f")) {
+            return;
+        }
+        const [skipTarget, reasonTargetWasSkipped] = tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_skipTargetFilter, "f").call(this, targetConfiguration);
+        if (skipTarget) {
+            const errorMsg = `${targetName} target on project "${projectName}" cannot be migrated. ${reasonTargetWasSkipped}`;
+            if (tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_specificProjectToMigrate, "f")) {
+                throw new Error(errorMsg);
+            }
+            else {
+                console.warn(errorMsg);
+            }
+            return;
+        }
+        if (tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_targetAndProjectsToMigrate, "f").has(targetName)) {
+            tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_targetAndProjectsToMigrate, "f").get(targetName).add(projectName);
+        }
+        else {
+            tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_targetAndProjectsToMigrate, "f").set(targetName, new Set([projectName]));
+        }
+    });
+}, _ExecutorToPluginMigrator_getTargetDefaultsForExecutor = function _ExecutorToPluginMigrator_getTargetDefaultsForExecutor() {
+    tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_targetDefaultsForExecutor, structuredClone(tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_nxJson, "f").targetDefaults?.[tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_executor, "f")]), "f");
+}, _ExecutorToPluginMigrator_getCreatedTargetForProjectRoot = function _ExecutorToPluginMigrator_getCreatedTargetForProjectRoot(targetName, projectRoot) {
+    const entry = Object.entries(tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_createNodesResultsForTargets, "f").get(targetName)?.projects ?? {}).find(([root]) => root === projectRoot);
+    if (!entry) {
+        throw new Error(`The nx plugin did not find a project inside ${projectRoot}. File an issue at https://github.com/nrwl/nx with information about your project structure.`);
+    }
+    const createdProject = entry[1];
+    const createdTarget = structuredClone(createdProject.targets[targetName]);
+    delete createdTarget.command;
+    delete createdTarget.options?.cwd;
+    return createdTarget;
+}, _ExecutorToPluginMigrator_getCreateNodesResults = async function _ExecutorToPluginMigrator_getCreateNodesResults() {
+    if (tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_targetAndProjectsToMigrate, "f").size === 0) {
+        return;
+    }
+    for (const targetName of tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_targetAndProjectsToMigrate, "f").keys()) {
+        const loadedPlugin = new devkit_internals_1.LoadedNxPlugin({
+            createNodesV2: tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_createNodesV2, "f"),
+            createNodes: tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_createNodes, "f"),
+            name: tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_pluginPath, "f"),
+        }, {
+            plugin: tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_pluginPath, "f"),
+            options: tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_pluginOptionsBuilder, "f").call(this, targetName),
+        });
+        let projectConfigs;
+        try {
+            projectConfigs = await (0, devkit_internals_1.retrieveProjectConfigurations)([loadedPlugin], this.tree.root, tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_nxJson, "f"));
+        }
+        catch (e) {
+            if (e instanceof devkit_internals_1.ProjectConfigurationsError) {
+                projectConfigs = e.partialProjectConfigurationsResult;
+            }
+            else {
+                throw e;
+            }
+        }
+        tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_createNodesResultsForTargets, "f").set(targetName, projectConfigs);
+    }
+};
+async function migrateExecutorToPlugin(tree, projectGraph, executor, pluginPath, pluginOptionsBuilder, postTargetTransformer, createNodes, specificProjectToMigrate, skipTargetFilter) {
+    const migrator = new ExecutorToPluginMigrator(tree, projectGraph, executor, pluginPath, pluginOptionsBuilder, postTargetTransformer, undefined, createNodes, specificProjectToMigrate, skipTargetFilter);
+    return await migrator.run();
+}
+exports.migrateExecutorToPlugin = migrateExecutorToPlugin;
+async function migrateExecutorToPluginV1(tree, projectGraph, executor, pluginPath, pluginOptionsBuilder, postTargetTransformer, createNodes, specificProjectToMigrate, skipTargetFilter) {
+    const migrator = new ExecutorToPluginMigrator(tree, projectGraph, executor, pluginPath, pluginOptionsBuilder, postTargetTransformer, createNodes, undefined, specificProjectToMigrate, skipTargetFilter);
+    return await migrator.run();
+}
+exports.migrateExecutorToPluginV1 = migrateExecutorToPluginV1;
+// Checks if two objects are structurely equal, without caring
+// about the order of the keys.
+function deepEqual(a, b, logKey = '') {
+    const aKeys = Object.keys(a);
+    const bKeys = new Set(Object.keys(b));
+    if (aKeys.length !== bKeys.size) {
+        return false;
+    }
+    for (const key of aKeys) {
+        if (!bKeys.has(key)) {
+            return false;
+        }
+        if (typeof a[key] === 'object' && typeof b[key] === 'object') {
+            if (!deepEqual(a[key], b[key], logKey + '.' + key)) {
+                return false;
+            }
+        }
+        else if (a[key] !== b[key]) {
+            return false;
+        }
+    }
+    return true;
+}

package/src/generators/plugin-migrations/plugin-migration-utils.d.ts

@@ -0,0 +1,62 @@
+import type { TargetConfiguration } from 'nx/src/devkit-exports';
+/**
+ * Iterate through the current target in the project.json and its options comparing it to the target created by the Plugin itself
+ * Delete matching properties from current target.
+ *
+ * _Note: Deletes by reference_
+ *
+ * @example
+ * // Run the plugin to get all the projects
+ * const { projects } = await createNodes[1](
+ *    playwrightConfigPath,
+ *    { targetName, ciTargetName: 'e2e-ci' },
+ *    { workspaceRoot: tree.root, nxJsonConfiguration, configFiles }
+ * );
+ *
+ * // Find the project that matches the one that is being migrated
+ * const createdProject = Object.entries(projects ?? {}).find(
+ *  ([root]) => root === projectFromGraph.data.root
+ * )[1];
+ *
+ * // Get the created TargetConfiguration for the target being migrated
+ * const createdTarget: TargetConfiguration<RunCommandsOptions> =
+ *    createdProject.targets[targetName];
+ *
+ * // Delete specific run-commands options
+ * delete createdTarget.command;
+ * delete createdTarget.options?.cwd;
+ *
+ * // Get the TargetConfiguration for the target being migrated from project.json
+ * const projectConfig = readProjectConfiguration(tree, projectName);
+ * let targetToMigrate = projectConfig.targets[targetName];
+ *
+ * // Merge the target defaults for the executor to the target being migrated
+ * target = mergeTargetConfigurations(targetToMigrate, targetDefaultsForExecutor);
+ *
+ * // Delete executor and any additional options that are no longer necessary
+ * delete target.executor;
+ * delete target.options?.config;
+ *
+ * // Run deleteMatchingProperties to delete further options that match what the plugin creates
+ * deleteMatchingProperties(target, createdTarget);
+ *
+ * // Delete the target if it is now empty, otherwise, set it to the updated TargetConfiguration
+ * if (Object.keys(target).length > 0) {
+ *    projectConfig.targets[targetName] = target;
+ * } else {
+ *    delete projectConfig.targets[targetName];
+ * }
+ *
+ * updateProjectConfiguration(tree, projectName, projectConfig);
+ *
+ * @param targetToMigrate The target from project.json
+ * @param createdTarget The target created by the Plugin
+ */
+export declare function deleteMatchingProperties(targetToMigrate: object, createdTarget: object): void;
+export declare function processTargetOutputs(target: TargetConfiguration, renamedOutputOptions: Array<{
+    newName: string;
+    oldName: string;
+}>, inferredTarget: TargetConfiguration, projectDetails: {
+    projectName: string;
+    projectRoot: string;
+}): void;

package/src/generators/plugin-migrations/plugin-migration-utils.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processTargetOutputs = exports.deleteMatchingProperties = void 0;
+const devkit_internals_1 = require("nx/src/devkit-internals");
+/**
+ * Iterate through the current target in the project.json and its options comparing it to the target created by the Plugin itself
+ * Delete matching properties from current target.
+ *
+ * _Note: Deletes by reference_
+ *
+ * @example
+ * // Run the plugin to get all the projects
+ * const { projects } = await createNodes[1](
+ *    playwrightConfigPath,
+ *    { targetName, ciTargetName: 'e2e-ci' },
+ *    { workspaceRoot: tree.root, nxJsonConfiguration, configFiles }
+ * );
+ *
+ * // Find the project that matches the one that is being migrated
+ * const createdProject = Object.entries(projects ?? {}).find(
+ *  ([root]) => root === projectFromGraph.data.root
+ * )[1];
+ *
+ * // Get the created TargetConfiguration for the target being migrated
+ * const createdTarget: TargetConfiguration<RunCommandsOptions> =
+ *    createdProject.targets[targetName];
+ *
+ * // Delete specific run-commands options
+ * delete createdTarget.command;
+ * delete createdTarget.options?.cwd;
+ *
+ * // Get the TargetConfiguration for the target being migrated from project.json
+ * const projectConfig = readProjectConfiguration(tree, projectName);
+ * let targetToMigrate = projectConfig.targets[targetName];
+ *
+ * // Merge the target defaults for the executor to the target being migrated
+ * target = mergeTargetConfigurations(targetToMigrate, targetDefaultsForExecutor);
+ *
+ * // Delete executor and any additional options that are no longer necessary
+ * delete target.executor;
+ * delete target.options?.config;
+ *
+ * // Run deleteMatchingProperties to delete further options that match what the plugin creates
+ * deleteMatchingProperties(target, createdTarget);
+ *
+ * // Delete the target if it is now empty, otherwise, set it to the updated TargetConfiguration
+ * if (Object.keys(target).length > 0) {
+ *    projectConfig.targets[targetName] = target;
+ * } else {
+ *    delete projectConfig.targets[targetName];
+ * }
+ *
+ * updateProjectConfiguration(tree, projectName, projectConfig);
+ *
+ * @param targetToMigrate The target from project.json
+ * @param createdTarget The target created by the Plugin
+ */
+function deleteMatchingProperties(targetToMigrate, createdTarget) {
+    for (const key in targetToMigrate) {
+        if (Array.isArray(targetToMigrate[key])) {
+            if (targetToMigrate[key].every((v) => createdTarget[key]?.includes(v)) &&
+                targetToMigrate[key].length === createdTarget[key]?.length) {
+                delete targetToMigrate[key];
+            }
+        }
+        else if (typeof targetToMigrate[key] === 'object' &&
+            typeof createdTarget[key] === 'object') {
+            deleteMatchingProperties(targetToMigrate[key], createdTarget[key]);
+        }
+        else if (targetToMigrate[key] === createdTarget[key]) {
+            delete targetToMigrate[key];
+        }
+        if (typeof targetToMigrate[key] === 'object' &&
+            Object.keys(targetToMigrate[key]).length === 0) {
+            delete targetToMigrate[key];
+        }
+    }
+}
+exports.deleteMatchingProperties = deleteMatchingProperties;
+function processTargetOutputs(target, renamedOutputOptions, inferredTarget, projectDetails) {
+    const interpolatedInferredOutputs = (inferredTarget.outputs ?? []).map((output) => (0, devkit_internals_1.interpolate)(output, {
+        workspaceRoot: '',
+        projectRoot: projectDetails.projectRoot,
+        projectName: projectDetails.projectName,
+    }));
+    const targetOutputs = (target.outputs ?? []).map((output) => updateOutput(output, renamedOutputOptions));
+    const interpolatedOutputs = targetOutputs.map((output) => (0, devkit_internals_1.interpolate)(output, {
+        workspaceRoot: '',
+        projectRoot: projectDetails.projectRoot,
+        projectName: projectDetails.projectName,
+    }));
+    const shouldDelete = interpolatedOutputs.every((output) => interpolatedInferredOutputs.includes(output));
+    if (shouldDelete) {
+        // all existing outputs are already inferred
+        delete target.outputs;
+        return;
+    }
+    // move extra inferred outputs to the target outputs
+    for (let i = 0; i < interpolatedInferredOutputs.length; i++) {
+        if (!interpolatedOutputs.includes(interpolatedInferredOutputs[i])) {
+            targetOutputs.push(inferredTarget.outputs[i]);
+            interpolatedOutputs.push(interpolatedInferredOutputs[i]);
+        }
+    }
+    target.outputs = targetOutputs;
+}
+exports.processTargetOutputs = processTargetOutputs;
+function updateOutputRenamingOption(output, option, previousName) {
+    const newOptionToken = `{options.${option}}`;
+    const oldOptionToken = `{options.${previousName}}`;
+    if (!output.startsWith('{workspaceRoot}') &&
+        !output.startsWith('{projectRoot}')) {
+        return `{projectRoot}/${output.replace(oldOptionToken, newOptionToken)}`;
+    }
+    if (output.startsWith('{workspaceRoot}') &&
+        !output.startsWith('{workspaceRoot}/{projectRoot}')) {
+        return output
+            .replace('{workspaceRoot}', '{projectRoot}')
+            .replace(oldOptionToken, newOptionToken);
+    }
+    return output.replace(oldOptionToken, newOptionToken);
+}
+function updateOutput(output, renamedOutputOptions) {
+    if (!/{options\..*}/.test(output)) {
+        // output does not contain any option tokens
+        return output;
+    }
+    for (const { newName, oldName } of renamedOutputOptions) {
+        const optionToken = `{options.${oldName}}`;
+        if (output.includes(optionToken)) {
+            return updateOutputRenamingOption(output, newName, oldName);
+        }
+    }
+    if (!output.startsWith('{workspaceRoot}') &&
+        !output.startsWith('{projectRoot}')) {
+        return `{projectRoot}/${output}`;
+    }
+    if (output.startsWith('{workspaceRoot}') &&
+        !output.startsWith('{workspaceRoot}/{projectRoot}')) {
+        return output.replace('{workspaceRoot}', '{projectRoot}');
+    }
+    return output;
+}

package/src/generators/project-name-and-root-utils.d.ts

@@ -1,5 +1,4 @@
-import type { ProjectType } from 'nx/src/config/workspace-json-project-json';
-import type { Tree } from 'nx/src/generators/tree';
+import { ProjectType, Tree } from 'nx/src/devkit-exports';
 export type ProjectNameAndRootFormat = 'as-provided' | 'derived';
 export type ProjectGenerationOptions = {
     name: string;

package/src/generators/project-name-and-root-utils.js

@@ -3,10 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setCwd = exports.determineProjectNameAndRootOptions = void 0;
 const enquirer_1 = require("enquirer");
 const path_1 = require("path");
-const nx_1 = require("../../nx");
 const get_workspace_layout_1 = require("../utils/get-workspace-layout");
 const names_1 = require("../utils/names");
-const { joinPathFragments, logger, normalizePath, output, readJson, stripIndents, workspaceRoot, } = (0, nx_1.requireNx)();
+const devkit_exports_1 = require("nx/src/devkit-exports");
 async function determineProjectNameAndRootOptions(tree, options) {
     if (!options.projectNameAndRootFormat &&
         (process.env.NX_INTERACTIVE !== 'true' || !isTTY())) {
@@ -45,8 +44,8 @@ function validateName(name, projectNameAndRootFormat) {
     }
 }
 function logDeprecationMessage(callingGenerator, formats) {
-    logger.warn(stripIndents `
-    In Nx 19, generating projects will no longer derive the name and root.
+    devkit_exports_1.logger.warn((0, devkit_exports_1.stripIndents) `
+    In Nx 20, generating projects will no longer derive the name and root.
     Please provide the exact project name and root in the future.
     Example: nx g ${callingGenerator} ${formats['derived'].projectName} --directory ${formats['derived'].projectRoot}
   `);
@@ -86,7 +85,7 @@ async function determineFormat(formats) {
 }
 function getProjectNameAndRootFormats(tree, options) {
     const directory = options.directory
-        ? normalizePath(options.directory.replace(/^\.?\//, ''))
+        ? (0, devkit_exports_1.normalizePath)(options.directory.replace(/^\.?\//, ''))
         : undefined;
     const { name: asProvidedParsedName, directory: asProvidedParsedDirectory } = parseNameForAsProvided(options.name);
     if (asProvidedParsedDirectory && directory) {
@@ -106,7 +105,7 @@ function getProjectNameAndRootFormats(tree, options) {
     }
     if (asProvidedOptions.projectName.startsWith('@')) {
         if (!options.projectNameAndRootFormat) {
-            output.warn({
+            devkit_exports_1.output.warn({
                 title: `The provided name "${options.name}" contains a scoped project name and this is not supported by the "${options.callingGenerator}" when using the "derived" format.`,
                 bodyLines: [
                     `The generator will try to generate the project "${asProvidedOptions.projectName}" using the "as-provided" format at "${asProvidedOptions.projectRoot}".`,
@@ -152,7 +151,7 @@ function getAsProvidedOptions(tree, options) {
             projectRoot = options.directory;
         }
         else {
-            projectRoot = joinPathFragments(relativeCwd, options.directory);
+            projectRoot = (0, devkit_exports_1.joinPathFragments)(relativeCwd, options.directory);
         }
     }
     else if (options.rootProject) {
@@ -162,7 +161,7 @@ function getAsProvidedOptions(tree, options) {
         projectRoot = relativeCwd;
         // append the project name to the current working directory if it doesn't end with it
         if (!relativeCwd.endsWith(options.name)) {
-            projectRoot = joinPathFragments(relativeCwd, options.name);
+            projectRoot = (0, devkit_exports_1.joinPathFragments)(relativeCwd, options.name);
         }
     }
     let importPath = undefined;
@@ -176,7 +175,7 @@ function getAsProvidedOptions(tree, options) {
                 const npmScope = getNpmScope(tree);
                 importPath =
                     projectRoot === '.'
-                        ? readJson(tree, 'package.json').name ??
+                        ? (0, devkit_exports_1.readJson)(tree, 'package.json').name ??
                             getImportPath(npmScope, options.name)
                         : getImportPath(npmScope, options.name);
             }
@@ -208,7 +207,7 @@ function getDerivedOptions(tree, options) {
     let projectRoot = projectDirectoryWithoutLayout;
     if (projectDirectoryWithoutLayout !== '.') {
         // prepend the layout directory
-        projectRoot = joinPathFragments(layoutDirectory, projectRoot);
+        projectRoot = (0, devkit_exports_1.joinPathFragments)(layoutDirectory, projectRoot);
     }
     let importPath;
     if (options.projectType === 'library') {
@@ -217,7 +216,7 @@ function getDerivedOptions(tree, options) {
             const npmScope = getNpmScope(tree);
             importPath =
                 projectRoot === '.'
-                    ? readJson(tree, 'package.json').name ??
+                    ? (0, devkit_exports_1.readJson)(tree, 'package.json').name ??
                         getImportPath(npmScope, projectName)
                     : getImportPath(npmScope, projectDirectoryWithoutLayout);
         }
@@ -245,7 +244,7 @@ function getImportPath(npmScope, name) {
 }
 function getNpmScope(tree) {
     const { name } = tree.exists('package.json')
-        ? readJson(tree, 'package.json')
+        ? (0, devkit_exports_1.readJson)(tree, 'package.json')
         : { name: null };
     return name?.startsWith('@') ? name.split('/')[0].substring(1) : undefined;
 }
@@ -259,22 +258,22 @@ function isTTY() {
  * environment variable (see here: https://docs.npmjs.com/cli/v9/commands/npm-run-script#description).
  */
 function getCwd() {
-    return process.env.INIT_CWD?.startsWith(workspaceRoot)
+    return process.env.INIT_CWD?.startsWith(devkit_exports_1.workspaceRoot)
         ? process.env.INIT_CWD
         : process.cwd();
 }
 function getRelativeCwd() {
-    return normalizePath((0, path_1.relative)(workspaceRoot, getCwd())).replace(/\/$/, '');
+    return (0, devkit_exports_1.normalizePath)((0, path_1.relative)(devkit_exports_1.workspaceRoot, getCwd())).replace(/\/$/, '');
 }
 /**
  * Function for setting cwd during testing
  */
 function setCwd(path) {
-    process.env.INIT_CWD = (0, path_1.join)(workspaceRoot, path);
+    process.env.INIT_CWD = (0, path_1.join)(devkit_exports_1.workspaceRoot, path);
 }
 exports.setCwd = setCwd;
 function parseNameForAsProvided(rawName) {
-    const directory = normalizePath(rawName);
+    const directory = (0, devkit_exports_1.normalizePath)(rawName);
     if (rawName.includes('@')) {
         const index = directory.lastIndexOf('@');
         if (index === 0) {
@@ -291,7 +290,7 @@ function parseNameForAsProvided(rawName) {
     return { name: rawName, directory: undefined };
 }
 function parseNameForDerived(rawName) {
-    const parsedName = normalizePath(rawName).split('/');
+    const parsedName = (0, devkit_exports_1.normalizePath)(rawName).split('/');
     const name = parsedName.pop();
     const directory = parsedName.length ? parsedName.join('/') : undefined;
     return { name, directory };

package/src/generators/run-tasks-in-serial.d.ts

@@ -1,4 +1,4 @@
-import type { GeneratorCallback } from 'nx/src/config/misc-interfaces';
+import type { GeneratorCallback } from 'nx/src/devkit-exports';
 /**
  * Run tasks in serial
  *

package/src/generators/to-js.d.ts

@@ -1,4 +1,4 @@
-import type { Tree } from 'nx/src/generators/tree';
+import type { Tree } from 'nx/src/devkit-exports';
 import type { ScriptTarget, ModuleKind } from 'typescript';
 export type ToJSOptions = {
     target?: ScriptTarget;

package/src/generators/update-ts-configs-to-js.d.ts

@@ -1,4 +1,4 @@
-import type { Tree } from 'nx/src/generators/tree';
+import { Tree } from 'nx/src/devkit-exports';
 export declare function updateTsConfigsToJs(tree: Tree, options: {
     projectRoot: string;
 }): void;