nx 20.8.4 → 22.7.7

package/dist/src/command-line/release/publish.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releasePublishCLIHandler = void 0;
+exports.createAPI = createAPI;
+const nx_json_1 = require("../../config/nx-json");
+const tree_1 = require("../../generators/tree");
+const native_1 = require("../../native");
+const file_map_utils_1 = require("../../project-graph/file-map-utils");
+const tasks_execution_hooks_1 = require("../../project-graph/plugins/tasks-execution-hooks");
+const project_graph_1 = require("../../project-graph/project-graph");
+const run_command_1 = require("../../tasks-runner/run-command");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const handle_errors_1 = require("../../utils/handle-errors");
+const output_1 = require("../../utils/output");
+const project_graph_utils_1 = require("../../utils/project-graph-utils");
+const workspace_root_1 = require("../../utils/workspace-root");
+const graph_1 = require("../graph/graph");
+const config_1 = require("./config/config");
+const deep_merge_json_1 = require("./config/deep-merge-json");
+const print_config_1 = require("./utils/print-config");
+const release_graph_1 = require("./utils/release-graph");
+const releasePublishCLIHandler = (args) => (0, handle_errors_1.handleErrors)(args.verbose, async () => {
+    const publishProjectsResult = await createAPI({}, false)(args);
+    // If all projects are published successfully, return 0, otherwise return 1
+    return Object.values(publishProjectsResult).every((result) => result.code === 0)
+        ? 0
+        : 1;
+});
+exports.releasePublishCLIHandler = releasePublishCLIHandler;
+function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
+    /**
+     * 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.
+     */
+    return async function releasePublish(args) {
+        /**
+         * When used via the CLI, the args object will contain a __overrides_unparsed__ property that is
+         * important for invoking the relevant executor behind the scenes.
+         *
+         * We intentionally do not include that in the function signature, however, so as not to cause
+         * confusing errors for programmatic consumers of this function.
+         */
+        const _args = args;
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+        const nxJson = (0, nx_json_1.readNxJson)();
+        const overriddenConfig = overrideReleaseConfig ?? {};
+        const userProvidedReleaseConfig = ignoreNxJsonConfig
+            ? overriddenConfig
+            : (0, deep_merge_json_1.deepMergeJson)(nxJson.release ?? {}, overriddenConfig);
+        // 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',
+            });
+        }
+        // Use pre-built release graph if provided, otherwise create a new one
+        const releaseGraph = args.releaseGraph ||
+            (await (0, release_graph_1.createReleaseGraph)({
+                // Only build the tree if no existing graph, it's only needed for this
+                tree: new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose),
+                projectGraph,
+                nxReleaseConfig,
+                filters: {
+                    projects: _args.projects,
+                    groups: _args.groups,
+                },
+                firstRelease: args.firstRelease,
+                verbose: args.verbose,
+                // Publish doesn't need to resolve current versions during graph construction
+                skipVersionResolution: true,
+            }));
+        // Display filter log if filters were applied
+        if (releaseGraph.filterLog &&
+            process.env.NX_RELEASE_INTERNAL_SUPPRESS_FILTER_LOG !== 'true') {
+            output_1.output.note(releaseGraph.filterLog);
+        }
+        /**
+         * If the user is filtering to a subset of projects or groups, we should not run the publish task
+         * for dependencies, because that could cause projects outset of the filtered set to be published.
+         */
+        const shouldExcludeTaskDependencies = _args.projects?.length > 0 ||
+            _args.groups?.length > 0 ||
+            args.excludeTaskDependencies;
+        let overallPublishProjectsResult = {};
+        if (args.projects?.length) {
+            /**
+             * Run publishing for all remaining release groups and filtered projects within them
+             * in topological order
+             */
+            for (const releaseGroupName of releaseGraph.sortedReleaseGroups) {
+                const releaseGroup = releaseGraph.releaseGroups.find((g) => g.name === releaseGroupName);
+                if (!releaseGroup) {
+                    // Release group was filtered out, skip
+                    continue;
+                }
+                const publishProjectsResult = await runPublishOnProjects(_args, projectGraph, nxJson, Array.from(releaseGraph.releaseGroupToFilteredProjects.get(releaseGroup)), {
+                    excludeTaskDependencies: shouldExcludeTaskDependencies,
+                    loadDotEnvFiles: process.env.NX_LOAD_DOT_ENV_FILES !== 'false',
+                });
+                overallPublishProjectsResult = {
+                    ...overallPublishProjectsResult,
+                    ...publishProjectsResult,
+                };
+            }
+            return overallPublishProjectsResult;
+        }
+        /**
+         * Run publishing for all remaining release groups
+         */
+        for (const releaseGroupName of releaseGraph.sortedReleaseGroups) {
+            const releaseGroup = releaseGraph.releaseGroups.find((g) => g.name === releaseGroupName);
+            if (!releaseGroup) {
+                // Release group was filtered out, skip
+                continue;
+            }
+            const publishProjectsResult = await runPublishOnProjects(_args, projectGraph, nxJson, releaseGroup.projects, {
+                excludeTaskDependencies: shouldExcludeTaskDependencies,
+                loadDotEnvFiles: process.env.NX_LOAD_DOT_ENV_FILES !== 'false',
+            });
+            overallPublishProjectsResult = {
+                ...overallPublishProjectsResult,
+                ...publishProjectsResult,
+            };
+        }
+        return overallPublishProjectsResult;
+    };
+}
+async function runPublishOnProjects(args, projectGraph, nxJson, projectNames, extraOptions) {
+    const projectsToRun = projectNames.map((projectName) => projectGraph.nodes[projectName]);
+    const overrides = (0, command_line_utils_1.createOverrides)(args.__overrides_unparsed__);
+    if (args.registry) {
+        overrides.registry = args.registry;
+    }
+    if (args.tag) {
+        overrides.tag = args.tag;
+    }
+    if (args.otp) {
+        overrides.otp = args.otp;
+    }
+    if (args.access) {
+        overrides.access = args.access;
+    }
+    if (args.dryRun) {
+        overrides.dryRun = args.dryRun;
+        /**
+         * Ensure the env var is set too, so that any and all publish executors triggered
+         * indirectly via dependsOn can also pick up on the fact that this is a dry run.
+         */
+        process.env.NX_DRY_RUN = 'true';
+    }
+    if (args.firstRelease) {
+        overrides.firstRelease = args.firstRelease;
+    }
+    /**
+     * If using the `nx release` command, or possibly via the programmatic API, versionData will be passed through from the version subcommand.
+     * Provide it automatically to the publish executor options with a clear namespace to avoid userland conflicts.
+     * It will be filtered out of the final terminal output lifecycle to avoid cluttering the terminal.
+     */
+    if (args.versionData) {
+        overrides.nxReleaseVersionData = args.versionData;
+    }
+    const requiredTargetName = 'nx-release-publish';
+    if (args.graph) {
+        const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(args);
+        const projectNamesWithTarget = projectsToRun
+            .map((t) => t.name)
+            .filter((projectName) => (0, project_graph_utils_1.projectHasTarget)(projectGraph.nodes[projectName], requiredTargetName));
+        await (0, graph_1.generateGraph)({
+            watch: true,
+            all: false,
+            open: true,
+            view: 'tasks',
+            targets: [requiredTargetName],
+            projects: projectNamesWithTarget,
+            file,
+        }, projectNamesWithTarget);
+        return {};
+    }
+    const projectsWithTarget = projectsToRun.filter((project) => (0, project_graph_utils_1.projectHasTarget)(project, requiredTargetName));
+    if (projectsWithTarget.length === 0) {
+        throw new Error(`Based on your config, the following projects were matched for publishing but do not have the "${requiredTargetName}" target specified:\n${[
+            ...projectsToRun.map((p) => `- ${p.name}`),
+            '',
+            `This is usually caused by either`,
+            `- not having an appropriate plugin, such as "@nx/js" installed, which will add the appropriate "${requiredTargetName}" target for you automatically`,
+            `- having "private": true set in your package.json, which prevents the target from being created`,
+        ].join('\n')}\n`);
+    }
+    const id = (0, native_1.hashArray)([...process.argv, Date.now().toString()]);
+    await (0, tasks_execution_hooks_1.runPreTasksExecution)({
+        id,
+        workspaceRoot: workspace_root_1.workspaceRoot,
+        nxJsonConfiguration: nxJson,
+        argv: process.argv,
+    });
+    const startTime = Date.now();
+    /**
+     * Run the relevant nx-release-publish executor on each of the selected projects.
+     * NOTE: Force TUI to be disabled for now.
+     */
+    process.env.NX_TUI = 'false';
+    const { taskResults } = await (0, run_command_1.runCommandForTasks)(projectsWithTarget, projectGraph, { nxJson }, {
+        targets: [requiredTargetName],
+        outputStyle: 'static',
+        ...args,
+        // It is possible for workspaces to have circular dependencies between packages and still release them to a registry
+        nxIgnoreCycles: true,
+    }, overrides, null, {}, extraOptions);
+    const endTime = Date.now();
+    const publishProjectsResult = {};
+    for (const taskData of Object.values(taskResults)) {
+        publishProjectsResult[taskData.task.target.project] = {
+            code: taskData.code,
+        };
+    }
+    // Check for EOTP errors and provide a helpful re-run command
+    const eotpFailedProjects = getEOTPFailedProjects(taskResults);
+    if (eotpFailedProjects.length > 0) {
+        output_1.output.warn({
+            title: 'One or more packages failed to publish because a valid OTP was not provided or has expired.',
+            bodyLines: [
+                'Affected projects:',
+                ...eotpFailedProjects.map((p) => `  - ${p}`),
+                '',
+                'You can provide a new OTP and re-run the publish step in isolation:',
+                '',
+                `  ${buildRerunCommand(args)}`,
+            ],
+        });
+    }
+    await (0, tasks_execution_hooks_1.runPostTasksExecution)({
+        id,
+        taskResults,
+        workspaceRoot: workspace_root_1.workspaceRoot,
+        nxJsonConfiguration: nxJson,
+        argv: process.argv,
+        startTime,
+        endTime,
+    });
+    return publishProjectsResult;
+}
+/**
+ * Return project names for failed tasks that contain EOTP error indicators in their terminal output.
+ * npm returns error code "EOTP" in JSON output.
+ * pnpm returns "EOTP" in error messages.
+ * Both will appear in the captured terminal output.
+ */
+function getEOTPFailedProjects(taskResults) {
+    return Object.values(taskResults)
+        .filter((result) => result.code !== 0 &&
+        result.terminalOutput &&
+        (result.terminalOutput.includes('EOTP') ||
+            result.terminalOutput.includes('one-time pass') ||
+            result.terminalOutput.includes('one-time password')))
+        .map((result) => result.task.target.project);
+}
+function buildRerunCommand(args) {
+    const parts = ['nx release publish'];
+    if (args.registry) {
+        parts.push(`--registry=${args.registry}`);
+    }
+    if (args.tag) {
+        parts.push(`--tag=${args.tag}`);
+    }
+    if (args.access) {
+        parts.push(`--access=${args.access}`);
+    }
+    if (args.projects?.length) {
+        parts.push(`--projects=${args.projects.join(',')}`);
+    }
+    if (args.groups?.length) {
+        parts.push(`--groups=${args.groups.join(',')}`);
+    }
+    if (args.firstRelease) {
+        parts.push('--first-release');
+    }
+    if (args.verbose) {
+        parts.push('--verbose');
+    }
+    parts.push('--otp=REPLACE_WITH_NEW_OTP');
+    return parts.join(' ');
+}

