@ohos-ports/nx 23.2.1-beta.0 → 23.3.0-beta.0

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

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOOP_VERSION_ACTIONS = exports.VersionActions = void 0;
+exports.resolveVersionActionsForProject = resolveVersionActionsForProject;
+const node_path_1 = require("node:path");
+const register_1 = require("../../../plugins/js/utils/register");
+const utils_1 = require("../../../tasks-runner/utils");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const config_1 = require("../config/config");
+const semver_1 = require("../utils/semver");
+const release_group_processor_1 = require("./release-group-processor");
+function resolveVersionActionsPath(path, projectGraphNode) {
+    try {
+        return require.resolve(path);
+    }
+    catch {
+        try {
+            return require.resolve((0, node_path_1.join)(workspace_root_1.workspaceRoot, path));
+        }
+        catch {
+            if (path === config_1.DEFAULT_VERSION_ACTIONS_PATH) {
+                throw new Error(`Unable to resolve the default "versionActions" implementation for project "${projectGraphNode.name}" at path: "${path}"
+
+- If this is a JavaScript/TypeScript project, it is likely that you simply need to install the "@nx/js" plugin.
+
+- If this not a JavaScript/TypeScript project, you can should provide an alternative "versionActions" implementation path via the "release.version.versionActions" configuration option.
+`);
+            }
+            throw new Error(`Unable to resolve the "versionActions" implementation for project "${projectGraphNode.name}" at the configured path: "${path}"`);
+        }
+    }
+}
+const versionActionsResolutionCache = new Map();
+async function resolveVersionActionsForProject(tree, releaseGroup, projectGraphNode, finalConfigForProject) {
+    // Project level release version config takes priority, if set
+    const projectVersionConfig = projectGraphNode.data.release?.version;
+    const releaseGroupVersionConfig = releaseGroup.version;
+    const versionActionsPathConfig = projectVersionConfig?.versionActions ??
+        releaseGroupVersionConfig?.versionActions ??
+        null;
+    if (!versionActionsPathConfig) {
+        // Should be an impossible state, as we should have defaulted to the JS implementation during config processing
+        throw new Error(`No versionActions implementation found for project "${projectGraphNode.name}", please report this on https://github.com/nrwl/nx/issues`);
+    }
+    let cachedData = versionActionsResolutionCache.get(versionActionsPathConfig);
+    const versionActionsPath = resolveVersionActionsPath(versionActionsPathConfig, projectGraphNode);
+    let VersionActionsClass;
+    let afterAllProjectsVersioned;
+    if (cachedData) {
+        VersionActionsClass = cachedData.VersionActionsClass;
+        afterAllProjectsVersioned = cachedData.afterAllProjectsVersioned;
+    }
+    else {
+        const loaded = /\.[cm]?ts$/.test(versionActionsPath)
+            ? (0, register_1.loadTsFile)(versionActionsPath)
+            : (0, register_1.requireWithTsconfigFallback)(versionActionsPath);
+        VersionActionsClass = loaded.default ?? loaded;
+        if (!VersionActionsClass) {
+            throw new Error(`For project "${projectGraphNode.name}" it was not possible to resolve the VersionActions implementation from: "${versionActionsPath}"`);
+        }
+        afterAllProjectsVersioned =
+            loaded.afterAllProjectsVersioned ??
+                // no-op fallback for ecosystems/use-cases where it is not applicable
+                (() => Promise.resolve({
+                    changedFiles: [],
+                    deletedFiles: [],
+                }));
+        versionActionsResolutionCache.set(versionActionsPath, {
+            VersionActionsClass,
+            afterAllProjectsVersioned,
+        });
+    }
+    const versionActions = new VersionActionsClass(releaseGroup, projectGraphNode, finalConfigForProject);
+    // Initialize the version actions with all the required manifest paths etc
+    await versionActions.init(tree);
+    return {
+        versionActionsPath,
+        versionActions,
+        afterAllProjectsVersioned,
+    };
+}
+class VersionActions {
+    constructor(releaseGroup, projectGraphNode, finalConfigForProject) {
+        this.releaseGroup = releaseGroup;
+        this.projectGraphNode = projectGraphNode;
+        this.finalConfigForProject = finalConfigForProject;
+        /**
+         * Whether manifests updated by this implementation should be excluded from
+         * the final Prettier pass performed by Nx Release.
+         *
+         * Custom implementations must opt in explicitly. This defaults to false so
+         * their existing formatting behavior does not change.
+         */
+        this.excludeManifestsFromFormatting = false;
+        /**
+         * The interpolated manifest paths to update, if applicable based on the user's configuration, when new
+         * versions and dependencies are determined. If no manifest files should be updated based on the user's
+         * configuration, this will be an empty array.
+         *
+         * The final value for preserveLocalDependencyProtocols will be based on the resolved config for the current
+         * project and any overrides from the user's configuration for the manifestRootsToUpdate.
+         */
+        this.manifestsToUpdate = [];
+    }
+    /**
+     * Asynchronous initialization of the version actions and resolution of manifest paths.
+     * Note: This does NOT validate that manifest files exist - that happens later in validate().
+     */
+    async init(tree) {
+        // Default to the first available source manifest root, if applicable, if no custom manifest roots are provided
+        if (this.validManifestFilenames?.length &&
+            this.finalConfigForProject.manifestRootsToUpdate.length === 0) {
+            for (const manifestFilename of this.validManifestFilenames) {
+                if (tree.exists((0, node_path_1.join)(this.projectGraphNode.data.root, manifestFilename))) {
+                    this.finalConfigForProject.manifestRootsToUpdate.push({
+                        path: this.projectGraphNode.data.root,
+                        preserveLocalDependencyProtocols: this.finalConfigForProject.preserveLocalDependencyProtocols,
+                    });
+                    break;
+                }
+            }
+        }
+        const interpolatedManifestRoots = this.finalConfigForProject.manifestRootsToUpdate.map((manifestRoot) => {
+            return {
+                ...manifestRoot,
+                path: (0, utils_1.interpolate)(manifestRoot.path, {
+                    workspaceRoot: '',
+                    projectRoot: this.projectGraphNode.data.root,
+                    projectName: this.projectGraphNode.name,
+                }),
+            };
+        });
+        // Build manifestsToUpdate but don't validate existence yet as that could break release graph construction before preVersionCommands have run
+        for (const interpolatedManifestRoot of interpolatedManifestRoots) {
+            for (const manifestFilename of this.validManifestFilenames) {
+                const manifestPath = (0, node_path_1.join)(interpolatedManifestRoot.path, manifestFilename);
+                // Just add the first matching filename pattern, actual existence check happens in validate()
+                this.manifestsToUpdate.push({
+                    ...interpolatedManifestRoot,
+                    manifestPath,
+                });
+                break;
+            }
+        }
+    }
+    /**
+     * Validates that manifest files actually exist.
+     * This will be called after all preVersionCommands have run.
+     */
+    async validate(tree) {
+        // Skip if no manifest files are expected
+        if (!this.validManifestFilenames?.length) {
+            return;
+        }
+        // Simply check each manifest exists
+        for (const manifest of this.manifestsToUpdate) {
+            if (!tree.exists(manifest.manifestPath)) {
+                const validManifestFilenames = this.validManifestFilenames?.join(' or ');
+                // Get directory path for error message using Node's path module for cross-platform compatibility
+                let rootPath = manifest.manifestPath;
+                for (const filename of this.validManifestFilenames) {
+                    rootPath = rootPath.replace(filename, '');
+                }
+                throw new Error(`The project "${this.projectGraphNode.name}" does not have a ${validManifestFilenames} file available in ${rootPath}
+
+To fix this you will either need to add a ${validManifestFilenames} file at that location, or configure "release" within your nx.json to exclude "${this.projectGraphNode.name}" from the current release group, or amend the "release.version.manifestRootsToUpdate" configuration to point to where the relevant manifest should be.
+
+It is also possible that the project is being processed because of a dependency relationship between what you are directly versioning and the project/release group, in which case you will need to amend your filters to include all relevant projects and release groups.`);
+            }
+        }
+    }
+    /**
+     * The default implementation will calculate the new version based on semver. If semver is not applicable to a
+     * particular versioning use-case, this method should be overridden with custom logic.
+     *
+     * @param {string | null} currentVersion - The current version of the project, or null if the current version resolver is set to 'none'
+     * @param {string} newVersionInput - The new version input provided by the user, such as a semver relative bump type, or an explicit version
+     * @param {string} newVersionInputReason - The reason for the new version input used to inform the log message to show to the user
+     * @param {Record<string, unknown>} newVersionInputReasonData - The data to interpolate into the new version input reason
+     * @param {string} preid - The preid to use for the new version, if applicable
+     */
+    async calculateNewVersion(currentVersion, newVersionInput, newVersionInputReason, newVersionInputReasonData, preid) {
+        const isSemverRelativeBump = (0, semver_1.isRelativeVersionKeyword)(newVersionInput);
+        const newVersionReasonText = release_group_processor_1.BUMP_TYPE_REASON_TEXT[newVersionInputReason];
+        if (!newVersionReasonText) {
+            throw new Error(`Unhandled bump type reason for ${this.projectGraphNode.name} with newVersionInput ${newVersionInput} and newVersionInputReason ${newVersionInputReason}, please report this as a bug on https://github.com/nrwl/nx/issues`);
+        }
+        const interpolatedNewVersionInputReasonText = (0, utils_1.interpolate)(newVersionReasonText, newVersionInputReasonData);
+        if (isSemverRelativeBump && !currentVersion) {
+            throw new Error(`There was no current version resolved for project "${this.projectGraphNode.name}", but it was configured to be bumped via a semver relative keyword "${newVersionInput}"${interpolatedNewVersionInputReasonText}. This is not a valid combination, please review your release configuration and CLI arguments`);
+        }
+        const newVersion = (0, semver_1.deriveNewSemverVersion)(currentVersion, newVersionInput, preid, {
+            adjustSemverBumpsForZeroMajorVersion: this.finalConfigForProject.adjustSemverBumpsForZeroMajorVersion,
+        });
+        const newVersionInputText = (0, semver_1.isRelativeVersionKeyword)(newVersionInput)
+            ? `semver relative bump "${newVersionInput}"`
+            : `explicit semver value "${newVersionInput}"`;
+        return {
+            newVersion,
+            logText: `❓ Applied ${newVersionInputText}${interpolatedNewVersionInputReasonText}to get new version ${newVersion}`,
+        };
+    }
+    /**
+     * Implementation details of resolving the dependencies of a project.
+     *
+     * The default implementation will read dependencies from the Nx project graph. In many cases this will be sufficient,
+     * because the project graph will have been constructed using plugins from relevant ecosystems that should have applied
+     * any and all relevant metadata to the project nodes and dependency edges.
+     *
+     * If, however, the project graph cannot be used as the source of truth for whatever reason, then this default method
+     * can simply be overridden in the final version actions implementation.
+     */
+    async readDependencies(tree, projectGraph) {
+        return (projectGraph.dependencies[this.projectGraphNode.name] ?? []).filter(
+        // Skip implicit dependencies for now to match legacy versioning behavior
+        // TODO: holistically figure out how to handle implicit dependencies with nx release
+        (dep) => dep.type !== 'implicit');
+    }
+}
+exports.VersionActions = VersionActions;
+class NOOP_VERSION_ACTIONS extends VersionActions {
+    constructor() {
+        super(...arguments);
+        this.validManifestFilenames = null;
+    }
+    async validate(tree) {
+        // Nothing to validate, patch base method
+        return;
+    }
+    readCurrentVersionFromRegistry(tree, currentVersionResolverMetadata) {
+        return Promise.resolve(null);
+    }
+    readCurrentVersionFromSourceManifest(tree) {
+        return Promise.resolve(null);
+    }
+    readCurrentVersionOfDependency(tree, projectGraph, dependencyProjectName) {
+        return Promise.resolve({
+            currentVersion: null,
+            dependencyCollection: null,
+        });
+    }
+    async calculateNewVersion(currentVersion, newVersionInput, newVersionInputReason, newVersionInputReasonData, preid) {
+        return Promise.resolve({
+            newVersion: '0.0.0',
+            logText: 'Skipped default versioning as no-op.',
+        });
+    }
+    updateProjectDependencies(tree, projectGraph, dependenciesToUpdate, resolveVersionForDependency) {
+        return Promise.resolve([]);
+    }
+    updateProjectVersion(tree, newVersion) {
+        return Promise.resolve([]);
+    }
+}
+exports.NOOP_VERSION_ACTIONS = NOOP_VERSION_ACTIONS;

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

