@nx/devkit 19.0.0-canary.20240423-b37bfdb → 19.0.0-canary.20240425-cec57c4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/devkit",
-  "version": "19.0.0-canary.20240423-b37bfdb",
+  "version": "19.0.0-canary.20240425-cec57c4",
   "private": false,
   "description": "The Nx Devkit is used to customize Nx for different technologies and use cases. It contains many utility functions for reading and writing files, updating configuration, working with Abstract Syntax Trees(ASTs), and more. Learn more about [extending Nx by leveraging the Nx Devkit](https://nx.dev/extending-nx/intro/getting-started) on our docs.",
   "repository": {
@@ -35,7 +35,8 @@
     "tslib": "^2.3.0",
     "semver": "^7.5.3",
     "yargs-parser": "21.1.1",
-    "@nrwl/devkit": "19.0.0-canary.20240423-b37bfdb"
+    "minimatch": "9.0.3",
+    "@nrwl/devkit": "19.0.0-canary.20240425-cec57c4"
   },
   "peerDependencies": {
     "nx": ">= 16 <= 19"

package/src/generators/plugin-migrations/executor-to-plugin-migrator.d.ts

@@ -0,0 +1,9 @@
+import type { TargetConfiguration } from 'nx/src/config/workspace-json-project-json';
+import type { Tree } from 'nx/src/generators/tree';
+import type { CreateNodes } from 'nx/src/project-graph/plugins';
+import type { ProjectGraph } from 'nx/src/config/project-graph';
+type PluginOptionsBuilder<T> = (targetName: string) => T;
+type PostTargetTransformer = (targetConfiguration: TargetConfiguration) => TargetConfiguration;
+type SkipTargetFilter = (targetConfiguration: TargetConfiguration) => [boolean, string];
+export declare function migrateExecutorToPlugin<T>(tree: Tree, projectGraph: ProjectGraph, executor: string, pluginPath: string, pluginOptionsBuilder: PluginOptionsBuilder<T>, postTargetTransformer: PostTargetTransformer, createNodes: CreateNodes<T>, specificProjectToMigrate?: string, skipTargetFilter?: SkipTargetFilter): Promise<void>;
+export {};

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

@@ -0,0 +1,197 @@
+"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_configFiles, _ExecutorToPluginMigrator_createNodesResultsForTargets, _ExecutorToPluginMigrator_init, _ExecutorToPluginMigrator_migrateTarget, _ExecutorToPluginMigrator_migrateProject, _ExecutorToPluginMigrator_addPlugins, _ExecutorToPluginMigrator_getTargetAndProjectsToMigrate, _ExecutorToPluginMigrator_getTargetDefaultsForExecutor, _ExecutorToPluginMigrator_getCreatedTargetForProjectRoot, _ExecutorToPluginMigrator_getCreateNodesResults;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateExecutorToPlugin = void 0;
+const tslib_1 = require("tslib");
+const minimatch_1 = require("minimatch");
+const executor_options_utils_1 = require("../executor-options-utils");
+const plugin_migration_utils_1 = require("./plugin-migration-utils");
+const nx_1 = require("../../../nx");
+const { glob, readNxJson, updateNxJson, mergeTargetConfigurations, updateProjectConfiguration, readProjectConfiguration, retrieveProjectConfigurations, LoadedNxPlugin, ProjectConfigurationsError, } = (0, nx_1.requireNx)();
+class ExecutorToPluginMigrator {
+    constructor(tree, projectGraph, executor, pluginPath, pluginOptionsBuilder, postTargetTransformer, createNodes, 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_configFiles.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_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);
+        for (const targetName of tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_targetAndProjectsToMigrate, "f").keys()) {
+            tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_instances, "m", _ExecutorToPluginMigrator_migrateTarget).call(this, targetName);
+        }
+        tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_instances, "m", _ExecutorToPluginMigrator_addPlugins).call(this);
+    }
+}
+_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_configFiles = new WeakMap(), _ExecutorToPluginMigrator_createNodesResultsForTargets = new WeakMap(), _ExecutorToPluginMigrator_instances = new WeakSet(), _ExecutorToPluginMigrator_init = async function _ExecutorToPluginMigrator_init() {
+    const nxJson = 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 = 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 = mergeTargetConfigurations(projectTarget, tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_targetDefaultsForExecutor, "f"));
+    delete projectTarget.executor;
+    (0, plugin_migration_utils_1.deleteMatchingProperties)(projectTarget, createdTarget);
+    projectTarget = tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_postTargetTransformer, "f").call(this, projectTarget);
+    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];
+    }
+    updateProjectConfiguration(this.tree, projectName, projectConfig);
+    return `${projectFromGraph.data.root}/**/*`;
+}, _ExecutorToPluginMigrator_addPlugins = 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) {
+            for (const pluginIncludes of existingPlugin.include) {
+                for (const projectPath of plugin.include) {
+                    if (!(0, minimatch_1.minimatch)(projectPath, pluginIncludes, { dot: true })) {
+                        existingPlugin.include.push(projectPath);
+                    }
+                }
+            }
+            const allConfigFilesAreIncluded = tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_configFiles, "f").every((configFile) => {
+                for (const includePattern of existingPlugin.include) {
+                    if ((0, minimatch_1.minimatch)(configFile, includePattern, { dot: true })) {
+                        return true;
+                    }
+                }
+                return false;
+            });
+            if (allConfigFilesAreIncluded) {
+                existingPlugin.include = undefined;
+            }
+        }
+        if (!existingPlugin) {
+            tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_nxJson, "f").plugins.push(plugin);
+        }
+    }
+    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]));
+        }
+    });
+    if (tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_targetAndProjectsToMigrate, "f").size === 0) {
+        const errorMsg = tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_specificProjectToMigrate, "f")
+            ? `Project "${tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_specificProjectToMigrate, "f")}" does not contain any targets using the "${tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_executor, "f")}" executor. Please select a project that does.`
+            : `Could not find any targets using the "${tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_executor, "f")}" executor.`;
+        throw new Error(errorMsg);
+    }
+}, _ExecutorToPluginMigrator_getTargetDefaultsForExecutor = function _ExecutorToPluginMigrator_getTargetDefaultsForExecutor() {
+    tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_targetDefaultsForExecutor, tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_nxJson, "f").targetDefaults?.[tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_executor, "f")], "f");
+}, _ExecutorToPluginMigrator_getCreatedTargetForProjectRoot = function _ExecutorToPluginMigrator_getCreatedTargetForProjectRoot(targetName, projectRoot) {
+    const createdProject = Object.entries(tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_createNodesResultsForTargets, "f").get(targetName)?.projects ?? {}).find(([root]) => root === projectRoot)[1];
+    const createdTarget = createdProject.targets[targetName];
+    delete createdTarget.command;
+    delete createdTarget.options?.cwd;
+    return createdTarget;
+}, _ExecutorToPluginMigrator_getCreateNodesResults = async function _ExecutorToPluginMigrator_getCreateNodesResults() {
+    for (const targetName of tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_targetAndProjectsToMigrate, "f").keys()) {
+        const loadedPlugin = new LoadedNxPlugin({
+            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 retrieveProjectConfigurations([loadedPlugin], this.tree.root, tslib_1.__classPrivateFieldGet(this, _ExecutorToPluginMigrator_nxJson, "f"));
+        }
+        catch (e) {
+            if (e instanceof ProjectConfigurationsError) {
+                projectConfigs = e.partialProjectConfigurationsResult;
+            }
+            else {
+                throw e;
+            }
+        }
+        tslib_1.__classPrivateFieldSet(this, _ExecutorToPluginMigrator_configFiles, Array.from(projectConfigs.matchingProjectFiles), "f");
+        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, createNodes, specificProjectToMigrate, skipTargetFilter);
+    await migrator.run();
+}
+exports.migrateExecutorToPlugin = migrateExecutorToPlugin;

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