package/dist/src/command-line/release/release.d.ts

@@ -0,0 +1,5 @@
+import { NxReleaseConfiguration } from '../../config/nx-json';
+import { ReleaseOptions, VersionOptions } from './command-object';
+import { NxReleaseVersionResult } from './version';
+export declare const releaseCLIHandler: (args: VersionOptions) => Promise<number>;
+export declare function createAPI(overrideReleaseConfig: NxReleaseConfiguration, ignoreNxJsonConfig: boolean): (args: ReleaseOptions) => Promise<NxReleaseVersionResult>;

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

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseCLIHandler = void 0;
+exports.createAPI = createAPI;
+const enquirer_1 = require("enquirer");
+const node_fs_1 = require("node:fs");
+const nx_json_1 = require("../../config/nx-json");
+const file_map_utils_1 = require("../../project-graph/file-map-utils");
+const project_graph_1 = require("../../project-graph/project-graph");
+const handle_errors_1 = require("../../utils/handle-errors");
+const output_1 = require("../../utils/output");
+const changelog_1 = require("./changelog");
+const config_1 = require("./config/config");
+const deep_merge_json_1 = require("./config/deep-merge-json");
+const version_plans_1 = require("./config/version-plans");
+const publish_1 = require("./publish");
+const git_1 = require("./utils/git");
+const print_config_1 = require("./utils/print-config");
+const remote_release_client_1 = require("./utils/remote-release-clients/remote-release-client");
+const resolve_nx_json_error_message_1 = require("./utils/resolve-nx-json-error-message");
+const shared_1 = require("./utils/shared");
+const version_plan_utils_1 = require("./utils/version-plan-utils");
+const version_1 = require("./version");
+const releaseCLIHandler = (args) => (0, handle_errors_1.handleErrors)(args.verbose, () => createAPI({}, false)(args));
+exports.releaseCLIHandler = releaseCLIHandler;
+function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
+    const releaseVersion = (0, version_1.createAPI)(overrideReleaseConfig, ignoreNxJsonConfig);
+    const releaseChangelog = (0, changelog_1.createAPI)(overrideReleaseConfig, ignoreNxJsonConfig);
+    const releasePublish = (0, publish_1.createAPI)(overrideReleaseConfig, ignoreNxJsonConfig);
+    return async function release(args) {
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+        const overriddenConfig = overrideReleaseConfig ?? {};
+        const userProvidedReleaseConfig = ignoreNxJsonConfig
+            ? overriddenConfig
+            : (0, deep_merge_json_1.deepMergeJson)((0, nx_json_1.readNxJson)().release ?? {}, overriddenConfig);
+        const hasVersionGitConfig = Object.keys(userProvidedReleaseConfig.version?.git ?? {}).length > 0;
+        const hasChangelogGitConfig = Object.keys(userProvidedReleaseConfig.changelog?.git ?? {}).length > 0;
+        if (hasVersionGitConfig || hasChangelogGitConfig) {
+            const jsonConfigErrorPath = hasVersionGitConfig
+                ? ['release', 'version', 'git']
+                : ['release', 'changelog', 'git'];
+            const nxJsonMessage = await (0, resolve_nx_json_error_message_1.resolveNxJsonConfigErrorMessage)(jsonConfigErrorPath);
+            output_1.output.error({
+                title: `The "release" top level command cannot be used with granular git configuration. Instead, configure git options in the "release.git" property in nx.json, or use the version, changelog, and publish subcommands or programmatic API directly.`,
+                bodyLines: [nxJsonMessage],
+            });
+            process.exit(1);
+        }
+        // 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',
+            });
+        }
+        const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
+        if (args.specifier && rawVersionPlans.length > 0) {
+            output_1.output.error({
+                title: `A specifier option cannot be provided when using version plans.`,
+                bodyLines: [
+                    `To override this behavior, use the Nx Release programmatic API directly (https://nx.dev/features/manage-releases#using-the-programmatic-api-for-nx-release).`,
+                ],
+            });
+            process.exit(1);
+        }
+        // These properties must never be undefined as this command should
+        // always explicitly override the git operations of the subcommands.
+        const shouldCommit = userProvidedReleaseConfig.git?.commit ?? true;
+        const shouldStage = (shouldCommit || userProvidedReleaseConfig.git?.stageChanges) ?? false;
+        const shouldTag = userProvidedReleaseConfig.git?.tag ?? true;
+        const shouldCreateWorkspaceRemoteRelease = shouldCreateRemoteRelease(nxReleaseConfig.changelog.workspaceChangelog);
+        const { workspaceVersion, projectsVersionData, releaseGraph, } = await releaseVersion({
+            ...args,
+            stageChanges: shouldStage,
+            gitCommit: false,
+            gitTag: false,
+            deleteVersionPlans: false,
+        });
+        // Suppress the filter log for the changelog command as it would have already been printed by the version command
+        process.env.NX_RELEASE_INTERNAL_SUPPRESS_FILTER_LOG = 'true';
+        const changelogResult = await releaseChangelog({
+            ...args,
+            // Re-use existing release graph
+            releaseGraph,
+            versionData: projectsVersionData,
+            version: workspaceVersion,
+            stageChanges: shouldStage,
+            gitCommit: false,
+            gitTag: false,
+            gitPush: false,
+            createRelease: false,
+            deleteVersionPlans: false,
+        });
+        await (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGraph.releaseGroups, Object.keys(projectGraph.nodes), args.verbose);
+        // Validate version plans against the filter after resolution
+        const versionPlanValidationError = (0, version_plan_utils_1.validateResolvedVersionPlansAgainstFilter)(releaseGraph.releaseGroups, releaseGraph.releaseGroupToFilteredProjects);
+        if (versionPlanValidationError) {
+            output_1.output.error(versionPlanValidationError);
+            process.exit(1);
+        }
+        const planFiles = new Set();
+        releaseGraph.releaseGroups.forEach((group) => {
+            const filteredProjects = releaseGraph.releaseGroupToFilteredProjects.get(group);
+            if (group.resolvedVersionPlans) {
+                // Check each version plan individually to see if it should be deleted
+                const plansToDelete = [];
+                for (const plan of group.resolvedVersionPlans) {
+                    // Only delete if ALL projects in the version plan are being filtered/released
+                    if ((0, version_plan_utils_1.areAllVersionPlanProjectsFiltered)(plan, group, filteredProjects)) {
+                        plansToDelete.push(plan);
+                    }
+                }
+                // Only log and delete if we have plans to delete
+                if (plansToDelete.length > 0) {
+                    if (group.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP) {
+                        output_1.output.logSingleLine(`Removing version plan files`);
+                    }
+                    else {
+                        output_1.output.logSingleLine(`Removing version plan files for group ${group.name}`);
+                    }
+                    plansToDelete.forEach((plan) => {
+                        if (!args.dryRun) {
+                            (0, node_fs_1.rmSync)(plan.absolutePath, { recursive: true, force: true });
+                            if (args.verbose) {
+                                console.log(`Removing ${plan.relativePath}`);
+                            }
+                        }
+                        else {
+                            if (args.verbose) {
+                                console.log(`Would remove ${plan.relativePath}, but --dry-run was set`);
+                            }
+                        }
+                        planFiles.add(plan.relativePath);
+                    });
+                }
+            }
+        });
+        const deletedFiles = Array.from(planFiles);
+        if (deletedFiles.length > 0) {
+            await (0, git_1.gitAdd)({
+                changedFiles: [],
+                deletedFiles,
+                dryRun: args.dryRun,
+                verbose: args.verbose,
+            });
+        }
+        if (shouldCommit) {
+            output_1.output.logSingleLine(`Committing changes with git`);
+            const commitMessage = nxReleaseConfig.git.commitMessage;
+            const commitMessageValues = (0, shared_1.createCommitMessageValues)(releaseGraph.releaseGroups, releaseGraph.releaseGroupToFilteredProjects, projectsVersionData, commitMessage);
+            await (0, git_1.gitCommit)({
+                messages: commitMessageValues,
+                additionalArgs: nxReleaseConfig.git.commitArgs,
+                dryRun: args.dryRun,
+                verbose: args.verbose,
+            });
+        }
+        if (shouldTag) {
+            output_1.output.logSingleLine(`Tagging commit with git`);
+            // 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 = (0, shared_1.createGitTagValues)(releaseGraph.releaseGroups, releaseGraph.releaseGroupToFilteredProjects, projectsVersionData);
+            (0, shared_1.handleDuplicateGitTags)(gitTagValues);
+            for (const tag of gitTagValues) {
+                await (0, git_1.gitTag)({
+                    tag,
+                    message: nxReleaseConfig.git.tagMessage,
+                    additionalArgs: nxReleaseConfig.git.tagArgs,
+                    dryRun: args.dryRun,
+                    verbose: args.verbose,
+                });
+            }
+        }
+        let hasPushedChanges = false;
+        // If the workspace or any of the release groups specify that a remote release should be created, we need to push the changes to the remote
+        const shouldPush = (shouldCreateWorkspaceRemoteRelease ||
+            releaseGraph.releaseGroups.some((group) => shouldCreateRemoteRelease(group.changelog))) ??
+            false;
+        if (shouldPush) {
+            output_1.output.logSingleLine(`Pushing to git remote "origin"`);
+            await (0, git_1.gitPush)({
+                dryRun: args.dryRun,
+                verbose: args.verbose,
+                additionalArgs: nxReleaseConfig.git.pushArgs,
+            });
+            hasPushedChanges = true;
+        }
+        let latestCommit;
+        if (shouldCreateWorkspaceRemoteRelease &&
+            changelogResult.workspaceChangelog) {
+            const remoteReleaseClient = await (0, remote_release_client_1.createRemoteReleaseClient)(
+            // shouldCreateWorkspaceRemoteRelease() ensures that the createRelease property exists and is not false
+            nxReleaseConfig.changelog.workspaceChangelog
+                .createRelease);
+            if (!hasPushedChanges) {
+                throw new Error(`It is not possible to create a ${remoteReleaseClient.remoteReleaseProviderName} release for the workspace without pushing the changes to the remote, please ensure that you have not disabled git push in your nx release config`);
+            }
+            output_1.output.logSingleLine(`Creating ${remoteReleaseClient.remoteReleaseProviderName} Release`);
+            latestCommit = await (0, git_1.getCommitHash)('HEAD');
+            await remoteReleaseClient.createOrUpdateRelease(changelogResult.workspaceChangelog.releaseVersion, changelogResult.workspaceChangelog.contents, latestCommit, { dryRun: args.dryRun });
+        }
+        for (const releaseGroupName of releaseGraph.sortedReleaseGroups) {
+            const releaseGroup = releaseGraph.releaseGroups.find((g) => g.name === releaseGroupName);
+            if (!releaseGroup) {
+                continue;
+            }
+            const shouldCreateProjectRemoteReleases = shouldCreateRemoteRelease(releaseGroup.changelog);
+            if (shouldCreateProjectRemoteReleases &&
+                changelogResult.projectChangelogs) {
+                const remoteReleaseClient = await (0, remote_release_client_1.createRemoteReleaseClient)(
+                // shouldCreateProjectRemoteReleases() ensures that the createRelease property exists and is not false
+                releaseGroup.changelog
+                    .createRelease);
+                const projects = args.projects?.length
+                    ? // If the user has passed a list of projects, we need to use the filtered list of projects within the release group
+                        Array.from(releaseGraph.releaseGroupToFilteredProjects.get(releaseGroup))
+                    : // Otherwise, we use the full list of projects within the release group
+                        releaseGroup.projects;
+                const projectNodes = projects.map((name) => projectGraph.nodes[name]);
+                for (const project of projectNodes) {
+                    const changelog = changelogResult.projectChangelogs[project.name];
+                    if (!changelog) {
+                        continue;
+                    }
+                    if (!hasPushedChanges) {
+                        throw new Error(`It is not possible to create a ${remoteReleaseClient.remoteReleaseProviderName} release for the project without pushing the changes to the remote, please ensure that you have not disabled git push in your nx release config`);
+                    }
+                    output_1.output.logSingleLine(`Creating ${remoteReleaseClient.remoteReleaseProviderName} Release`);
+                    if (!latestCommit) {
+                        latestCommit = await (0, git_1.getCommitHash)('HEAD');
+                    }
+                    await remoteReleaseClient.createOrUpdateRelease(changelog.releaseVersion, changelog.contents, latestCommit, { dryRun: args.dryRun });
+                }
+            }
+        }
+        let hasNewVersion = false;
+        // null means that all projects are versioned together but there were no changes
+        if (workspaceVersion !== null) {
+            hasNewVersion = Object.values(projectsVersionData).some((version) => 
+            /**
+             * There is a scenario where applications will not have a newVersion created by VerisonActions,
+             * however, there will still be a dockerVersion created from the docker release.
+             */
+            version.newVersion !== null || version.dockerVersion !== null);
+        }
+        let shouldPublish = !!args.yes && !args.skipPublish && hasNewVersion;
+        const shouldPromptPublishing = !args.yes && !args.skipPublish && !args.dryRun && hasNewVersion;
+        if (shouldPromptPublishing) {
+            shouldPublish = await promptForPublish();
+        }
+        if (shouldPublish) {
+            const publishResults = await releasePublish({
+                ...args,
+                versionData: projectsVersionData,
+            });
+            const allExitOk = Object.values(publishResults).every((result) => result.code === 0);
+            if (!allExitOk) {
+                // When a publish target fails, we want to fail the nx release CLI
+                process.exit(1);
+            }
+        }
+        else {
+            output_1.output.logSingleLine('Skipped publishing packages.');
+        }
+        return {
+            workspaceVersion,
+            projectsVersionData,
+            releaseGraph,
+        };
+    };
+}
+async function promptForPublish() {
+    try {
+        const reply = await (0, enquirer_1.prompt)([
+            {
+                name: 'confirmation',
+                message: 'Do you want to publish these versions?',
+                type: 'confirm',
+            },
+        ]);
+        return reply.confirmation;
+    }
+    catch {
+        // Ensure the cursor is always restored before exiting
+        process.stdout.write('\u001b[?25h');
+        // Handle the case where the user exits the prompt with ctrl+c
+        return false;
+    }
+}
+function shouldCreateRemoteRelease(changelogConfig) {
+    if (changelogConfig === false) {
+        return false;
+    }
+    return changelogConfig.createRelease !== false;
+}

package/dist/src/command-line/release/utils/diff.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Minimal line-diff implementation for nx release output.
+ *
+ * Replaces jest-diff to eliminate transitive dependencies (pretty-format,
+ * chalk, ansi-styles@5) that cause version conflicts for supply chain
+ * hardening.
+ *
+ * Uses @jest/diff-sequences (zero deps) for the core LCS algorithm.
+ *
+ * Source algorithm: https://github.com/jestjs/jest/tree/main/packages/jest-diff
+ */
+interface DiffOptions {
+    contextLines?: number;
+    expand?: boolean;
+    aColor?: (s: string) => string;
+    bColor?: (s: string) => string;
+    patchColor?: (s: string) => string;
+    omitAnnotationLines?: boolean;
+}
+export declare function diff(a: string, b: string, options?: DiffOptions): string;
+export {};