@@ -0,0 +1,28 @@
+import { NxReleaseConfiguration } from '../../config/nx-json';
+import type { ProjectGraph } from '../../config/project-graph';
+import { VersionOptions } from './command-object';
+import { type NxReleaseConfig } from './config/config';
+import { ReleaseGraph } from './utils/release-graph';
+import { VersionData } from './utils/shared';
+export interface NxReleaseVersionResult {
+    /**
+     * In one specific (and very common) case, an overall workspace version is relevant, for example when there is
+     * only a single release group in which all projects have a fixed relationship to each other. In this case, the
+     * overall workspace version is the same as the version of the release group (and every project within it). This
+     * version could be a `string`, or it could be `null` if using conventional commits and no changes were detected.
+     *
+     * In all other cases (independent versioning, multiple release groups etc), the overall workspace version is
+     * not applicable and will be `undefined` here. If a user attempts to use this value later when it is `undefined`
+     * (for example in the changelog command), we will throw an appropriate error.
+     */
+    workspaceVersion: (string | null) | undefined;
+    projectsVersionData: VersionData;
+    /**
+     * The release graph that was built or reused during this operation.
+     * This can be passed to subsequent operations (changelog, publish) to avoid recomputing.
+     */
+    releaseGraph: ReleaseGraph;
+}
+export declare const releaseVersionCLIHandler: (args: VersionOptions) => Promise<number>;
+export declare function createAPI(overrideReleaseConfig: NxReleaseConfiguration, ignoreNxJsonConfig: boolean): (args: VersionOptions) => Promise<NxReleaseVersionResult>;
+export declare function hasDockerReleaseConfiguration(nxReleaseConfig: NxReleaseConfig, releaseGraph: ReleaseGraph, projectGraph: ProjectGraph): boolean;

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

