nx 19.6.0-canary.20240806-a3869a8 → 19.6.0-canary.20240808-333ab77

package/src/command-line/release/version.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.releaseVersionCLIHandler = exports.validReleaseVersionPrefixes = exports.deriveNewSemverVersion = void 0;
-exports.releaseVersion = releaseVersion;
+exports.createAPI = createAPI;
 const chalk = require("chalk");
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
@@ -17,11 +17,13 @@ const workspace_root_1 = require("../../utils/workspace-root");
 const generate_1 = require("../generate/generate");
 const generator_utils_1 = require("../generate/generator-utils");
 const config_1 = require("./config/config");
+const deep_merge_json_1 = require("./config/deep-merge-json");
 const filter_release_groups_1 = require("./config/filter-release-groups");
 const version_plans_1 = require("./config/version-plans");
 const batch_projects_by_generator_config_1 = require("./utils/batch-projects-by-generator-config");
 const git_1 = require("./utils/git");
 const print_changes_1 = require("./utils/print-changes");
+const print_config_1 = require("./utils/print-config");
 const resolve_nx_json_error_message_1 = require("./utils/resolve-nx-json-error-message");
 const shared_1 = require("./utils/shared");
 const LARGE_BUFFER = 1024 * 1000000;
@@ -29,78 +31,180 @@ const LARGE_BUFFER = 1024 * 1000000;
 var semver_1 = require("./utils/semver");
 Object.defineProperty(exports, "deriveNewSemverVersion", { enumerable: true, get: function () { return semver_1.deriveNewSemverVersion; } });
 exports.validReleaseVersionPrefixes = ['auto', '', '~', '^', '='];
-const releaseVersionCLIHandler = (args) => (0, params_1.handleErrors)(args.verbose, () => releaseVersion(args));
+const releaseVersionCLIHandler = (args) => (0, params_1.handleErrors)(args.verbose, () => createAPI({})(args));
 exports.releaseVersionCLIHandler = releaseVersionCLIHandler;
