nx 19.5.7 → 19.6.0-beta.1

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.releaseChangelogCLIHandler = void 0;
-exports.releaseChangelog = releaseChangelog;
+exports.createAPI = createAPI;
 exports.shouldCreateGitHubRelease = shouldCreateGitHubRelease;
 const chalk = require("chalk");
 const enquirer_1 = require("enquirer");
@@ -20,6 +20,7 @@ const params_1 = require("../../utils/params");
 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 filter_release_groups_1 = require("./config/filter-release-groups");
 const version_plans_1 = require("./config/version-plans");
 const git_1 = require("./utils/git");
@@ -27,295 +28,424 @@ const github_1 = require("./utils/github");
 const launch_editor_1 = require("./utils/launch-editor");
 const markdown_1 = require("./utils/markdown");
 const print_changes_1 = require("./utils/print-changes");
+const print_config_1 = require("./utils/print-config");
 const resolve_changelog_renderer_1 = require("./utils/resolve-changelog-renderer");
 const resolve_nx_json_error_message_1 = require("./utils/resolve-nx-json-error-message");
 const shared_1 = require("./utils/shared");
-const releaseChangelogCLIHandler = (args) => (0, params_1.handleErrors)(args.verbose, () => releaseChangelog(args));
+const releaseChangelogCLIHandler = (args) => (0, params_1.handleErrors)(args.verbose, () => createAPI({})(args));
 exports.releaseChangelogCLIHandler = releaseChangelogCLIHandler;