@@ -0,0 +1,382 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseVersionCLIHandler = void 0;
+exports.createAPI = createAPI;
+exports.hasDockerReleaseConfiguration = hasDockerReleaseConfiguration;
+const tslib_1 = require("tslib");
+const pc = tslib_1.__importStar(require("picocolors"));
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const nx_json_1 = require("../../config/nx-json");
+const run_commands_impl_1 = require("../../executors/run-commands/run-commands.impl");
+const format_changed_files_1 = require("../../generators/internal-utils/format-changed-files");
+const tree_1 = require("../../generators/tree");
+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 path_1 = require("../../utils/path");
+const workspace_root_1 = require("../../utils/workspace-root");
+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 git_1 = require("./utils/git");
+const print_changes_1 = require("./utils/print-changes");
+const print_config_1 = require("./utils/print-config");
+const release_graph_1 = require("./utils/release-graph");
+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 release_group_processor_1 = require("./version/release-group-processor");
+const releaseVersionCLIHandler = (args) => (0, handle_errors_1.handleErrors)(args.verbose, () => createAPI({}, false)(args));
+exports.releaseVersionCLIHandler = releaseVersionCLIHandler;
+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 releaseVersion(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);
+        // 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 tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose);
+        // Use pre-built release graph if provided, otherwise create a new one
+        const releaseGraph = args.releaseGraph ||
+            (await (0, release_graph_1.createReleaseGraph)({
+                tree,
+                projectGraph,
+                nxReleaseConfig,
+                filters: {
+                    projects: args.projects,
+                    groups: args.groups,
+                },
+                firstRelease: args.firstRelease,
+                verbose: args.verbose,
+                preid: args.preid,
+                versionActionsOptionsOverrides: args.versionActionsOptionsOverrides,
+            }));
+        // 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 (!args.specifier) {
+            const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
+            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);
+            }
+        }
+        else {
+            if (args.verbose &&
+                releaseGraph.releaseGroups.some((g) => !!g.versionPlans)) {
+                console.log(`Skipping version plan discovery as a specifier was provided`);
+            }
+        }
+        if (args.deleteVersionPlans === undefined) {
+            // default to not delete version plans after versioning as they may be needed for changelog generation
+            args.deleteVersionPlans = false;
+        }
+        /**
+         * Run any configured top level pre-version command
+         */
+        runPreVersionCommand(nxReleaseConfig.version?.preVersionCommand, {
+            dryRun: args.dryRun,
+            verbose: args.verbose,
+        });
+        /**
+         * Run any configured pre-version command for the selected release groups
+         * in topological order
+         */
+        for (const groupName of releaseGraph.sortedReleaseGroups) {
+            const releaseGroup = releaseGraph.releaseGroups.find((g) => g.name === groupName);
+            if (!releaseGroup) {
+                // Release group was filtered out, skip
+                continue;
+            }
+            runPreVersionCommand(releaseGroup.version?.groupPreVersionCommand, {
+                dryRun: args.dryRun,
+                verbose: args.verbose,
+            }, releaseGroup);
+        }
+        /**
+         * Validate the resolved data for the release graph, e.g. that manifest files exist for all projects that will be processed.
+         * This happens after preVersionCommands run, as those commands may create manifest files needed for versioning.
+         */
+        await releaseGraph.validate(tree);
+        const commitMessage = args.gitCommitMessage || nxReleaseConfig.version.git.commitMessage;
+        /**
+         * 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();
+        const processor = new release_group_processor_1.ReleaseGroupProcessor(tree, projectGraph, nxReleaseConfig, releaseGraph, {
+            dryRun: args.dryRun,
+            verbose: args.verbose,
+            firstRelease: args.firstRelease,
+            preid: args.preid ?? '',
+            userGivenSpecifier: args.specifier,
+            filters: {
+                projects: args.projects,
+                groups: args.groups,
+            },
+            versionActionsOptionsOverrides: args.versionActionsOptionsOverrides,
+        });
+        try {
+            await processor.processGroups();
+            // Delete processed version plan files if applicable
+            if (args.deleteVersionPlans) {
+                processor.deleteProcessedVersionPlanFiles();
+            }
+        }
+        catch (err) {
+            // Flush any pending project logs before printing the error to make troubleshooting easier
+            processor.flushAllProjectLoggers();
+            // Bubble up the error so that the CLI can print the error and exit, or the programmatic API can handle it
+            throw err;
+        }
+        // A version actions implementation can opt its manifests out of this final
+        // pass when it already preserves their formatting while updating values.
+        const manifestsToExcludeFromFormatting = new Set(Array.from(releaseGraph.projectsToVersionActions.values()).flatMap((versionActions) => versionActions.excludeManifestsFromFormatting
+            ? versionActions.manifestsToUpdate.map(({ manifestPath }) => manifestPath)
+            : []));
+        await (0, format_changed_files_1.formatChangedFiles)(tree, {
+            silent: true,
+            excludePaths: manifestsToExcludeFromFormatting,
+        });
+        printAndFlushChanges(tree, !!args.dryRun);
+        const { changedFiles: changed, deletedFiles: deleted } = await processor.afterAllProjectsVersioned({
+            ...nxReleaseConfig.version
+                .versionActionsOptions,
+            ...(args.versionActionsOptionsOverrides ?? {}),
+        });
+        changed.forEach((f) => additionalChangedFiles.add(f));
+        deleted.forEach((f) => additionalDeletedFiles.add(f));
+        // After all version actions have run, process docker projects as a layer above
+        if (nxReleaseConfig.docker?.preVersionCommand) {
+            /**
+             * Run any configured top level docker pre-version command
+             */
+            runPreVersionCommand(nxReleaseConfig.docker.preVersionCommand, {
+                dryRun: args.dryRun,
+                verbose: args.verbose,
+            }, undefined, true);
+        }
+        /**
+         * Run any configured docker pre-version command for the selected release groups
+         * in topological order (dependencies before dependents)
+         */
+        for (const groupName of releaseGraph.sortedReleaseGroups) {
+            const releaseGroup = releaseGraph.releaseGroups.find((g) => g.name === groupName);
+            if (!releaseGroup) {
+                // Release group was filtered out, skip
+                continue;
+            }
+            if (releaseGroup.docker?.groupPreVersionCommand) {
+                runPreVersionCommand(releaseGroup.docker.groupPreVersionCommand, {
+                    dryRun: args.dryRun,
+                    verbose: args.verbose,
+                }, releaseGroup, true);
+            }
+        }
+        const shouldProcessDockerProjects = hasDockerReleaseConfiguration(nxReleaseConfig, releaseGraph, projectGraph);
+        // TODO(colum): Remove when Docker support is no longer experimental
+        if (shouldProcessDockerProjects) {
+            output_1.output.warn({
+                title: 'Warning',
+                bodyLines: [
+                    `Docker support is experimental. Breaking changes may occur and not adhere to semver versioning.`,
+                ],
+            });
+            await processor.processDockerProjects(args.dockerVersionScheme, args.dockerVersion);
+        }
+        const versionData = processor.getVersionData();
+        // 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)(releaseGraph.releaseGroups, releaseGraph.releaseGroupToFilteredProjects, versionData)
+            : [];
+        (0, shared_1.handleDuplicateGitTags)(gitTagValues);
+        // Only applicable when there is a single release group with a fixed relationship
+        let workspaceVersion = undefined;
+        if (releaseGraph.releaseGroups.length === 1) {
+            const releaseGroup = releaseGraph.releaseGroups[0];
+            if (releaseGroup.projectsRelationship === 'fixed') {
+                const releaseGroupProjectNames = Array.from(releaseGraph.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,
+        ];
+        const deletedFiles = Array.from(additionalDeletedFiles);
+        // No further actions are necessary in this scenario (e.g. if conventional commits detected no changes)
+        if (!changedFiles.length && !deletedFiles.length) {
+            return {
+                workspaceVersion,
+                projectsVersionData: versionData,
+                releaseGraph,
+            };
+        }
+        if (args.gitCommit ?? nxReleaseConfig.version.git.commit) {
+            await (0, shared_1.commitChanges)({
+                changedFiles,
+                deletedFiles,
+                isDryRun: !!args.dryRun,
+                isVerbose: !!args.verbose,
+                gitCommitMessages: (0, shared_1.createCommitMessageValues)(releaseGraph.releaseGroups, releaseGraph.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,
+                deletedFiles,
+                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,
+                });
+            }
+        }
+        if (args.gitPush ?? nxReleaseConfig.version.git.push) {
+            output_1.output.logSingleLine(`Pushing to git remote "${args.gitRemote ?? 'origin'}"`);
+            await (0, git_1.gitPush)({
+                gitRemote: args.gitRemote,
+                dryRun: args.dryRun,
+                verbose: args.verbose,
+                additionalArgs: args.gitPushArgs || nxReleaseConfig.version.git.pushArgs,
+            });
+        }
+        return {
+            workspaceVersion,
+            projectsVersionData: versionData,
+            releaseGraph,
+        };
+    };
+}
+function hasDockerReleaseConfiguration(nxReleaseConfig, releaseGraph, projectGraph) {
+    if (nxReleaseConfig.docker) {
+        return true;
+    }
+    if (releaseGraph.releaseGroups.some((rg) => rg.docker)) {
+        return true;
+    }
+    return Array.from(releaseGraph.allProjectsToProcess).some((projectName) => projectGraph.nodes[projectName]?.data.release?.docker !== undefined);
+}
+function printAndFlushChanges(tree, isDryRun) {
+    const changes = tree.listChanges();
+    console.log('');
+    if (changes.length > 0) {
+        // Print the changes
+        changes.forEach((f) => {
+            if (f.type === 'CREATE') {
+                console.error(`${pc.green('CREATE')} ${f.path}${isDryRun ? (0, output_1.orange)(' [dry-run]') : ''}`);
+                (0, print_changes_1.printDiff)('', f.content?.toString() || '');
+            }
+            else if (f.type === 'UPDATE') {
+                console.error(`${pc.white('UPDATE')} ${f.path}${isDryRun ? (0, output_1.orange)(' [dry-run]') : ''}`);
+                const currentContentsOnDisk = (0, node_fs_1.readFileSync)((0, path_1.joinPathFragments)(tree.root, f.path)).toString();
+                (0, print_changes_1.printDiff)(currentContentsOnDisk, f.content?.toString() || '');
+            }
+            else if (f.type === 'DELETE' && !f.path.includes('.nx')) {
+                throw new Error('Unexpected DELETE change, please report this as an issue');
+            }
+        });
+    }
+    else {
+        let text = isDryRun ? ' would be ' : ' ';
+        output_1.output.warn({
+            title: `No files${text}changed as a result of running versioning`,
+        });
+    }
+    if (!isDryRun) {
+        (0, tree_1.flushChanges)(workspace_root_1.workspaceRoot, changes);
+    }
+}
+function runPreVersionCommand(preVersionCommand, { dryRun, verbose }, releaseGroup, dockerPreVersionCommand = false) {
+    if (!preVersionCommand) {
+        return;
+    }
+    output_1.output.logSingleLine(releaseGroup
+        ? `Executing${dockerPreVersionCommand ? ` docker` : ` release group`} pre-version command for "${releaseGroup.name}"`
+        : `Executing${dockerPreVersionCommand ? ` docker` : ``} pre-version command`);
+    if (verbose) {
+        console.log(`Executing the following pre-version command:`);
+        console.log(preVersionCommand);
+    }
+    let env = {
+        ...process.env,
+    };
+    if (dryRun) {
+        env.NX_DRY_RUN = 'true';
+    }
+    const stdio = verbose ? 'inherit' : 'pipe';
+    try {
+        (0, node_child_process_1.execSync)(preVersionCommand, {
+            encoding: 'utf-8',
+            maxBuffer: run_commands_impl_1.LARGE_BUFFER,
+            stdio,
+            env,
+            windowsHide: true,
+        });
+    }
+    catch (e) {
+        const title = verbose
+            ? `The pre-version command failed. See the full output above.`
+            : `The pre-version command failed. Retry with --verbose to see the full output of the pre-version command.`;
+        output_1.output.error({
+            title,
+            bodyLines: [preVersionCommand, e],
+        });
+        process.exit(1);
+    }
+}

package/dist/src/command-line/repair/command-object.d.ts

@@ -0,0 +1,2 @@
+import { CommandModule } from 'yargs';
+export declare const yargsRepairCommand: CommandModule;