-/**
- * NOTE: This function is also exported for programmatic usage and forms part of the public API
- * of Nx. We intentionally do not wrap the implementation with handleErrors because users need
- * to have control over their own error handling when using the API.
- */
-async function releaseVersion(args) {
-    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
-    const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
-    const nxJson = (0, nx_json_1.readNxJson)();
-    if (args.verbose) {
-        process.env.NX_VERBOSE_LOGGING = 'true';
-    }
-    // Apply default configuration to any optional user configuration
-    const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), nxJson.release);
-    if (configError) {
-        return await (0, config_1.handleNxReleaseConfigError)(configError);
-    }
-    // The nx release top level command will always override these three git args. This is how we can tell
-    // if the top level release command was used or if the user is using the changelog subcommand.
-    // If the user explicitly overrides these args, then it doesn't matter if the top level config is set,
-    // as all of the git options would be overridden anyway.
-    if ((args.gitCommit === undefined ||
-        args.gitTag === undefined ||
-        args.stageChanges === undefined) &&
-        nxJson.release?.git) {
-        const nxJsonMessage = await (0, resolve_nx_json_error_message_1.resolveNxJsonConfigErrorMessage)([
-            'release',
-            'git',
-        ]);
-        output_1.output.error({
-            title: `The "release.git" property in nx.json may not be used with the "nx release version" subcommand or programmatic API. Instead, configure git options for subcommands directly with "release.version.git" and "release.changelog.git".`,
-            bodyLines: [nxJsonMessage],
-        });
-        process.exit(1);
-    }
-    const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, args.projects, args.groups);
-    if (filterError) {
-        output_1.output.error(filterError);
-        process.exit(1);
-    }
-    const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
-    (0, version_plans_1.setVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
-    if (args.deleteVersionPlans === undefined) {
-        // default to not delete version plans after versioning as they may be needed for changelog generation
-        args.deleteVersionPlans = false;
-    }
-    runPreVersionCommand(nxReleaseConfig.version.preVersionCommand, {
-        dryRun: args.dryRun,
-        verbose: args.verbose,
-    });
-    const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose);
-    const versionData = {};
-    const commitMessage = args.gitCommitMessage || nxReleaseConfig.version.git.commitMessage;
-    const generatorCallbacks = [];
+function createAPI(overrideReleaseConfig) {
     /**
-     * additionalChangedFiles are files which need to be updated as a side-effect of versioning (such as package manager lock files),
-     * and need to get staged and committed as part of the existing commit, if applicable.
+     * NOTE: This function is also exported for programmatic usage and forms part of the public API
+     * of Nx. We intentionally do not wrap the implementation with handleErrors because users need
+     * to have control over their own error handling when using the API.
      */
-    const additionalChangedFiles = new Set();
-    const additionalDeletedFiles = new Set();
-    if (args.projects?.length) {
+    return async function releaseVersion(args) {
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+        const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+        const nxJson = (0, nx_json_1.readNxJson)();
+        const userProvidedReleaseConfig = (0, deep_merge_json_1.deepMergeJson)(nxJson.release ?? {}, overrideReleaseConfig ?? {});
+        if (args.verbose) {
+            process.env.NX_VERBOSE_LOGGING = 'true';
+        }
+        // Apply default configuration to any optional user configuration
+        const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), userProvidedReleaseConfig);
+        if (configError) {
+            return await (0, config_1.handleNxReleaseConfigError)(configError);
+        }
+        // --print-config exits directly as it is not designed to be combined with any other programmatic operations
+        if (args.printConfig) {
+            return (0, print_config_1.printConfigAndExit)({
+                userProvidedReleaseConfig,
+                nxReleaseConfig,
+                isDebug: args.printConfig === 'debug',
+            });
+        }
+        // The nx release top level command will always override these three git args. This is how we can tell
+        // if the top level release command was used or if the user is using the changelog subcommand.
+        // If the user explicitly overrides these args, then it doesn't matter if the top level config is set,
+        // as all of the git options would be overridden anyway.
+        if ((args.gitCommit === undefined ||
+            args.gitTag === undefined ||
+            args.stageChanges === undefined) &&
+            userProvidedReleaseConfig.git) {
+            const nxJsonMessage = await (0, resolve_nx_json_error_message_1.resolveNxJsonConfigErrorMessage)([
+                'release',
+                'git',
+            ]);
+            output_1.output.error({
+                title: `The "release.git" property in nx.json may not be used with the "nx release version" subcommand or programmatic API. Instead, configure git options for subcommands directly with "release.version.git" and "release.changelog.git".`,
+                bodyLines: [nxJsonMessage],
+            });
+            process.exit(1);
+        }
+        const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, args.projects, args.groups);
+        if (filterError) {
+            output_1.output.error(filterError);
+            process.exit(1);
+        }
+        const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
+        (0, version_plans_1.setVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
+        if (args.deleteVersionPlans === undefined) {
+            // default to not delete version plans after versioning as they may be needed for changelog generation
+            args.deleteVersionPlans = false;
+        }
+        runPreVersionCommand(nxReleaseConfig.version.preVersionCommand, {
+            dryRun: args.dryRun,
+            verbose: args.verbose,
+        });
+        const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose);
+        const versionData = {};
+        const commitMessage = args.gitCommitMessage || nxReleaseConfig.version.git.commitMessage;
+        const generatorCallbacks = [];
+        /**
+         * additionalChangedFiles are files which need to be updated as a side-effect of versioning (such as package manager lock files),
+         * and need to get staged and committed as part of the existing commit, if applicable.
+         */
+        const additionalChangedFiles = new Set();
+        const additionalDeletedFiles = new Set();
+        if (args.projects?.length) {
+            /**
+             * Run versioning for all remaining release groups and filtered projects within them
+             */
+            for (const releaseGroup of releaseGroups) {
+                const releaseGroupName = releaseGroup.name;
+                const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+                const projectBatches = (0, batch_projects_by_generator_config_1.batchProjectsByGeneratorConfig)(projectGraph, releaseGroup, 
+                // Only batch based on the filtered projects within the release group
+                releaseGroupProjectNames);
+                for (const [generatorConfigString, projectNames,] of projectBatches.entries()) {
+                    const [generatorName, generatorOptions] = JSON.parse(generatorConfigString);
+                    // Resolve the generator for the batch and run versioning on the projects within the batch
+                    const generatorData = resolveGeneratorData({
+                        ...extractGeneratorCollectionAndName(`batch "${JSON.stringify(projectNames)}" for release-group "${releaseGroupName}"`, generatorName),
+                        configGeneratorOptions: generatorOptions,
+                        // all project data from the project graph (not to be confused with projectNamesToRunVersionOn)
+                        projects,
+                    });
+                    const generatorCallback = await runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, args.generatorOptionsOverrides, projectNames, releaseGroup, versionData, nxReleaseConfig.conventionalCommits);
+                    // Capture the callback so that we can run it after flushing the changes to disk
+                    generatorCallbacks.push(async () => {
+                        const result = await generatorCallback(tree, {
+                            dryRun: !!args.dryRun,
+                            verbose: !!args.verbose,
+                            generatorOptions: {
+                                ...generatorOptions,
+                                ...args.generatorOptionsOverrides,
+                            },
+                        });
+                        const { changedFiles, deletedFiles } = parseGeneratorCallbackResult(result);
+                        changedFiles.forEach((f) => additionalChangedFiles.add(f));
+                        deletedFiles.forEach((f) => additionalDeletedFiles.add(f));
+                    });
+                }
+            }
+            // Resolve any git tags as early as possible so that we can hard error in case of any duplicates before reaching the actual git command
+            const gitTagValues = args.gitTag ?? nxReleaseConfig.version.git.tag
+                ? (0, shared_1.createGitTagValues)(releaseGroups, releaseGroupToFilteredProjects, versionData)
+                : [];
+            (0, shared_1.handleDuplicateGitTags)(gitTagValues);
+            printAndFlushChanges(tree, !!args.dryRun);
+            for (const generatorCallback of generatorCallbacks) {
+                await generatorCallback();
+            }
+            const changedFiles = [
+                ...tree.listChanges().map((f) => f.path),
+                ...additionalChangedFiles,
+            ];
+            // No further actions are necessary in this scenario (e.g. if conventional commits detected no changes)
+            if (!changedFiles.length) {
+                return {
+                    // An overall workspace version cannot be relevant when filtering to independent projects
+                    workspaceVersion: undefined,
+                    projectsVersionData: versionData,
+                };
+            }
+            if (args.gitCommit ?? nxReleaseConfig.version.git.commit) {
+                await (0, shared_1.commitChanges)({
+                    changedFiles,
+                    deletedFiles: Array.from(additionalDeletedFiles),
+                    isDryRun: !!args.dryRun,
+                    isVerbose: !!args.verbose,
+                    gitCommitMessages: (0, shared_1.createCommitMessageValues)(releaseGroups, releaseGroupToFilteredProjects, versionData, commitMessage),
+                    gitCommitArgs: args.gitCommitArgs || nxReleaseConfig.version.git.commitArgs,
+                });
+            }
+            else if (args.stageChanges ??
+                nxReleaseConfig.version.git.stageChanges) {
+                output_1.output.logSingleLine(`Staging changed files with git`);
+                await (0, git_1.gitAdd)({
+                    changedFiles,
+                    dryRun: args.dryRun,
+                    verbose: args.verbose,
+                });
+            }
+            if (args.gitTag ?? nxReleaseConfig.version.git.tag) {
+                output_1.output.logSingleLine(`Tagging commit with git`);
+                for (const tag of gitTagValues) {
+                    await (0, git_1.gitTag)({
+                        tag,
+                        message: args.gitTagMessage || nxReleaseConfig.version.git.tagMessage,
+                        additionalArgs: args.gitTagArgs || nxReleaseConfig.version.git.tagArgs,
+                        dryRun: args.dryRun,
+                        verbose: args.verbose,
+                    });
+                }
+            }
+            return {
+                // An overall workspace version cannot be relevant when filtering to independent projects
+                workspaceVersion: undefined,
+                projectsVersionData: versionData,
+            };
+        }
         /**
-         * Run versioning for all remaining release groups and filtered projects within them
+         * Run versioning for all remaining release groups
          */
         for (const releaseGroup of releaseGroups) {
             const releaseGroupName = releaseGroup.name;
-            const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
             const projectBatches = (0, batch_projects_by_generator_config_1.batchProjectsByGeneratorConfig)(projectGraph, releaseGroup, 
-            // Only batch based on the filtered projects within the release group
-            releaseGroupProjectNames);
+            // Batch based on all projects within the release group
+            releaseGroup.projects);
             for (const [generatorConfigString, projectNames,] of projectBatches.entries()) {
                 const [generatorName, generatorOptions] = JSON.parse(generatorConfigString);
                 // Resolve the generator for the batch and run versioning on the projects within the batch
@@ -136,6 +240,15 @@ async function releaseVersion(args) {
         for (const generatorCallback of generatorCallbacks) {
             await generatorCallback();
         }
+        // Only applicable when there is a single release group with a fixed relationship
+        let workspaceVersion = undefined;
+        if (releaseGroups.length === 1) {
+            const releaseGroup = releaseGroups[0];
+            if (releaseGroup.projectsRelationship === 'fixed') {
+                const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+                workspaceVersion = versionData[releaseGroupProjectNames[0]].newVersion; // all projects have the same version so we can just grab the first
+            }
+        }
         const changedFiles = [
             ...tree.listChanges().map((f) => f.path),
             ...additionalChangedFiles,
@@ -144,8 +257,7 @@ async function releaseVersion(args) {
         // No further actions are necessary in this scenario (e.g. if conventional commits detected no changes)
         if (!changedFiles.length && !deletedFiles.length) {
             return {
-                // An overall workspace version cannot be relevant when filtering to independent projects
-                workspaceVersion: undefined,
+                workspaceVersion,
                 projectsVersionData: versionData,
             };
         }
@@ -180,108 +292,10 @@ async function releaseVersion(args) {
                 });
             }
         }
-        return {
-            // An overall workspace version cannot be relevant when filtering to independent projects
-            workspaceVersion: undefined,
-            projectsVersionData: versionData,
-        };
-    }
-    /**
-     * Run versioning for all remaining release groups
-     */
-    for (const releaseGroup of releaseGroups) {
-        const releaseGroupName = releaseGroup.name;
-        const projectBatches = (0, batch_projects_by_generator_config_1.batchProjectsByGeneratorConfig)(projectGraph, releaseGroup, 
-        // Batch based on all projects within the release group
-        releaseGroup.projects);
-        for (const [generatorConfigString, projectNames,] of projectBatches.entries()) {
-            const [generatorName, generatorOptions] = JSON.parse(generatorConfigString);
-            // Resolve the generator for the batch and run versioning on the projects within the batch
-            const generatorData = resolveGeneratorData({
-                ...extractGeneratorCollectionAndName(`batch "${JSON.stringify(projectNames)}" for release-group "${releaseGroupName}"`, generatorName),
-                configGeneratorOptions: generatorOptions,
-                // all project data from the project graph (not to be confused with projectNamesToRunVersionOn)
-                projects,
-            });
-            const generatorCallback = await runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, args.generatorOptionsOverrides, projectNames, releaseGroup, versionData, nxReleaseConfig.conventionalCommits);
-            // Capture the callback so that we can run it after flushing the changes to disk
-            generatorCallbacks.push(async () => {
-                const result = await generatorCallback(tree, {
-                    dryRun: !!args.dryRun,
-                    verbose: !!args.verbose,
-                    generatorOptions: {
-                        ...generatorOptions,
-                        ...args.generatorOptionsOverrides,
-                    },
-                });
-                const { changedFiles, deletedFiles } = parseGeneratorCallbackResult(result);
-                changedFiles.forEach((f) => additionalChangedFiles.add(f));
-                deletedFiles.forEach((f) => additionalDeletedFiles.add(f));
-            });
-        }
-    }
-    // Resolve any git tags as early as possible so that we can hard error in case of any duplicates before reaching the actual git command
-    const gitTagValues = args.gitTag ?? nxReleaseConfig.version.git.tag
-        ? (0, shared_1.createGitTagValues)(releaseGroups, releaseGroupToFilteredProjects, versionData)
-        : [];
-    (0, shared_1.handleDuplicateGitTags)(gitTagValues);
-    printAndFlushChanges(tree, !!args.dryRun);
-    for (const generatorCallback of generatorCallbacks) {
-        await generatorCallback();
-    }
-    // Only applicable when there is a single release group with a fixed relationship
-    let workspaceVersion = undefined;
-    if (releaseGroups.length === 1) {
-        const releaseGroup = releaseGroups[0];
-        if (releaseGroup.projectsRelationship === 'fixed') {
-            const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
-            workspaceVersion = versionData[releaseGroupProjectNames[0]].newVersion; // all projects have the same version so we can just grab the first
-        }
-    }
-    const changedFiles = [
-        ...tree.listChanges().map((f) => f.path),
-        ...additionalChangedFiles,
-    ];
-    // No further actions are necessary in this scenario (e.g. if conventional commits detected no changes)
-    if (!changedFiles.length) {
         return {
             workspaceVersion,
             projectsVersionData: versionData,
         };
-    }
-    if (args.gitCommit ?? nxReleaseConfig.version.git.commit) {
-        await (0, shared_1.commitChanges)({
-            changedFiles,
-            deletedFiles: Array.from(additionalDeletedFiles),
-            isDryRun: !!args.dryRun,
-            isVerbose: !!args.verbose,
-            gitCommitMessages: (0, shared_1.createCommitMessageValues)(releaseGroups, releaseGroupToFilteredProjects, versionData, commitMessage),
-            gitCommitArgs: args.gitCommitArgs || nxReleaseConfig.version.git.commitArgs,
-        });
-    }
-    else if (args.stageChanges ?? nxReleaseConfig.version.git.stageChanges) {
-        output_1.output.logSingleLine(`Staging changed files with git`);
-        await (0, git_1.gitAdd)({
-            changedFiles,
-            dryRun: args.dryRun,
-            verbose: args.verbose,
-        });
-    }
-    if (args.gitTag ?? nxReleaseConfig.version.git.tag) {
-        output_1.output.logSingleLine(`Tagging commit with git`);
-        for (const tag of gitTagValues) {
-            await (0, git_1.gitTag)({
-                tag,
-                message: args.gitTagMessage || nxReleaseConfig.version.git.tagMessage,
-                additionalArgs: args.gitTagArgs || nxReleaseConfig.version.git.tagArgs,
-                dryRun: args.dryRun,
-                verbose: args.verbose,
-            });
-        }
-    }
-    return {
-        workspaceVersion,
-        projectsVersionData: versionData,
     };
 }
 function appendVersionData(existingVersionData, newVersionData) {

package/src/config/nx-json.d.ts

@@ -145,7 +145,7 @@ export interface NxReleaseConventionalCommitsConfiguration {
         } | boolean;
     } | boolean>;
 }
