@nx/devkit 18.3.0-canary.20240413-134cbbc → 18.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/devkit",
-  "version": "18.3.0-canary.20240413-134cbbc",
+  "version": "18.3.0",
   "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,7 @@
     "tslib": "^2.3.0",
     "semver": "^7.5.3",
     "yargs-parser": "21.1.1",
-    "@nrwl/devkit": "18.3.0-canary.20240413-134cbbc"
+    "@nrwl/devkit": "18.3.0"
   },
   "peerDependencies": {
     "nx": ">= 16 <= 19"

package/src/utils/add-plugin.d.ts

@@ -0,0 +1,7 @@
+import { type CreateNodes, type ProjectGraph, type Tree } from 'nx/src/devkit-exports';
+/**
+ * Iterates through various forms of plugin options to find the one which does not conflict with the current graph
+
+ */
+export declare function addPlugin<PluginOptions>(tree: Tree, graph: ProjectGraph, pluginName: string, createNodesTuple: CreateNodes<PluginOptions>, options: Partial<Record<keyof PluginOptions, PluginOptions[keyof PluginOptions][]>>, shouldUpdatePackageJsonScripts: boolean): Promise<void>;
+export declare function generateCombinations<T>(input: Record<string, T[]>): Record<string, T>[];

package/src/utils/{update-package-scripts.js → add-plugin.js}

@@ -1,21 +1,83 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updatePackageScripts = void 0;
-const path_1 = require("path");
+exports.generateCombinations = exports.addPlugin = void 0;
 const yargs = require("yargs-parser");
 const nx_1 = require("../../nx");
-const { glob, readJson, readNxJson, workspaceRoot, writeJson } = (0, nx_1.requireNx)();
-async function updatePackageScripts(tree, createNodesTuple) {
+const { readJson, writeJson, readNxJson, updateNxJson, retrieveProjectConfigurations, LoadedNxPlugin, ProjectConfigurationsError, } = (0, nx_1.requireNx)();
+/**
+ * Iterates through various forms of plugin options to find the one which does not conflict with the current graph
+
+ */
+async function addPlugin(tree, graph, pluginName, createNodesTuple, options, shouldUpdatePackageJsonScripts) {
+    const graphNodes = Object.values(graph.nodes);
     const nxJson = readNxJson(tree);
-    const [pattern, createNodes] = createNodesTuple;
-    const matchingFiles = glob(tree, [pattern]);
-    for (const file of matchingFiles) {
-        const projectRoot = getProjectRootFromConfigFile(file);
-        await processProject(tree, projectRoot, file, createNodes, nxJson, matchingFiles);
+    let pluginOptions;
+    let projConfigs;
+    const combinations = generateCombinations(options);
+    optionsLoop: for (const _pluginOptions of combinations) {
+        pluginOptions = _pluginOptions;
+        nxJson.plugins ??= [];
+        if (nxJson.plugins.some((p) => typeof p === 'string' ? p === pluginName : p.plugin === pluginName)) {
+            // Plugin has already been added
+            return;
+        }
+        global.NX_GRAPH_CREATION = true;
+        try {
+            projConfigs = await retrieveProjectConfigurations([
+                new LoadedNxPlugin({
+                    name: pluginName,
+                    createNodes: createNodesTuple,
+                }, {
+                    plugin: pluginName,
+                    options: pluginOptions,
+                }),
+            ], tree.root, nxJson);
+        }
+        catch (e) {
+            // Errors are okay for this because we're only running 1 plugin
+            if (e instanceof ProjectConfigurationsError) {
+                projConfigs = e.partialProjectConfigurationsResult;
+            }
+            else {
+                throw e;
+            }
+        }
+        global.NX_GRAPH_CREATION = false;
+        for (const projConfig of Object.values(projConfigs.projects)) {
+            const node = graphNodes.find((node) => node.data.root === projConfig.root);
+            if (!node) {
+                continue;
+            }
+            for (const targetName in projConfig.targets) {
+                if (node.data.targets[targetName]) {
+                    // Conflicting Target Name, check the next one
+                    pluginOptions = null;
+                    continue optionsLoop;
+                }
+            }
+        }
+        break;
+    }
+    if (!pluginOptions) {
+        throw new Error('Could not add the plugin in a way which does not conflict with existing targets. Please report this error at: https://github.com/nrwl/nx/issues/new/choose');
+    }
+    nxJson.plugins.push({
+        plugin: pluginName,
+        options: pluginOptions,
+    });
+    updateNxJson(tree, nxJson);
+    if (shouldUpdatePackageJsonScripts) {
+        updatePackageScripts(tree, projConfigs);
     }
 }
-exports.updatePackageScripts = updatePackageScripts;
-async function processProject(tree, projectRoot, projectConfigurationFile, createNodesFunction, nxJsonConfiguration, configFiles) {
+exports.addPlugin = addPlugin;
+function updatePackageScripts(tree, projectConfigurations) {
+    for (const projectConfig of Object.values(projectConfigurations.projects)) {
+        const projectRoot = projectConfig.root;
+        processProject(tree, projectRoot, projectConfig);
+    }
+}
+function processProject(tree, projectRoot, projectConfiguration) {
     const packageJsonPath = `${projectRoot}/package.json`;
     if (!tree.exists(packageJsonPath)) {
         return;
@@ -24,12 +86,7 @@ async function processProject(tree, projectRoot, projectConfigurationFile, creat
     if (!packageJson.scripts || !Object.keys(packageJson.scripts).length) {
         return;
     }
-    const result = await createNodesFunction(projectConfigurationFile, {}, {
-        nxJsonConfiguration,
-        workspaceRoot,
-        configFiles,
-    });
-    const targetCommands = getInferredTargetCommands(result);
+    const targetCommands = getInferredTargetCommands(projectConfiguration);
     if (!targetCommands.length) {
         return;
     }
@@ -116,68 +173,68 @@ async function processProject(tree, projectRoot, projectConfigurationFile, creat
             }
         }
     }
-    if (process.env.NX_RUNNING_NX_INIT === 'true') {
-        // running `nx init` so we want to exclude everything by default
-        packageJson.nx ??= {};
-        packageJson.nx.includedScripts = [];
-    }
-    else if (replacedTargets.size) {
-        /**
-         * Running `nx add`. In this case we want to:
-         * - if `includedScripts` is already set: exclude scripts that match inferred targets that were used to replace a script
-         * - if `includedScripts` is not set: set `includedScripts` with all scripts except the ones that match an inferred target that was used to replace a script
-         */
-        const includedScripts = packageJson.nx?.includedScripts ?? Object.keys(packageJson.scripts);
-        const filteredScripts = includedScripts.filter((s) => !replacedTargets.has(s));
-        if (filteredScripts.length !== includedScripts.length) {
-            packageJson.nx ??= {};
-            packageJson.nx.includedScripts = filteredScripts;
-        }
-    }
     writeJson(tree, packageJsonPath, packageJson);
 }
-function getInferredTargetCommands(result) {
+function getInferredTargetCommands(project) {
     const targetCommands = [];
-    for (const project of Object.values(result.projects ?? {})) {
-        for (const [targetName, target] of Object.entries(project.targets ?? {})) {
-            if (target.command) {
-                targetCommands.push({ command: target.command, target: targetName });
+    for (const [targetName, target] of Object.entries(project.targets ?? {})) {
+        if (target.command) {
+            targetCommands.push({ command: target.command, target: targetName });
+        }
+        else if (target.executor === 'nx:run-commands' &&
+            target.options?.command) {
+            targetCommands.push({
+                command: target.options.command,
+                target: targetName,
+            });
+        }
+        if (!target.configurations) {
+            continue;
+        }
+        for (const [configurationName, configuration] of Object.entries(target.configurations)) {
+            if (configuration.command) {
+                targetCommands.push({
+                    command: configuration.command,
+                    target: targetName,
+                    configuration: configurationName,
+                });
             }
             else if (target.executor === 'nx:run-commands' &&
-                target.options?.command) {
+                configuration.options?.command) {
                 targetCommands.push({
-                    command: target.options.command,
+                    command: configuration.options.command,
                     target: targetName,
+                    configuration: configurationName,
                 });
             }
-            if (!target.configurations) {
-                continue;
-            }
-            for (const [configurationName, configuration] of Object.entries(target.configurations)) {
-                if (configuration.command) {
-                    targetCommands.push({
-                        command: configuration.command,
-                        target: targetName,
-                        configuration: configurationName,
-                    });
-                }
-                else if (target.executor === 'nx:run-commands' &&
-                    configuration.options?.command) {
-                    targetCommands.push({
-                        command: configuration.options.command,
-                        target: targetName,
-                        configuration: configurationName,
-                    });
-                }
-            }
         }
     }
     return targetCommands;
 }
-function getProjectRootFromConfigFile(file) {
-    let projectRoot = (0, path_1.dirname)(file);
-    if ((0, path_1.basename)(projectRoot) === '.storybook') {
-        projectRoot = (0, path_1.dirname)(projectRoot);
+function generateCombinations(input) {
+    // This is reversed so that combinations have the first defined property updated first
+    const keys = Object.keys(input).reverse();
+    return _generateCombinations(Object.values(input).reverse()).map((combination) => {
+        const result = {};
+        combination.reverse().forEach((combo, i) => {
+            result[keys[keys.length - i - 1]] = combo;
+        });
+        return result;
+    });
+}
+exports.generateCombinations = generateCombinations;
+/**
+ * Generate all possible combinations of a 2-dimensional array.
+ *
+ * Useful for generating all possible combinations of options for a plugin
+ */
+function _generateCombinations(input) {
+    if (input.length === 0) {
+        return [[]];
+    }
+    else {
+        const [first, ...rest] = input;
+        const partialCombinations = _generateCombinations(rest);
+        return first.flatMap((value) => partialCombinations.map((combination) => [value, ...combination]));
     }
-    return projectRoot;
 }

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

@@ -1,2 +0,0 @@
-import type { CreateNodes, Tree } from 'nx/src/devkit-exports';
-export declare function updatePackageScripts(tree: Tree, createNodesTuple: CreateNodes): Promise<void>;