@@ -0,0 +1,54 @@
+/**
+ * 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;

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

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

package/src/utils/add-plugin.js

@@ -17,7 +17,9 @@ async function addPlugin(tree, graph, pluginName, createNodesTuple, options, sho
     optionsLoop: for (const _pluginOptions of combinations) {
         pluginOptions = _pluginOptions;
         nxJson.plugins ??= [];
-        if (nxJson.plugins.some((p) => typeof p === 'string' ? p === pluginName : p.plugin === pluginName)) {
+        if (nxJson.plugins.some((p) => typeof p === 'string'
+            ? p === pluginName
+            : p.plugin === pluginName && !p.include)) {
             // Plugin has already been added
             return;
         }

package/src/utils/convert-nx-executor.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertNxExecutor = void 0;
 const nx_1 = require("../../nx");
-const { Workspaces, readNxJsonFromDisk, retrieveProjectConfigurationsWithAngularProjects, } = (0, nx_1.requireNx)();
+const package_json_1 = require("./package-json");
+const semver_1 = require("semver");
+const { Workspaces, readNxJsonFromDisk, retrieveProjectConfigurationsWithAngularProjects, readProjectConfigurationsFromRootMap, } = (0, nx_1.requireNx)();
 /**
  * Convert an Nx Executor into an Angular Devkit Builder
  *
@@ -20,7 +22,20 @@ function convertNxExecutor(executor) {
             const projectsConfigurations = retrieveProjectConfigurationsWithAngularProjects
                 ? {
                     version: 2,
-                    projects: await retrieveProjectConfigurationsWithAngularProjects(builderContext.workspaceRoot, nxJsonConfiguration).then((p) => p.projectNodes ?? p.projects),
+                    projects: await retrieveProjectConfigurationsWithAngularProjects(builderContext.workspaceRoot, nxJsonConfiguration).then((p) => {
+                        if (p.projectNodes) {
+                            return p.projectNodes;
+                        }
+                        // v18.3.4 changed projects to be keyed by root
+                        // rather than project name
+                        if ((0, semver_1.lt)(package_json_1.NX_VERSION, '18.3.4')) {
+                            return p.projects;
+                        }
+                        if (readProjectConfigurationsFromRootMap) {
+                            return readProjectConfigurationsFromRootMap(p.projects);
+                        }
+                        throw new Error('Unable to successfully map Nx executor -> Angular Builder');
+                    }),
                 }
                 : // TODO(v19): remove retrieveProjectConfigurations. This is to be backwards compatible with Nx 16.5 and below.
                     workspaces.readProjectsConfigurations({