-interface NxReleaseConfiguration {
+export interface NxReleaseConfiguration {
     /**
      * Shorthand for amending the projects which will be included in the implicit default release group (all projects by default).
      * @note Only one of `projects` or `groups` can be specified, the cannot be used together.
@@ -379,6 +379,11 @@ export interface NxJsonConfiguration<T = '*' | string[]> {
      * To use a different runner that accepts an access token, define it in {@link tasksRunnerOptions}
      */
     nxCloudAccessToken?: string;
+    /**
+     * If specified Nx will use nx-cloud by default with the given cloud id.
+     * To use a different runner that accepts a cloud id, define it in {@link tasksRunnerOptions}
+     */
+    nxCloudId?: string;
     /**
      * Specifies the url pointing to an instance of nx cloud. Used for remote
      * caching and displaying run links.

package/src/devkit-internals.d.ts

@@ -8,8 +8,8 @@ export { getExecutorInformation } from './command-line/run/executor-utils';
 export { readNxJson as readNxJsonFromDisk } from './config/nx-json';
 export { calculateDefaultProjectName } from './config/calculate-default-project-name';
 export { retrieveProjectConfigurationsWithAngularProjects } from './project-graph/utils/retrieve-workspace-files';
-export { mergeTargetConfigurations, findMatchingConfigFiles, } from './project-graph/utils/project-configuration-utils';
-export { readProjectConfigurationsFromRootMap } from './project-graph/utils/project-configuration-utils';
+export { mergeTargetConfigurations } from './project-graph/utils/project-configuration-utils';
+export { readProjectConfigurationsFromRootMap, findMatchingConfigFiles, } from './project-graph/utils/project-configuration-utils';
 export { splitTarget } from './utils/split-target';
 export { combineOptionsForExecutor } from './utils/params';
 export { sortObjectByKeys } from './utils/object-sort';

package/src/devkit-internals.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.interpolate = exports.registerTsProject = exports.LoadedNxPlugin = exports.retrieveProjectConfigurations = exports.findProjectForPath = exports.createProjectRootMappingsFromProjectConfigurations = exports.hashWithWorkspaceContext = exports.hashObject = exports.splitByColons = exports.readModulePackageJson = exports.stripIndent = exports.sortObjectByKeys = exports.combineOptionsForExecutor = exports.splitTarget = exports.readProjectConfigurationsFromRootMap = exports.findMatchingConfigFiles = exports.mergeTargetConfigurations = exports.retrieveProjectConfigurationsWithAngularProjects = exports.calculateDefaultProjectName = exports.readNxJsonFromDisk = exports.getExecutorInformation = exports.createTempNpmDirectory = void 0;
+exports.interpolate = exports.registerTsProject = exports.LoadedNxPlugin = exports.retrieveProjectConfigurations = exports.findProjectForPath = exports.createProjectRootMappingsFromProjectConfigurations = exports.hashWithWorkspaceContext = exports.hashObject = exports.splitByColons = exports.readModulePackageJson = exports.stripIndent = exports.sortObjectByKeys = exports.combineOptionsForExecutor = exports.splitTarget = exports.findMatchingConfigFiles = exports.readProjectConfigurationsFromRootMap = exports.mergeTargetConfigurations = exports.retrieveProjectConfigurationsWithAngularProjects = exports.calculateDefaultProjectName = exports.readNxJsonFromDisk = exports.getExecutorInformation = exports.createTempNpmDirectory = void 0;
 const tslib_1 = require("tslib");
 /**
  * Note to developers: STOP! These exports are available via requireNx in @nx/devkit.
@@ -19,9 +19,9 @@ var retrieve_workspace_files_1 = require("./project-graph/utils/retrieve-workspa
 Object.defineProperty(exports, "retrieveProjectConfigurationsWithAngularProjects", { enumerable: true, get: function () { return retrieve_workspace_files_1.retrieveProjectConfigurationsWithAngularProjects; } });
 var project_configuration_utils_1 = require("./project-graph/utils/project-configuration-utils");
 Object.defineProperty(exports, "mergeTargetConfigurations", { enumerable: true, get: function () { return project_configuration_utils_1.mergeTargetConfigurations; } });
-Object.defineProperty(exports, "findMatchingConfigFiles", { enumerable: true, get: function () { return project_configuration_utils_1.findMatchingConfigFiles; } });
 var project_configuration_utils_2 = require("./project-graph/utils/project-configuration-utils");
 Object.defineProperty(exports, "readProjectConfigurationsFromRootMap", { enumerable: true, get: function () { return project_configuration_utils_2.readProjectConfigurationsFromRootMap; } });
+Object.defineProperty(exports, "findMatchingConfigFiles", { enumerable: true, get: function () { return project_configuration_utils_2.findMatchingConfigFiles; } });
 var split_target_1 = require("./utils/split-target");
 Object.defineProperty(exports, "splitTarget", { enumerable: true, get: function () { return split_target_1.splitTarget; } });
 var params_1 = require("./utils/params");

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.d.ts

@@ -9,4 +9,5 @@ export interface ConnectToNxCloudOptions {
     directory?: string;
 }
 export declare function connectToNxCloud(tree: Tree, schema: ConnectToNxCloudOptions, nxJson?: NxJsonConfiguration<string[] | "*">): Promise<string>;
-export default connectToNxCloud;
+declare function connectToNxCloudGenerator(tree: Tree, options: ConnectToNxCloudOptions): Promise<void>;
+export default connectToNxCloudGenerator;

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.js

@@ -42,7 +42,7 @@ function getNxInitDate() {
         return null;
     }
 }
-async function createNxCloudWorkspace(workspaceName, installationSource, nxInitDate) {
+async function createNxCloudWorkspaceV1(workspaceName, installationSource, nxInitDate) {
     const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
     const response = await require('axios').post(`${apiUrl}/nx-cloud/create-org-and-workspace`, {
         workspaceName,
@@ -54,6 +54,18 @@ async function createNxCloudWorkspace(workspaceName, installationSource, nxInitD
     }
     return response.data;
 }
+async function createNxCloudWorkspaceV2(workspaceName, installationSource, nxInitDate) {
+    const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
+    const response = await require('axios').post(`${apiUrl}/nx-cloud/v2/create-org-and-workspace`, {
+        workspaceName,
+        installationSource,
+        nxInitDate,
+    });
+    if (response.data.message) {
+        throw new Error(response.data.message);
+    }
+    return response.data;
+}
 async function printSuccessMessage(token, installationSource, usesGithub) {
     const connectCloudUrl = await (0, url_shorten_1.createNxCloudOnboardingURL)(installationSource, token, usesGithub);
     output_1.output.note({
@@ -69,7 +81,7 @@ async function printSuccessMessage(token, installationSource, usesGithub) {
     });
     return connectCloudUrl;
 }
-function addNxCloudOptionsToNxJson(tree, token, directory = tree.root) {
+function addNxCloudOptionsToNxJson(tree, token, directory = '') {
     const nxJsonPath = (0, path_1.join)(directory, 'nx.json');
     if (tree.exists(nxJsonPath)) {
         (0, json_1.updateJson)(tree, (0, path_1.join)(directory, 'nx.json'), (nxJson) => {
@@ -82,6 +94,19 @@ function addNxCloudOptionsToNxJson(tree, token, directory = tree.root) {
         });
     }
 }
+function addNxCloudIdToNxJson(tree, nxCloudId, directory = tree.root) {
+    const nxJsonPath = (0, path_1.join)(directory, 'nx.json');
+    if (tree.exists(nxJsonPath)) {
+        (0, json_1.updateJson)(tree, (0, path_1.join)(directory, 'nx.json'), (nxJson) => {
+            const overrideUrl = process.env.NX_CLOUD_API || process.env.NRWL_API;
+            if (overrideUrl) {
+                nxJson.nxCloudUrl = overrideUrl;
+            }
+            nxJson.nxCloudId = nxCloudId;
+            return nxJson;
+        });
+    }
+}
 async function connectToNxCloud(tree, schema, nxJson = (0, nx_json_1.readNxJson)(tree)) {
     schema.installationSource ??= 'user';
     if (nxJson?.neverConnectToCloud) {
@@ -90,17 +115,31 @@ async function connectToNxCloud(tree, schema, nxJson = (0, nx_json_1.readNxJson)
     }
     else {
         const usesGithub = schema.github ?? (await (0, url_shorten_1.repoUsesGithub)(schema.github));
-        let responseFromCreateNxCloudWorkspace;
+        let responseFromCreateNxCloudWorkspaceV1;
+        let responseFromCreateNxCloudWorkspaceV2;
         // do NOT create Nx Cloud token (createNxCloudWorkspace)
         // if user is using github and is running nx-connect
         if (!(usesGithub && schema.installationSource === 'nx-connect')) {
-            responseFromCreateNxCloudWorkspace = await createNxCloudWorkspace(getRootPackageName(tree), schema.installationSource, getNxInitDate());
-            addNxCloudOptionsToNxJson(tree, responseFromCreateNxCloudWorkspace?.token, schema.directory);
-            await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
-                silent: schema.hideFormatLogs,
-            });
-            return responseFromCreateNxCloudWorkspace.token;
+            if (process.env.NX_ENABLE_LOGIN === 'true') {
+                responseFromCreateNxCloudWorkspaceV2 = await createNxCloudWorkspaceV2(getRootPackageName(tree), schema.installationSource, getNxInitDate());
+                addNxCloudIdToNxJson(tree, responseFromCreateNxCloudWorkspaceV2?.nxCloudId, schema.directory);
+                await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
+                    silent: schema.hideFormatLogs,
+                });
+                return responseFromCreateNxCloudWorkspaceV2.nxCloudId;
+            }
+            else {
+                responseFromCreateNxCloudWorkspaceV1 = await createNxCloudWorkspaceV1(getRootPackageName(tree), schema.installationSource, getNxInitDate());
+                addNxCloudOptionsToNxJson(tree, responseFromCreateNxCloudWorkspaceV1?.token, schema.directory);
+                await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
+                    silent: schema.hideFormatLogs,
+                });
+                return responseFromCreateNxCloudWorkspaceV1.token;
+            }
         }
     }
 }
-exports.default = connectToNxCloud;
+async function connectToNxCloudGenerator(tree, options) {
+    await connectToNxCloud(tree, options);
+}
+exports.default = connectToNxCloudGenerator;

package/src/nx-cloud/nx-cloud-tasks-runner-shell.d.ts

@@ -11,5 +11,6 @@ export interface CloudTaskRunnerOptions extends DefaultTasksRunnerOptions {
     url?: string;
     useLightClient?: boolean;
     clientVersion?: string;
+    nxCloudId?: string;
 }
 export declare const nxCloudTasksRunnerShell: TasksRunner<CloudTaskRunnerOptions>;

package/src/nx-cloud/utilities/axios.js

@@ -8,8 +8,15 @@ function createApiAxiosInstance(options) {
     let axiosConfigBuilder = (axiosConfig) => axiosConfig;
     const baseUrl = process.env.NX_CLOUD_API || options.url || 'https://cloud.nx.app';
     const accessToken = environment_1.ACCESS_TOKEN ? environment_1.ACCESS_TOKEN : options.accessToken;
-    if (!accessToken) {
-        throw new Error(`Unable to authenticate. Either define accessToken in nx.json or set the NX_CLOUD_ACCESS_TOKEN env variable.`);
+    const nxCloudId = options.nxCloudId;
+    // TODO(lourw): Update message with NxCloudId once it is supported
+    if (!accessToken && !nxCloudId) {
+        if (process.env.NX_ENABLE_LOGIN === 'true' && !nxCloudId) {
+            throw new Error(`Unable to authenticate. Please connect your workspace to Nx Cloud to define a valid Nx Cloud Id. If you are in a CI context, please set the NX_CLOUD_ACCESS_TOKEN environment variable or define an access token in your nx.json.`);
+        }
+        else {
+            throw new Error(`Unable to authenticate. Either define accessToken in nx.json or set the NX_CLOUD_ACCESS_TOKEN env variable. If you do not want to use Nx Cloud for this command, either set NX_NO_CLOUD=true, or pass the --no-cloud flag.`);
+        }
     }
     if (options.customProxyConfigPath) {
         const { nxCloudProxyConfig } = require((0, path_1.join)(process.cwd(), options.customProxyConfigPath));

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -141,9 +141,14 @@ class TargetProjectLocator {
             }
             const version = (0, semver_1.clean)(externalPackageJson.version);
             const npmProjectKey = `npm:${externalPackageJson.name}@${version}`;
-            const matchingExternalNode = this.npmProjects[npmProjectKey];
+            let matchingExternalNode = this.npmProjects[npmProjectKey];
             if (!matchingExternalNode) {
-                return null;
+                // check if it's a package alias, where the resolved package key is used as the version
+                const aliasNpmProjectKey = `npm:${packageName}@${npmProjectKey}`;
+                matchingExternalNode = this.npmProjects[aliasNpmProjectKey];
+                if (!matchingExternalNode) {
+                    return null;
+                }
             }
             this.npmResolutionCache.set(npmImportForProject, matchingExternalNode.name);
             return matchingExternalNode.name;

package/src/plugins/package-json/create-nodes.js

@@ -90,7 +90,15 @@ function buildProjectConfigurationFromPackageJson(packageJson, workspaceRoot, pa
     const siblingProjectJson = tryReadJson((0, node_path_1.join)(workspaceRoot, projectRoot, 'project.json'));
     if (siblingProjectJson) {
         for (const target of Object.keys(siblingProjectJson?.targets ?? {})) {
-            delete packageJson.scripts?.[target];
+            const { executor, command, options } = siblingProjectJson.targets[target];
+            if (
+            // will use run-commands, different target
+            command ||
+                // Either uses a different executor or runs a different script
+                (executor &&
+                    (executor !== 'nx:run-script' || options?.script !== target))) {
+                delete packageJson.scripts?.[target];
+            }
         }
     }
     if (!packageJson.name && projectRoot === '.') {