-/**
- * 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 releaseChangelog(args) {
-    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
-    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 changelog" 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 deleting version plans in this command instead of after versioning
-        args.deleteVersionPlans = true;
-    }
-    const changelogGenerationEnabled = !!nxReleaseConfig.changelog.workspaceChangelog ||
-        Object.values(nxReleaseConfig.groups).some((g) => g.changelog);
-    if (!changelogGenerationEnabled) {
-        output_1.output.warn({
-            title: `Changelogs are disabled. No changelog entries will be generated`,
-            bodyLines: [
-                `To explicitly enable changelog generation, configure "release.changelog.workspaceChangelog" or "release.changelog.projectChangelogs" in nx.json.`,
-            ],
-        });
-        return {};
-    }
-    const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose);
-    const useAutomaticFromRef = nxReleaseConfig.changelog?.automaticFromRef || args.firstRelease;
+function createAPI(overrideReleaseConfig) {
     /**
-     * For determining the versions to use within changelog files, there are a few different possibilities:
-     * - the user is using the nx CLI, and therefore passes a single --version argument which represents the version for any and all changelog
-     * files which will be generated (i.e. both the workspace changelog, and all project changelogs, depending on which of those has been enabled)
-     * - the user is using the nxReleaseChangelog API programmatically, and:
-     *   - passes only a version property
-     *     - this works in the same way as described above for the CLI
-     *   - passes only a versionData object
-     *     - this is a special case where the user is providing a version for each project, and therefore the version argument is not needed
-     *     - NOTE: it is not possible to generate a workspace level changelog with only a versionData object, and this will produce an error
-     *   - passes both a version and a versionData object
-     *     - in this case, the version property will be used as the reference for the workspace changelog, and the versionData object will be used
-     *    to generate project changelogs
+     * 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 { workspaceChangelogVersion, projectsVersionData } = resolveChangelogVersions(args, releaseGroups, releaseGroupToFilteredProjects);
-    const to = args.to || 'HEAD';
-    const toSHA = await (0, git_1.getCommitHash)(to);
-    const headSHA = to === 'HEAD' ? toSHA : await (0, git_1.getCommitHash)('HEAD');
-    /**
-     * Protect the user against attempting to create a new commit when recreating an old release changelog,
-     * this seems like it would always be unintentional.
-     */
-    const autoCommitEnabled = args.gitCommit ?? nxReleaseConfig.changelog.git.commit;
-    if (autoCommitEnabled && headSHA !== toSHA) {
-        throw new Error(`You are attempting to recreate the changelog for an old release, but you have enabled auto-commit mode. Please disable auto-commit mode by updating your nx.json, or passing --git-commit=false`);
-    }
-    const commitMessage = args.gitCommitMessage || nxReleaseConfig.changelog.git.commitMessage;
-    const commitMessageValues = (0, shared_1.createCommitMessageValues)(releaseGroups, releaseGroupToFilteredProjects, projectsVersionData, commitMessage);
-    // 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.changelog.git.tag
-        ? (0, shared_1.createGitTagValues)(releaseGroups, releaseGroupToFilteredProjects, projectsVersionData)
-        : [];
-    (0, shared_1.handleDuplicateGitTags)(gitTagValues);
-    const postGitTasks = [];
-    let workspaceChangelogChanges = [];
-    // TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
-    let workspaceChangelogCommits = [];
-    // If there are multiple release groups, we'll just skip the workspace changelog anyway.
-    const versionPlansEnabledForWorkspaceChangelog = releaseGroups[0].versionPlans;
-    if (versionPlansEnabledForWorkspaceChangelog) {
-        if (releaseGroups.length === 1) {
-            const releaseGroup = releaseGroups[0];
-            if (releaseGroup.projectsRelationship === 'fixed') {
-                const versionPlans = releaseGroup.versionPlans;
-                workspaceChangelogChanges = filterHiddenChanges(versionPlans
-                    .map((vp) => {
-                    const parsedMessage = (0, git_1.parseConventionalCommitsMessage)(vp.message);
-                    // only properly formatted conventional commits messages will be included in the changelog
-                    if (!parsedMessage) {
-                        return null;
-                    }
-                    return {
-                        type: parsedMessage.type,
-                        scope: parsedMessage.scope,
-                        description: parsedMessage.description,
-                        body: '',
-                        isBreaking: parsedMessage.breaking,
-                        githubReferences: [],
-                    };
-                })
-                    .filter(Boolean), nxReleaseConfig.conventionalCommits);
-            }
+    return async function releaseChangelog(args) {
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+        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';
         }
-    }
-    else {
-        let workspaceChangelogFromRef = args.from ||
-            (await (0, git_1.getLatestGitTagForPattern)(nxReleaseConfig.releaseTagPattern))?.tag;
-        if (!workspaceChangelogFromRef) {
-            if (useAutomaticFromRef) {
-                workspaceChangelogFromRef = await (0, git_1.getFirstGitCommit)();
-                if (args.verbose) {
-                    console.log(`Determined workspace --from ref from the first commit in the workspace: ${workspaceChangelogFromRef}`);
-                }
-            }
-            else {
-                throw new Error(`Unable to determine the previous git tag. If this is the first release of your workspace, use the --first-release option or set the "release.changelog.automaticFromRef" config property in nx.json to generate a changelog from the first commit. Otherwise, be sure to configure the "release.releaseTagPattern" property in nx.json to match the structure of your repository's git tags.`);
-            }
+        // 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);
         }
-        // Make sure that the fromRef is actually resolvable
-        const workspaceChangelogFromSHA = await (0, git_1.getCommitHash)(workspaceChangelogFromRef);
-        workspaceChangelogCommits = await getCommits(workspaceChangelogFromSHA, toSHA);
-        workspaceChangelogChanges = filterHiddenChanges(workspaceChangelogCommits.map((c) => {
-            return {
-                type: c.type,
-                scope: c.scope,
-                description: c.description,
-                body: c.body,
-                isBreaking: c.isBreaking,
-                githubReferences: c.references,
-                author: c.author,
-                shortHash: c.shortHash,
-                revertedHashes: c.revertedHashes,
-                affectedProjects: '*',
-            };
-        }), nxReleaseConfig.conventionalCommits);
-    }
-    const workspaceChangelog = await generateChangelogForWorkspace({
-        tree,
-        args,
-        projectGraph,
-        nxReleaseConfig,
-        workspaceChangelogVersion,
-        changes: workspaceChangelogChanges,
+        // --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 changelog" 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 deleting version plans in this command instead of after versioning
+            args.deleteVersionPlans = true;
+        }
+        const changelogGenerationEnabled = !!nxReleaseConfig.changelog.workspaceChangelog ||
+            Object.values(nxReleaseConfig.groups).some((g) => g.changelog);
+        if (!changelogGenerationEnabled) {
+            output_1.output.warn({
+                title: `Changelogs are disabled. No changelog entries will be generated`,
+                bodyLines: [
+                    `To explicitly enable changelog generation, configure "release.changelog.workspaceChangelog" or "release.changelog.projectChangelogs" in nx.json.`,
+                ],
+            });
+            return {};
+        }
+        const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose);
+        const useAutomaticFromRef = nxReleaseConfig.changelog?.automaticFromRef || args.firstRelease;
+        /**
+         * For determining the versions to use within changelog files, there are a few different possibilities:
+         * - the user is using the nx CLI, and therefore passes a single --version argument which represents the version for any and all changelog
+         * files which will be generated (i.e. both the workspace changelog, and all project changelogs, depending on which of those has been enabled)
+         * - the user is using the nxReleaseChangelog API programmatically, and:
+         *   - passes only a version property
+         *     - this works in the same way as described above for the CLI
+         *   - passes only a versionData object
+         *     - this is a special case where the user is providing a version for each project, and therefore the version argument is not needed
+         *     - NOTE: it is not possible to generate a workspace level changelog with only a versionData object, and this will produce an error
+         *   - passes both a version and a versionData object
+         *     - in this case, the version property will be used as the reference for the workspace changelog, and the versionData object will be used
+         *    to generate project changelogs
+         */
+        const { workspaceChangelogVersion, projectsVersionData } = resolveChangelogVersions(args, releaseGroups, releaseGroupToFilteredProjects);
+        const to = args.to || 'HEAD';
+        const toSHA = await (0, git_1.getCommitHash)(to);
+        const headSHA = to === 'HEAD' ? toSHA : await (0, git_1.getCommitHash)('HEAD');
+        /**
+         * Protect the user against attempting to create a new commit when recreating an old release changelog,
+         * this seems like it would always be unintentional.
+         */
+        const autoCommitEnabled = args.gitCommit ?? nxReleaseConfig.changelog.git.commit;
+        if (autoCommitEnabled && headSHA !== toSHA) {
+            throw new Error(`You are attempting to recreate the changelog for an old release, but you have enabled auto-commit mode. Please disable auto-commit mode by updating your nx.json, or passing --git-commit=false`);
+        }
+        const commitMessage = args.gitCommitMessage || nxReleaseConfig.changelog.git.commitMessage;
+        const commitMessageValues = (0, shared_1.createCommitMessageValues)(releaseGroups, releaseGroupToFilteredProjects, projectsVersionData, commitMessage);
+        // 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.changelog.git.tag
+            ? (0, shared_1.createGitTagValues)(releaseGroups, releaseGroupToFilteredProjects, projectsVersionData)
+            : [];
+        (0, shared_1.handleDuplicateGitTags)(gitTagValues);
+        const postGitTasks = [];
+        let workspaceChangelogChanges = [];
         // TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
-        commits: filterHiddenCommits(workspaceChangelogCommits, nxReleaseConfig.conventionalCommits),
-    });
-    if (workspaceChangelog &&
-        shouldCreateGitHubRelease(nxReleaseConfig.changelog.workspaceChangelog, args.createRelease)) {
-        let hasPushed = false;
-        postGitTasks.push(async (latestCommit) => {
-            if (!hasPushed) {
-                output_1.output.logSingleLine(`Pushing to git remote`);
-                // Before we can create/update the release we need to ensure the commit exists on the remote
-                await (0, git_1.gitPush)({
-                    gitRemote: args.gitRemote,
-                    dryRun: args.dryRun,
-                    verbose: args.verbose,
-                });
-                hasPushed = true;
+        let workspaceChangelogCommits = [];
+        // If there are multiple release groups, we'll just skip the workspace changelog anyway.
+        const versionPlansEnabledForWorkspaceChangelog = releaseGroups[0].versionPlans;
+        if (versionPlansEnabledForWorkspaceChangelog) {
+            if (releaseGroups.length === 1) {
+                const releaseGroup = releaseGroups[0];
+                if (releaseGroup.projectsRelationship === 'fixed') {
+                    const versionPlans = releaseGroup.versionPlans;
+                    workspaceChangelogChanges = versionPlans
+                        .flatMap((vp) => {
+                        const releaseType = versionPlanSemverReleaseTypeToChangelogType(vp.groupVersionBump);
+                        const changes = !vp.triggeredByProjects
+                            ? {
+                                type: releaseType.type,
+                                scope: '',
+                                description: vp.message,
+                                body: '',
+                                isBreaking: releaseType.isBreaking,
+                                githubReferences: [],
+                                affectedProjects: '*',
+                            }
+                            : vp.triggeredByProjects.map((project) => {
+                                return {
+                                    type: releaseType.type,
+                                    scope: project,
+                                    description: vp.message,
+                                    body: '',
+                                    // TODO: what about github references?
+                                    isBreaking: releaseType.isBreaking,
+                                    githubReferences: [],
+                                    affectedProjects: [project],
+                                };
+                            });
+                        return changes;
+                    })
+                        .filter(Boolean);
+                }
             }
-            output_1.output.logSingleLine(`Creating GitHub Release`);
-            await (0, github_1.createOrUpdateGithubRelease)(workspaceChangelog.releaseVersion, workspaceChangelog.contents, latestCommit, { dryRun: args.dryRun });
-        });
-    }
-    /**
-     * Compute any additional dependency bumps up front because there could be cases of circular dependencies,
-     * and figuring them out during the main iteration would be too late.
-     */
-    const projectToAdditionalDependencyBumps = new Map();
-    for (const releaseGroup of releaseGroups) {
-        if (releaseGroup.projectsRelationship !== 'independent') {
-            continue;
         }
-        for (const project of releaseGroup.projects) {
-            // If the project does not have any changes, do not process its dependents
-            if (!projectsVersionData[project] ||
-                projectsVersionData[project].newVersion === null) {
-                continue;
+        else {
+            let workspaceChangelogFromRef = args.from ||
+                (await (0, git_1.getLatestGitTagForPattern)(nxReleaseConfig.releaseTagPattern))
+                    ?.tag;
+            if (!workspaceChangelogFromRef) {
+                if (useAutomaticFromRef) {
+                    workspaceChangelogFromRef = await (0, git_1.getFirstGitCommit)();
+                    if (args.verbose) {
+                        console.log(`Determined workspace --from ref from the first commit in the workspace: ${workspaceChangelogFromRef}`);
+                    }
+                }
+                else {
+                    throw new Error(`Unable to determine the previous git tag. If this is the first release of your workspace, use the --first-release option or set the "release.changelog.automaticFromRef" config property in nx.json to generate a changelog from the first commit. Otherwise, be sure to configure the "release.releaseTagPattern" property in nx.json to match the structure of your repository's git tags.`);
+                }
             }
-            const dependentProjects = (projectsVersionData[project].dependentProjects || [])
-                .map((dep) => {
+            // Make sure that the fromRef is actually resolvable
+            const workspaceChangelogFromSHA = await (0, git_1.getCommitHash)(workspaceChangelogFromRef);
+            workspaceChangelogCommits = await getCommits(workspaceChangelogFromSHA, toSHA);
+            workspaceChangelogChanges = filterHiddenChanges(workspaceChangelogCommits.map((c) => {
                 return {
-                    dependencyName: dep.source,
-                    newVersion: projectsVersionData[dep.source].newVersion,
+                    type: c.type,
+                    scope: c.scope,
+                    description: c.description,
+                    body: c.body,
+                    isBreaking: c.isBreaking,
+                    githubReferences: c.references,
+                    author: c.author,
+                    shortHash: c.shortHash,
+                    revertedHashes: c.revertedHashes,
+                    affectedProjects: '*',
                 };
-            })
-                .filter((b) => b.newVersion !== null);
-            for (const dependent of dependentProjects) {
-                const additionalDependencyBumpsForProject = projectToAdditionalDependencyBumps.has(dependent.dependencyName)
-                    ? projectToAdditionalDependencyBumps.get(dependent.dependencyName)
-                    : [];
-                additionalDependencyBumpsForProject.push({
-                    dependencyName: project,
-                    newVersion: projectsVersionData[project].newVersion,
-                });
-                projectToAdditionalDependencyBumps.set(dependent.dependencyName, additionalDependencyBumpsForProject);
-            }
+            }), nxReleaseConfig.conventionalCommits);
         }
-    }
-    const allProjectChangelogs = {};
-    for (const releaseGroup of releaseGroups) {
-        const config = releaseGroup.changelog;
-        // The entire feature is disabled at the release group level, exit early
-        if (config === false) {
-            continue;
+        const workspaceChangelog = await generateChangelogForWorkspace({
+            tree,
+            args,
+            projectGraph,
+            nxReleaseConfig,
+            workspaceChangelogVersion,
+            changes: workspaceChangelogChanges,
+            // TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
+            commits: filterHiddenCommits(workspaceChangelogCommits, nxReleaseConfig.conventionalCommits),
+        });
+        if (workspaceChangelog &&
+            shouldCreateGitHubRelease(nxReleaseConfig.changelog.workspaceChangelog, args.createRelease)) {
+            let hasPushed = false;
+            postGitTasks.push(async (latestCommit) => {
+                if (!hasPushed) {
+                    output_1.output.logSingleLine(`Pushing to git remote`);
+                    // Before we can create/update the release we need to ensure the commit exists on the remote
+                    await (0, git_1.gitPush)({
+                        gitRemote: args.gitRemote,
+                        dryRun: args.dryRun,
+                        verbose: args.verbose,
+                    });
+                    hasPushed = true;
+                }
+                output_1.output.logSingleLine(`Creating GitHub Release`);
+                await (0, github_1.createOrUpdateGithubRelease)(workspaceChangelog.releaseVersion, workspaceChangelog.contents, latestCommit, { dryRun: args.dryRun });
+            });
         }
-        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, plus any dependents
-                Array.from(releaseGroupToFilteredProjects.get(releaseGroup)).flatMap((project) => {
-                    return [
-                        project,
-                        ...(projectsVersionData[project]?.dependentProjects.map((dep) => dep.source) || []),
-                    ];
+        /**
+         * Compute any additional dependency bumps up front because there could be cases of circular dependencies,
+         * and figuring them out during the main iteration would be too late.
+         */
+        const projectToAdditionalDependencyBumps = new Map();
+        for (const releaseGroup of releaseGroups) {
+            if (releaseGroup.projectsRelationship !== 'independent') {
+                continue;
+            }
+            for (const project of releaseGroup.projects) {
+                // If the project does not have any changes, do not process its dependents
+                if (!projectsVersionData[project] ||
+                    projectsVersionData[project].newVersion === null) {
+                    continue;
+                }
+                const dependentProjects = (projectsVersionData[project].dependentProjects || [])
+                    .map((dep) => {
+                    return {
+                        dependencyName: dep.source,
+                        newVersion: projectsVersionData[dep.source].newVersion,
+                    };
                 })
-            : // Otherwise, we use the full list of projects within the release group
-                releaseGroup.projects;
-        const projectNodes = projects.map((name) => projectGraph.nodes[name]);
-        if (releaseGroup.projectsRelationship === 'independent') {
-            for (const project of projectNodes) {
-                let changes = null;
+                    .filter((b) => b.newVersion !== null);
+                for (const dependent of dependentProjects) {
+                    const additionalDependencyBumpsForProject = projectToAdditionalDependencyBumps.has(dependent.dependencyName)
+                        ? projectToAdditionalDependencyBumps.get(dependent.dependencyName)
+                        : [];
+                    additionalDependencyBumpsForProject.push({
+                        dependencyName: project,
+                        newVersion: projectsVersionData[project].newVersion,
+                    });
+                    projectToAdditionalDependencyBumps.set(dependent.dependencyName, additionalDependencyBumpsForProject);
+                }
+            }
+        }
+        const allProjectChangelogs = {};
+        for (const releaseGroup of releaseGroups) {
+            const config = releaseGroup.changelog;
+            // The entire feature is disabled at the release group level, exit early
+            if (config === false) {
+                continue;
+            }
+            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, plus any dependents
+                    Array.from(releaseGroupToFilteredProjects.get(releaseGroup)).flatMap((project) => {
+                        return [
+                            project,
+                            ...(projectsVersionData[project]?.dependentProjects.map((dep) => dep.source) || []),
+                        ];
+                    })
+                : // Otherwise, we use the full list of projects within the release group
+                    releaseGroup.projects;
+            const projectNodes = projects.map((name) => projectGraph.nodes[name]);
+            if (releaseGroup.projectsRelationship === 'independent') {
+                for (const project of projectNodes) {
+                    let changes = null;
+                    // TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
+                    let commits;
+                    if (releaseGroup.versionPlans) {
+                        changes = releaseGroup.versionPlans
+                            .map((vp) => {
+                            const bumpForProject = vp.projectVersionBumps[project.name];
+                            if (!bumpForProject) {
+                                return null;
+                            }
+                            const releaseType = versionPlanSemverReleaseTypeToChangelogType(bumpForProject);
+                            return {
+                                type: releaseType.type,
+                                scope: project.name,
+                                description: vp.message,
+                                body: '',
+                                isBreaking: releaseType.isBreaking,
+                                affectedProjects: Object.keys(vp.projectVersionBumps),
+                                // TODO: can we include github references when using version plans?
+                                githubReferences: [],
+                            };
+                        })
+                            .filter(Boolean);
+                    }
+                    else {
+                        let fromRef = args.from ||
+                            (await (0, git_1.getLatestGitTagForPattern)(releaseGroup.releaseTagPattern, {
+                                projectName: project.name,
+                                releaseGroupName: releaseGroup.name,
+                            }))?.tag;
+                        if (!fromRef && useAutomaticFromRef) {
+                            const firstCommit = await (0, git_1.getFirstGitCommit)();
+                            const allCommits = await getCommits(firstCommit, toSHA);
+                            const commitsForProject = allCommits.filter((c) => c.affectedFiles.find((f) => f.startsWith(project.data.root)));
+                            fromRef = commitsForProject[0]?.shortHash;
+                            if (args.verbose) {
+                                console.log(`Determined --from ref for ${project.name} from the first commit in which it exists: ${fromRef}`);
+                            }
+                            commits = commitsForProject;
+                        }
+                        if (!fromRef && !commits) {
+                            throw new Error(`Unable to determine the previous git tag. If this is the first release of your workspace, use the --first-release option or set the "release.changelog.automaticFromRef" config property in nx.json to generate a changelog from the first commit. Otherwise, be sure to configure the "release.releaseTagPattern" property in nx.json to match the structure of your repository's git tags.`);
+                        }
+                        if (!commits) {
+                            commits = await getCommits(fromRef, toSHA);
+                        }
+                        const { fileMap } = await (0, file_map_utils_1.createFileMapUsingProjectGraph)(projectGraph);
+                        const fileToProjectMap = createFileToProjectMap(fileMap.projectFileMap);
+                        changes = filterHiddenChanges(commits.map((c) => ({
+                            type: c.type,
+                            scope: c.scope,
+                            description: c.description,
+                            body: c.body,
+                            isBreaking: c.isBreaking,
+                            githubReferences: c.references,
+                            author: c.author,
+                            shortHash: c.shortHash,
+                            revertedHashes: c.revertedHashes,
+                            affectedProjects: commitChangesNonProjectFiles(c, fileMap.nonProjectFiles)
+                                ? '*'
+                                : getProjectsAffectedByCommit(c, fileToProjectMap),
+                        })), nxReleaseConfig.conventionalCommits);
+                    }
+                    const projectChangelogs = await generateChangelogForProjects({
+                        tree,
+                        args,
+                        projectGraph,
+                        changes,
+                        projectsVersionData,
+                        releaseGroup,
+                        projects: [project],
+                        nxReleaseConfig,
+                        projectToAdditionalDependencyBumps,
+                        // TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
+                        commits: filterHiddenCommits(commits, nxReleaseConfig.conventionalCommits),
+                    });
+                    let hasPushed = false;
+                    for (const [projectName, projectChangelog] of Object.entries(projectChangelogs)) {
+                        if (projectChangelogs &&
+                            shouldCreateGitHubRelease(releaseGroup.changelog, args.createRelease)) {
+                            postGitTasks.push(async (latestCommit) => {
+                                if (!hasPushed) {
+                                    output_1.output.logSingleLine(`Pushing to git remote`);
+                                    // Before we can create/update the release we need to ensure the commit exists on the remote
+                                    await (0, git_1.gitPush)({
+                                        gitRemote: args.gitRemote,
+                                        dryRun: args.dryRun,
+                                        verbose: args.verbose,
+                                    });
+                                    hasPushed = true;
+                                }
+                                output_1.output.logSingleLine(`Creating GitHub Release`);
+                                await (0, github_1.createOrUpdateGithubRelease)(projectChangelog.releaseVersion, projectChangelog.contents, latestCommit, { dryRun: args.dryRun });
+                            });
+                        }
+                        allProjectChangelogs[projectName] = projectChangelog;
+                    }
+                }
+            }
+            else {
+                let changes = [];
                 // TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
-                let commits;
+                let commits = [];
                 if (releaseGroup.versionPlans) {
-                    changes = filterHiddenChanges(releaseGroup.versionPlans
-                        .map((vp) => {
-                        const parsedMessage = (0, git_1.parseConventionalCommitsMessage)(vp.message);
-                        // only properly formatted conventional commits messages will be included in the changelog
-                        if (!parsedMessage) {
-                            return null;
-                        }
-                        return {
-                            type: parsedMessage.type,
-                            scope: parsedMessage.scope,
-                            description: parsedMessage.description,
-                            body: '',
-                            isBreaking: parsedMessage.breaking,
-                            affectedProjects: Object.keys(vp.projectVersionBumps),
-                            githubReferences: [],
-                        };
+                    changes = releaseGroup.versionPlans
+                        .flatMap((vp) => {
+                        const releaseType = versionPlanSemverReleaseTypeToChangelogType(vp.groupVersionBump);
+                        const changes = !vp.triggeredByProjects
+                            ? {
+                                type: releaseType.type,
+                                scope: '',
+                                description: vp.message,
+                                body: '',
+                                isBreaking: releaseType.isBreaking,
+                                githubReferences: [],
+                                affectedProjects: '*',
+                            }
+                            : vp.triggeredByProjects.map((project) => {
+                                return {
+                                    type: releaseType.type,
+                                    scope: project,
+                                    description: vp.message,
+                                    body: '',
+                                    // TODO: what about github references?
+                                    isBreaking: releaseType.isBreaking,
+                                    githubReferences: [],
+                                    affectedProjects: [project],
+                                };
+                            });
+                        return changes;
                     })
-                        .filter(Boolean), nxReleaseConfig.conventionalCommits);
+                        .filter(Boolean);
                 }
                 else {
                     let fromRef = args.from ||
-                        (await (0, git_1.getLatestGitTagForPattern)(releaseGroup.releaseTagPattern, {
-                            projectName: project.name,
-                            releaseGroupName: releaseGroup.name,
-                        }))?.tag;
-                    if (!fromRef && useAutomaticFromRef) {
-                        const firstCommit = await (0, git_1.getFirstGitCommit)();
-                        const allCommits = await getCommits(firstCommit, toSHA);
-                        const commitsForProject = allCommits.filter((c) => c.affectedFiles.find((f) => f.startsWith(project.data.root)));
-                        fromRef = commitsForProject[0]?.shortHash;
-                        if (args.verbose) {
-                            console.log(`Determined --from ref for ${project.name} from the first commit in which it exists: ${fromRef}`);
+                        (await (0, git_1.getLatestGitTagForPattern)(releaseGroup.releaseTagPattern))
+                            ?.tag;
+                    if (!fromRef) {
+                        if (useAutomaticFromRef) {
+                            fromRef = await (0, git_1.getFirstGitCommit)();
+                            if (args.verbose) {
+                                console.log(`Determined release group --from ref from the first commit in the workspace: ${fromRef}`);
+                            }
+                        }
+                        else {
+                            throw new Error(`Unable to determine the previous git tag. If this is the first release of your release group, use the --first-release option or set the "release.changelog.automaticFromRef" config property in nx.json to generate a changelog from the first commit. Otherwise, be sure to configure the "release.releaseTagPattern" property in nx.json to match the structure of your repository's git tags.`);
                         }
-                        commits = commitsForProject;
-                    }
-                    if (!fromRef && !commits) {
-                        throw new Error(`Unable to determine the previous git tag. If this is the first release of your workspace, use the --first-release option or set the "release.changelog.automaticFromRef" config property in nx.json to generate a changelog from the first commit. Otherwise, be sure to configure the "release.releaseTagPattern" property in nx.json to match the structure of your repository's git tags.`);
-                    }
-                    if (!commits) {
-                        commits = await getCommits(fromRef, toSHA);
                     }
+                    // Make sure that the fromRef is actually resolvable
+                    const fromSHA = await (0, git_1.getCommitHash)(fromRef);
                     const { fileMap } = await (0, file_map_utils_1.createFileMapUsingProjectGraph)(projectGraph);
                     const fileToProjectMap = createFileToProjectMap(fileMap.projectFileMap);
+                    commits = await getCommits(fromSHA, toSHA);
                     changes = filterHiddenChanges(commits.map((c) => ({
                         type: c.type,
                         scope: c.scope,
@@ -338,7 +468,7 @@ async function releaseChangelog(args) {
                     changes,
                     projectsVersionData,
                     releaseGroup,
-                    projects: [project],
+                    projects: projectNodes,
                     nxReleaseConfig,
                     projectToAdditionalDependencyBumps,
                     // TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
@@ -367,105 +497,11 @@ async function releaseChangelog(args) {
                 }
             }
         }
-        else {
-            let changes = [];
-            // TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
-            let commits = [];
-            if (releaseGroup.versionPlans) {
-                changes = filterHiddenChanges(releaseGroup.versionPlans
-                    .map((vp) => {
-                    const parsedMessage = (0, git_1.parseConventionalCommitsMessage)(vp.message);
-                    // only properly formatted conventional commits messages will be included in the changelog
-                    if (!parsedMessage) {
-                        return null;
-                    }
-                    return {
-                        type: parsedMessage.type,
-                        scope: parsedMessage.scope,
-                        description: parsedMessage.description,
-                        body: '',
-                        isBreaking: parsedMessage.breaking,
-                        githubReferences: [],
-                        affectedProjects: '*',
-                    };
-                })
-                    .filter(Boolean), nxReleaseConfig.conventionalCommits);
-            }
-            else {
-                let fromRef = args.from ||
-                    (await (0, git_1.getLatestGitTagForPattern)(releaseGroup.releaseTagPattern))
-                        ?.tag;
-                if (!fromRef) {
-                    if (useAutomaticFromRef) {
-                        fromRef = await (0, git_1.getFirstGitCommit)();
-                        if (args.verbose) {
-                            console.log(`Determined release group --from ref from the first commit in the workspace: ${fromRef}`);
-                        }
-                    }
-                    else {
-                        throw new Error(`Unable to determine the previous git tag. If this is the first release of your release group, use the --first-release option or set the "release.changelog.automaticFromRef" config property in nx.json to generate a changelog from the first commit. Otherwise, be sure to configure the "release.releaseTagPattern" property in nx.json to match the structure of your repository's git tags.`);
-                    }
-                }
-                // Make sure that the fromRef is actually resolvable
-                const fromSHA = await (0, git_1.getCommitHash)(fromRef);
-                const { fileMap } = await (0, file_map_utils_1.createFileMapUsingProjectGraph)(projectGraph);
-                const fileToProjectMap = createFileToProjectMap(fileMap.projectFileMap);
-                commits = await getCommits(fromSHA, toSHA);
-                changes = filterHiddenChanges(commits.map((c) => ({
-                    type: c.type,
-                    scope: c.scope,
-                    description: c.description,
-                    body: c.body,
-                    isBreaking: c.isBreaking,
-                    githubReferences: c.references,
-                    author: c.author,
-                    shortHash: c.shortHash,
-                    revertedHashes: c.revertedHashes,
-                    affectedProjects: commitChangesNonProjectFiles(c, fileMap.nonProjectFiles)
-                        ? '*'
-                        : getProjectsAffectedByCommit(c, fileToProjectMap),
-                })), nxReleaseConfig.conventionalCommits);
-            }
-            const projectChangelogs = await generateChangelogForProjects({
-                tree,
-                args,
-                projectGraph,
-                changes,
-                projectsVersionData,
-                releaseGroup,
-                projects: projectNodes,
-                nxReleaseConfig,
-                projectToAdditionalDependencyBumps,
-                // TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
-                commits: filterHiddenCommits(commits, nxReleaseConfig.conventionalCommits),
-            });
-            let hasPushed = false;
-            for (const [projectName, projectChangelog] of Object.entries(projectChangelogs)) {
-                if (projectChangelogs &&
-                    shouldCreateGitHubRelease(releaseGroup.changelog, args.createRelease)) {
-                    postGitTasks.push(async (latestCommit) => {
-                        if (!hasPushed) {
-                            output_1.output.logSingleLine(`Pushing to git remote`);
-                            // Before we can create/update the release we need to ensure the commit exists on the remote
-                            await (0, git_1.gitPush)({
-                                gitRemote: args.gitRemote,
-                                dryRun: args.dryRun,
-                                verbose: args.verbose,
-                            });
-                            hasPushed = true;
-                        }
-                        output_1.output.logSingleLine(`Creating GitHub Release`);
-                        await (0, github_1.createOrUpdateGithubRelease)(projectChangelog.releaseVersion, projectChangelog.contents, latestCommit, { dryRun: args.dryRun });
-                    });
-                }
-                allProjectChangelogs[projectName] = projectChangelog;
-            }
-        }
-    }
-    await applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues, releaseGroups);
-    return {
-        workspaceChangelog,
-        projectChangelogs: allProjectChangelogs,
+        await applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues, releaseGroups);
+        return {
+            workspaceChangelog,
+            projectChangelogs: allProjectChangelogs,
+        };
     };
 }
 function resolveChangelogVersions(args, releaseGroups, releaseGroupToFilteredProjects) {
@@ -900,3 +936,19 @@ function createFileToProjectMap(projectFileMap) {
     }
     return fileToProjectMap;
 }
+function versionPlanSemverReleaseTypeToChangelogType(bump) {
+    switch (bump) {
+        case 'premajor':
+        case 'major':
+            return { type: 'feat', isBreaking: true };
+        case 'preminor':
+        case 'minor':
+            return { type: 'feat', isBreaking: false };
+        case 'prerelease':
+        case 'prepatch':
+        case 'patch':
+            return { type: 'fix', isBreaking: false };
+        default:
+            throw new Error(`Invalid semver bump type: ${bump}`);
+    }
+}