nx 17.0.3 → 17.0.5

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

@@ -1,17 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.changelogHandler = void 0;
+exports.shouldCreateGitHubRelease = exports.releaseChangelog = exports.releaseChangelogCLIHandler = void 0;
 const chalk = require("chalk");
+const enquirer_1 = require("enquirer");
 const node_fs_1 = require("node:fs");
 const semver_1 = require("semver");
 const tmp_1 = require("tmp");
 const nx_json_1 = require("../../config/nx-json");
 const tree_1 = require("../../generators/tree");
 const register_1 = require("../../plugins/js/utils/register");
+const file_map_utils_1 = require("../../project-graph/file-map-utils");
 const project_graph_1 = require("../../project-graph/project-graph");
 const utils_1 = require("../../tasks-runner/utils");
-const logger_1 = require("../../utils/logger");
+const is_ci_1 = require("../../utils/is-ci");
 const output_1 = require("../../utils/output");
+const params_1 = require("../../utils/params");
 const path_1 = require("../../utils/path");
 const typescript_1 = require("../../utils/typescript");
 const workspace_root_1 = require("../../utils/workspace-root");
@@ -22,100 +25,345 @@ 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");
-class ReleaseVersion {
-    constructor({ version, // short form version string with no prefixes or patterns, e.g. 1.0.0
-    releaseTagPattern, // full pattern to interpolate, e.g. "v{version}" or "{projectName}@{version}"
-    projectName, // optional project name to interpolate into the releaseTagPattern
-     }) {
-        this.rawVersion = version;
-        this.gitTag = (0, utils_1.interpolate)(releaseTagPattern, {
-            version,
-            projectName,
-        });
-        this.isPrerelease = isPrerelease(version);
-    }
-}
-async function changelogHandler(args) {
-    // Right now, the given version must be valid semver in order to proceed
-    if (!(0, semver_1.valid)(args.version)) {
-        output_1.output.error({
-            title: `The given version "${args.version}" is not a valid semver version. Please provide your version in the format "1.0.0", "1.0.0-beta.1" etc`,
-        });
-        process.exit(1);
-    }
+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));
+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, nxJson.release);
+    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 releaseVersion = new ReleaseVersion({
-        version: args.version,
-        releaseTagPattern: nxReleaseConfig.releaseTagPattern,
-    });
-    const from = args.from || (await (0, git_1.getLastGitTag)());
-    if (!from) {
-        output_1.output.error({
-            title: `Unable to determine the previous git tag, please provide an explicit git reference using --from`,
+    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.`,
+            ],
         });
-        process.exit(1);
+        return {};
+    }
+    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 rawCommits = await (0, git_1.getGitDiff)(from, args.to);
-    // Parse as conventional commits
-    const commits = (0, git_1.parseCommits)(rawCommits).filter((c) => {
-        const type = c.type;
-        // Always ignore non user-facing commits for now
-        // TODO: allow this filter to be configurable via config in a future release
-        if (type === 'feat' || type === 'fix' || type === 'perf') {
-            return true;
-        }
-        return false;
-    });
     const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose);
-    await generateChangelogForWorkspace(tree, releaseVersion, !!args.dryRun, 
-    // Only trigger interactive mode for the workspace changelog if the user explicitly requested it via "all" or "workspace"
-    args.interactive === 'all' || args.interactive === 'workspace', commits, nxReleaseConfig.changelog.workspaceChangelog, args.gitRemote);
-    if (args.projects?.length) {
-        /**
-         * Run changelog generation for all remaining release groups and filtered projects within them
-         */
-        for (const releaseGroup of releaseGroups) {
-            const projectNodes = Array.from(releaseGroupToFilteredProjects.get(releaseGroup)).map((name) => projectGraph.nodes[name]);
-            await generateChangelogForProjects(tree, args.version, !!args.dryRun, 
-            // Only trigger interactive mode for the workspace changelog if the user explicitly requested it via "all" or "projects"
-            args.interactive === 'all' || args.interactive === 'projects', commits, releaseGroup.changelog, releaseGroup.releaseTagPattern, projectNodes, args.gitRemote);
+    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 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 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.`);
         }
-        return process.exit(0);
     }
-    /**
-     * Run changelog generation for all remaining release groups
-     */
+    // Make sure that the fromRef is actually resolvable
+    const workspaceChangelogFromSHA = await (0, git_1.getCommitHash)(workspaceChangelogFromRef);
+    const workspaceChangelogCommits = await getCommits(workspaceChangelogFromSHA, toSHA, nxReleaseConfig.conventionalCommits);
+    const workspaceChangelog = await generateChangelogForWorkspace(tree, args, projectGraph, nxReleaseConfig, workspaceChangelogVersion, workspaceChangelogCommits);
+    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 allProjectChangelogs = {};
     for (const releaseGroup of releaseGroups) {
-        const projectNodes = releaseGroup.projects.map((name) => projectGraph.nodes[name]);
-        await generateChangelogForProjects(tree, args.version, !!args.dryRun, 
-        // Only trigger interactive mode for the workspace changelog if the user explicitly requested it via "all" or "projects"
-        args.interactive === 'all' || args.interactive === 'projects', commits, releaseGroup.changelog, releaseGroup.releaseTagPattern, projectNodes, args.gitRemote);
+        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
+                Array.from(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]);
+        if (releaseGroup.projectsRelationship === 'independent') {
+            for (const project of projectNodes) {
+                let fromRef = args.from ||
+                    (await (0, git_1.getLatestGitTagForPattern)(releaseGroup.releaseTagPattern, {
+                        projectName: project.name,
+                    }))?.tag;
+                let commits = null;
+                if (!fromRef && useAutomaticFromRef) {
+                    const firstCommit = await (0, git_1.getFirstGitCommit)();
+                    const allCommits = await getCommits(firstCommit, toSHA, nxReleaseConfig.conventionalCommits);
+                    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, nxReleaseConfig.conventionalCommits);
+                }
+                const projectChangelogs = await generateChangelogForProjects(tree, args, projectGraph, commits, projectsVersionData, releaseGroup, [project], nxReleaseConfig);
+                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 {
+            const fromRef = args.from ||
+                (await (0, git_1.getLatestGitTagForPattern)(releaseGroup.releaseTagPattern))?.tag;
+            if (!fromRef) {
+                throw new Error(`Unable to determine the previous git tag, please provide an explicit git reference using --from`);
+            }
+            // Make sure that the fromRef is actually resolvable
+            const fromSHA = await (0, git_1.getCommitHash)(fromRef);
+            const commits = await getCommits(fromSHA, toSHA, nxReleaseConfig.conventionalCommits);
+            const projectChangelogs = await generateChangelogForProjects(tree, args, projectGraph, commits, projectsVersionData, releaseGroup, projectNodes, nxReleaseConfig);
+            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;
+            }
+        }
     }
-    if (args.dryRun) {
-        logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changelogs were actually created.`);
+    await applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues);
+    return {
+        workspaceChangelog,
+        projectChangelogs: allProjectChangelogs,
+    };
+}
+exports.releaseChangelog = releaseChangelog;
+function resolveChangelogVersions(args, releaseGroups, releaseGroupToFilteredProjects) {
+    if (!args.version && !args.versionData) {
+        throw new Error(`You must provide a version string and/or a versionData object.`);
     }
-    process.exit(0);
+    /**
+     * TODO: revaluate this assumption holistically in a dedicated PR when we add support for calver
+     * (e.g. the Release class also uses semver utils to check if prerelease).
+     *
+     * Right now, the given version must be valid semver in order to proceed
+     */
+    if (args.version && !(0, semver_1.valid)(args.version)) {
+        throw new Error(`The given version "${args.version}" is not a valid semver version. Please provide your version in the format "1.0.0", "1.0.0-beta.1" etc`);
+    }
+    const versionData = releaseGroups.reduce((versionData, releaseGroup) => {
+        const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+        for (const projectName of releaseGroupProjectNames) {
+            if (!args.versionData) {
+                versionData[projectName] = {
+                    newVersion: args.version,
+                    currentVersion: '', // not relevant within changelog/commit generation
+                    dependentProjects: [], // not relevant within changelog/commit generation
+                };
+                continue;
+            }
+            /**
+             * In the case where a versionData object was provided, we need to make sure all projects are present,
+             * otherwise it suggests a filtering mismatch between the version and changelog command invocations.
+             */
+            if (!args.versionData[projectName]) {
+                throw new Error(`The provided versionData object does not contain a version for project "${projectName}". This suggests a filtering mismatch between the version and changelog command invocations.`);
+            }
+        }
+        return versionData;
+    }, args.versionData || {});
+    return {
+        workspaceChangelogVersion: args.version,
+        projectsVersionData: versionData,
+    };
 }
-exports.changelogHandler = changelogHandler;
-function isPrerelease(version) {
-    // prerelease returns an array of matching prerelease "components", or null if the version is not a prerelease
-    return (0, semver_1.prerelease)(version) !== null;
+async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues) {
+    let latestCommit = toSHA;
+    const changes = tree.listChanges();
+    /**
+     * In the case where we are expecting changelog file updates, but there is nothing
+     * to flush from the tree, we exit early. This could happen we using conventional
+     * commits, for example.
+     */
+    const changelogFilesEnabled = checkChangelogFilesEnabled(nxReleaseConfig);
+    if (changelogFilesEnabled && !changes.length) {
+        output_1.output.warn({
+            title: `No changes detected for changelogs`,
+            bodyLines: [
+                `No changes were detected for any changelog files, so no changelog entries will be generated.`,
+            ],
+        });
+        if (!postGitTasks.length) {
+            // no GitHub releases to create so we can just exit
+            return;
+        }
+        if ((0, is_ci_1.isCI)()) {
+            output_1.output.warn({
+                title: `Skipped GitHub release creation because no changes were detected for any changelog files.`,
+            });
+            return;
+        }
+        // prompt the user to see if they want to create a GitHub release anyway
+        // we know that the user has configured GitHub releases because we have postGitTasks
+        const shouldCreateGitHubReleaseAnyway = await promptForGitHubRelease();
+        if (!shouldCreateGitHubReleaseAnyway) {
+            return;
+        }
+        for (const postGitTask of postGitTasks) {
+            await postGitTask(latestCommit);
+        }
+        return;
+    }
+    // Generate a new commit for the changes, if configured to do so
+    if (args.gitCommit ?? nxReleaseConfig.changelog.git.commit) {
+        await (0, shared_1.commitChanges)(changes.map((f) => f.path), !!args.dryRun, !!args.verbose, commitMessageValues, args.gitCommitArgs || nxReleaseConfig.changelog.git.commitArgs);
+        // Resolve the commit we just made
+        latestCommit = await (0, git_1.getCommitHash)('HEAD');
+    }
+    else if ((args.stageChanges ?? nxReleaseConfig.changelog.git.stageChanges) &&
+        changes.length) {
+        output_1.output.logSingleLine(`Staging changed files with git`);
+        await (0, git_1.gitAdd)({
+            changedFiles: changes.map((f) => f.path),
+            dryRun: args.dryRun,
+            verbose: args.verbose,
+        });
+    }
+    // Generate a one or more git tags for the changes, if configured to do so
+    if (args.gitTag ?? nxReleaseConfig.changelog.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.changelog.git.tagMessage,
+                additionalArgs: args.gitTagArgs || nxReleaseConfig.changelog.git.tagArgs,
+                dryRun: args.dryRun,
+                verbose: args.verbose,
+            });
+        }
+    }
+    // Run any post-git tasks in series
+    for (const postGitTask of postGitTasks) {
+        await postGitTask(latestCommit);
+    }
+    return;
 }
 function resolveChangelogRenderer(changelogRendererPath) {
+    const interpolatedChangelogRendererPath = (0, utils_1.interpolate)(changelogRendererPath, {
+        workspaceRoot: workspace_root_1.workspaceRoot,
+    });
     // Try and load the provided (or default) changelog renderer
     let changelogRenderer;
     let cleanupTranspiler = () => { };
@@ -124,7 +372,7 @@ function resolveChangelogRenderer(changelogRendererPath) {
         if (rootTsconfigPath) {
             cleanupTranspiler = (0, register_1.registerTsProject)(rootTsconfigPath);
         }
-        const r = require(changelogRendererPath);
+        const r = require(interpolatedChangelogRendererPath);
         changelogRenderer = r.default || r;
     }
     catch {
@@ -134,45 +382,74 @@ function resolveChangelogRenderer(changelogRendererPath) {
     }
     return changelogRenderer;
 }
-async function generateChangelogForWorkspace(tree, releaseVersion, dryRun, interactive, commits, config, gitRemote) {
+async function generateChangelogForWorkspace(tree, args, projectGraph, nxReleaseConfig, workspaceChangelogVersion, commits) {
+    const config = nxReleaseConfig.changelog.workspaceChangelog;
     // The entire feature is disabled at the workspace level, exit early
     if (config === false) {
         return;
     }
+    // If explicitly null it must mean that no changes were detected (e.g. when using conventional commits), so do nothing
+    if (workspaceChangelogVersion === null) {
+        return;
+    }
+    // The user explicitly passed workspaceChangelog=true but does not have a workspace changelog config in nx.json
+    if (!config) {
+        throw new Error(`Workspace changelog is enabled but no configuration was provided. Please provide a workspaceChangelog object in your nx.json`);
+    }
+    if (Object.entries(nxReleaseConfig.groups).length > 1) {
+        output_1.output.warn({
+            title: `Workspace changelog is enabled, but you have multiple release groups configured. This is not supported, so workspace changelog will be disabled.`,
+            bodyLines: [
+                `A single workspace version cannot be determined when defining multiple release groups because versions differ between each group.`,
+                `Project level changelogs can be enabled with the "release.changelog.projectChangelogs" property.`,
+            ],
+        });
+        return;
+    }
+    if (Object.values(nxReleaseConfig.groups)[0].projectsRelationship ===
+        'independent') {
+        output_1.output.warn({
+            title: `Workspace changelog is enabled, but you have configured an independent projects relationship. This is not supported, so workspace changelog will be disabled.`,
+            bodyLines: [
+                `A single workspace version cannot be determined when using independent projects because versions differ between each project.`,
+                `Project level changelogs can be enabled with the "release.changelog.projectChangelogs" property.`,
+            ],
+        });
+        return;
+    }
+    // Only trigger interactive mode for the workspace changelog if the user explicitly requested it via "all" or "workspace"
+    const interactive = args.interactive === 'all' || args.interactive === 'workspace';
+    const dryRun = !!args.dryRun;
+    const gitRemote = args.gitRemote;
     const changelogRenderer = resolveChangelogRenderer(config.renderer);
     let interpolatedTreePath = config.file || '';
     if (interpolatedTreePath) {
         interpolatedTreePath = (0, utils_1.interpolate)(interpolatedTreePath, {
-            projectName: '',
-            projectRoot: '',
+            projectName: '', // n/a for the workspace changelog
+            projectRoot: '', // n/a for the workspace changelog
             workspaceRoot: '', // within the tree, workspaceRoot is the root
         });
     }
-    // We are either creating/previewing a changelog file, a Github release, or both
-    let logTitle = dryRun ? 'Previewing a' : 'Generating a';
-    switch (true) {
-        case interpolatedTreePath && config.createRelease === 'github':
-            logTitle += ` Github release and an entry in ${interpolatedTreePath} for ${chalk.white(releaseVersion.gitTag)}`;
-            break;
-        case !!interpolatedTreePath:
-            logTitle += `n entry in ${interpolatedTreePath} for ${chalk.white(releaseVersion.gitTag)}`;
-            break;
-        case config.createRelease === 'github':
-            logTitle += ` Github release for ${chalk.white(releaseVersion.gitTag)}`;
-    }
-    output_1.output.log({
-        title: logTitle,
+    const releaseVersion = new shared_1.ReleaseVersion({
+        version: workspaceChangelogVersion,
+        releaseTagPattern: nxReleaseConfig.releaseTagPattern,
     });
-    const githubRepoSlug = config.createRelease === 'github'
-        ? (0, github_1.getGitHubRepoSlug)(gitRemote)
-        : undefined;
+    if (interpolatedTreePath) {
+        const prefix = dryRun ? 'Previewing' : 'Generating';
+        output_1.output.log({
+            title: `${prefix} an entry in ${interpolatedTreePath} for ${chalk.white(releaseVersion.gitTag)}`,
+        });
+    }
+    const githubRepoSlug = (0, github_1.getGitHubRepoSlug)(gitRemote);
     let contents = await changelogRenderer({
+        projectGraph,
         commits,
         releaseVersion: releaseVersion.rawVersion,
         project: null,
         repoSlug: githubRepoSlug,
         entryWhenNoChanges: config.entryWhenNoChanges,
         changelogRenderOptions: config.renderOptions,
+        conventionalCommitsConfig: nxReleaseConfig.conventionalCommits,
     });
     /**
      * If interactive mode, make the changelog contents available for the user to modify in their editor of choice,
@@ -187,14 +464,10 @@ async function generateChangelogForWorkspace(tree, releaseVersion, dryRun, inter
         await (0, launch_editor_1.launchEditor)(changelogPath);
         contents = (0, node_fs_1.readFileSync)(changelogPath, 'utf-8');
     }
-    /**
-     * The exact logic we use for printing the summary/diff to the user is dependent upon whether they are creating
-     * a changelog file, a Github release, or both.
-     */
-    let printSummary = () => { };
-    const noDiffInChangelogMessage = chalk.yellow(`NOTE: There was no diff detected for the changelog entry. Maybe you intended to pass alternative git references via --from and --to?`);
     if (interpolatedTreePath) {
-        let rootChangelogContents = tree.read(interpolatedTreePath)?.toString() ?? '';
+        let rootChangelogContents = tree.exists(interpolatedTreePath)
+            ? tree.read(interpolatedTreePath).toString()
+            : '';
         if (rootChangelogContents) {
             // NOTE: right now existing releases are always expected to be in markdown format, but in the future we could potentially support others via a custom parser option
             const changelogReleases = (0, markdown_1.parseChangelogMarkdown)(rootChangelogContents).releases;
@@ -212,80 +485,25 @@ async function generateChangelogForWorkspace(tree, releaseVersion, dryRun, inter
             rootChangelogContents = contents;
         }
         tree.write(interpolatedTreePath, rootChangelogContents);
-        printSummary = () => (0, print_changes_1.printChanges)(tree, !!dryRun, 3, false, noDiffInChangelogMessage);
-    }
-    if (config.createRelease === 'github') {
-        if (!githubRepoSlug) {
-            output_1.output.error({
-                title: `Unable to create a Github release because the Github repo slug could not be determined.`,
-                bodyLines: [
-                    `Please ensure you have a valid Github remote configured. You can run \`git remote -v\` to list your current remotes.`,
-                ],
-            });
-            process.exit(1);
-        }
-        const token = await (0, github_1.resolveGithubToken)();
-        const githubRequestConfig = {
-            repo: githubRepoSlug,
-            token,
-        };
-        let existingGithubReleaseForVersion;
-        try {
-            existingGithubReleaseForVersion = await (0, github_1.getGithubReleaseByTag)(githubRequestConfig, releaseVersion.gitTag);
-        }
-        catch (err) {
-            if (err.response?.status === 401) {
-                output_1.output.error({
-                    title: `Unable to resolve data via the Github API. You can use any of the following options to resolve this:`,
-                    bodyLines: [
-                        '- Set the `GITHUB_TOKEN` or `GH_TOKEN` environment variable to a valid Github token with `repo` scope',
-                        '- Have an active session via the official gh CLI tool (https://cli.github.com) in your current terminal',
-                    ],
-                });
-                process.exit(1);
-            }
-            if (err.response?.status === 404) {
-                // No existing release found, this is fine
-            }
-            else {
-                // Rethrow unknown errors for now
-                throw err;
-            }
-        }
-        let existingPrintSummaryFn = printSummary;
-        printSummary = () => {
-            const logTitle = `https://github.com/${githubRepoSlug}/releases/tag/${releaseVersion.gitTag}`;
-            if (existingGithubReleaseForVersion) {
-                console.error(`${chalk.white('UPDATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
-            }
-            else {
-                console.error(`${chalk.green('CREATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
-            }
-            // Only print the diff here if we are not already going to be printing changes from the Tree
-            if (!interpolatedTreePath) {
-                console.log('');
-                (0, print_changes_1.printDiff)(existingGithubReleaseForVersion
-                    ? existingGithubReleaseForVersion.body
-                    : '', contents, 3, noDiffInChangelogMessage);
-            }
-            existingPrintSummaryFn();
-        };
-        if (!dryRun) {
-            await (0, github_1.createOrUpdateGithubRelease)(githubRequestConfig, {
-                version: releaseVersion.gitTag,
-                prerelease: releaseVersion.isPrerelease,
-                body: contents,
-            }, existingGithubReleaseForVersion);
-        }
+        (0, print_changes_1.printAndFlushChanges)(tree, !!dryRun, 3, false, shared_1.noDiffInChangelogMessage);
     }
-    printSummary();
+    return {
+        releaseVersion,
+        contents,
+    };
 }
-async function generateChangelogForProjects(tree, rawVersion, dryRun, interactive, commits, config, releaseTagPattern, projects, gitRemote) {
-    // The entire feature is disabled at the project level, exit early
+async function generateChangelogForProjects(tree, args, projectGraph, commits, projectsVersionData, releaseGroup, projects, nxReleaseConfig) {
+    const config = releaseGroup.changelog;
+    // The entire feature is disabled at the release group level, exit early
     if (config === false) {
         return;
     }
+    // Only trigger interactive mode for the project changelog if the user explicitly requested it via "all" or "projects"
+    const interactive = args.interactive === 'all' || args.interactive === 'projects';
+    const dryRun = !!args.dryRun;
+    const gitRemote = args.gitRemote;
     const changelogRenderer = resolveChangelogRenderer(config.renderer);
+    const projectChangelogs = {};
     for (const project of projects) {
         let interpolatedTreePath = config.file || '';
         if (interpolatedTreePath) {
@@ -295,33 +513,32 @@ async function generateChangelogForProjects(tree, rawVersion, dryRun, interactiv
                 workspaceRoot: '', // within the tree, workspaceRoot is the root
             });
         }
-        const releaseVersion = new ReleaseVersion({
-            version: rawVersion,
-            releaseTagPattern,
+        /**
+         * newVersion will be null in the case that no changes were detected (e.g. in conventional commits mode),
+         * no changelog entry is relevant in that case.
+         */
+        if (projectsVersionData[project.name].newVersion === null) {
+            continue;
+        }
+        const releaseVersion = new shared_1.ReleaseVersion({
+            version: projectsVersionData[project.name].newVersion,
+            releaseTagPattern: releaseGroup.releaseTagPattern,
             projectName: project.name,
         });
-        // We are either creating/previewing a changelog file, a Github release, or both
-        let logTitle = dryRun ? 'Previewing a' : 'Generating a';
-        switch (true) {
-            case interpolatedTreePath && config.createRelease === 'github':
-                logTitle += ` Github release and an entry in ${interpolatedTreePath} for ${chalk.white(releaseVersion.gitTag)}`;
-                break;
-            case !!interpolatedTreePath:
-                logTitle += `n entry in ${interpolatedTreePath} for ${chalk.white(releaseVersion.gitTag)}`;
-                break;
-            case config.createRelease === 'github':
-                logTitle += ` Github release for ${chalk.white(releaseVersion.gitTag)}`;
+        if (interpolatedTreePath) {
+            const prefix = dryRun ? 'Previewing' : 'Generating';
+            output_1.output.log({
+                title: `${prefix} an entry in ${interpolatedTreePath} for ${chalk.white(releaseVersion.gitTag)}`,
+            });
         }
-        output_1.output.log({
-            title: logTitle,
-        });
         const githubRepoSlug = config.createRelease === 'github'
             ? (0, github_1.getGitHubRepoSlug)(gitRemote)
             : undefined;
         let contents = await changelogRenderer({
+            projectGraph,
             commits,
             releaseVersion: releaseVersion.rawVersion,
-            project: null,
+            project: project.name,
             repoSlug: githubRepoSlug,
             entryWhenNoChanges: typeof config.entryWhenNoChanges === 'string'
                 ? (0, utils_1.interpolate)(config.entryWhenNoChanges, {
@@ -331,6 +548,7 @@ async function generateChangelogForProjects(tree, rawVersion, dryRun, interactiv
                 })
                 : false,
             changelogRenderOptions: config.renderOptions,
+            conventionalCommitsConfig: nxReleaseConfig.conventionalCommits,
         });
         /**
          * If interactive mode, make the changelog contents available for the user to modify in their editor of choice,
@@ -345,14 +563,10 @@ async function generateChangelogForProjects(tree, rawVersion, dryRun, interactiv
             await (0, launch_editor_1.launchEditor)(changelogPath);
             contents = (0, node_fs_1.readFileSync)(changelogPath, 'utf-8');
         }
-        /**
-         * The exact logic we use for printing the summary/diff to the user is dependent upon whether they are creating
-         * a changelog file, a Github release, or both.
-         */
-        let printSummary = () => { };
-        const noDiffInChangelogMessage = chalk.yellow(`NOTE: There was no diff detected for the changelog entry. Maybe you intended to pass alternative git references via --from and --to?`);
         if (interpolatedTreePath) {
-            let changelogContents = tree.read(interpolatedTreePath)?.toString() ?? '';
+            let changelogContents = tree.exists(interpolatedTreePath)
+                ? tree.read(interpolatedTreePath).toString()
+                : '';
             if (changelogContents) {
                 // NOTE: right now existing releases are always expected to be in markdown format, but in the future we could potentially support others via a custom parser option
                 const changelogReleases = (0, markdown_1.parseChangelogMarkdown)(changelogContents).releases;
@@ -370,74 +584,62 @@ async function generateChangelogForProjects(tree, rawVersion, dryRun, interactiv
                 changelogContents = contents;
             }
             tree.write(interpolatedTreePath, changelogContents);
-            printSummary = () => (0, print_changes_1.printChanges)(tree, !!dryRun, 3, false, noDiffInChangelogMessage, 
+            (0, print_changes_1.printAndFlushChanges)(tree, !!dryRun, 3, false, shared_1.noDiffInChangelogMessage, 
             // Only print the change for the current changelog file at this point
             (f) => f.path === interpolatedTreePath);
         }
-        if (config.createRelease === 'github') {
-            if (!githubRepoSlug) {
-                output_1.output.error({
-                    title: `Unable to create a Github release because the Github repo slug could not be determined.`,
-                    bodyLines: [
-                        `Please ensure you have a valid Github remote configured. You can run \`git remote -v\` to list your current remotes.`,
-                    ],
-                });
-                process.exit(1);
-            }
-            const token = await (0, github_1.resolveGithubToken)();
-            const githubRequestConfig = {
-                repo: githubRepoSlug,
-                token,
-            };
-            let existingGithubReleaseForVersion;
-            try {
-                existingGithubReleaseForVersion = await (0, github_1.getGithubReleaseByTag)(githubRequestConfig, releaseVersion.gitTag);
-            }
-            catch (err) {
-                if (err.response?.status === 401) {
-                    output_1.output.error({
-                        title: `Unable to resolve data via the Github API. You can use any of the following options to resolve this:`,
-                        bodyLines: [
-                            '- Set the `GITHUB_TOKEN` or `GH_TOKEN` environment variable to a valid Github token with `repo` scope',
-                            '- Have an active session via the official gh CLI tool (https://cli.github.com) in your current terminal',
-                        ],
-                    });
-                    process.exit(1);
-                }
-                if (err.response?.status === 404) {
-                    // No existing release found, this is fine
-                }
-                else {
-                    // Rethrow unknown errors for now
-                    throw err;
-                }
-            }
-            let existingPrintSummaryFn = printSummary;
-            printSummary = () => {
-                const logTitle = `https://github.com/${githubRepoSlug}/releases/tag/${releaseVersion.gitTag}`;
-                if (existingGithubReleaseForVersion) {
-                    console.error(`${chalk.white('UPDATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
-                }
-                else {
-                    console.error(`${chalk.green('CREATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
-                }
-                // Only print the diff here if we are not already going to be printing changes from the Tree
-                if (!interpolatedTreePath) {
-                    console.log('');
-                    (0, print_changes_1.printDiff)(existingGithubReleaseForVersion
-                        ? existingGithubReleaseForVersion.body
-                        : '', contents, 3, noDiffInChangelogMessage);
-                }
-                existingPrintSummaryFn();
-            };
-            if (!dryRun) {
-                await (0, github_1.createOrUpdateGithubRelease)(githubRequestConfig, {
-                    version: releaseVersion.gitTag,
-                    prerelease: releaseVersion.isPrerelease,
-                    body: contents,
-                }, existingGithubReleaseForVersion);
-            }
+        projectChangelogs[project.name] = {
+            releaseVersion,
+            contents,
+        };
+    }
+    return projectChangelogs;
+}
+function checkChangelogFilesEnabled(nxReleaseConfig) {
+    if (nxReleaseConfig.changelog.workspaceChangelog &&
+        nxReleaseConfig.changelog.workspaceChangelog.file) {
+        return true;
+    }
+    for (const releaseGroup of Object.values(nxReleaseConfig.groups)) {
+        if (releaseGroup.changelog && releaseGroup.changelog.file) {
+            return true;
+        }
+    }
+    return false;
+}
+async function getCommits(fromSHA, toSHA, conventionalCommitsConfig) {
+    const rawCommits = await (0, git_1.getGitDiff)(fromSHA, toSHA);
+    // Parse as conventional commits
+    return (0, git_1.parseCommits)(rawCommits).filter((c) => {
+        const type = c.type;
+        const typeConfig = conventionalCommitsConfig.types[type];
+        if (!typeConfig) {
+            // don't include commits with unknown types
+            return false;
         }
-        printSummary();
+        return !typeConfig.changelog.hidden;
+    });
+}
+function shouldCreateGitHubRelease(changelogConfig, createReleaseArg = undefined) {
+    if (createReleaseArg !== undefined) {
+        return createReleaseArg === 'github';
+    }
+    return (changelogConfig || {}).createRelease === 'github';
+}
+exports.shouldCreateGitHubRelease = shouldCreateGitHubRelease;
+async function promptForGitHubRelease() {
+    try {
+        const result = await (0, enquirer_1.prompt)([
+            {
+                name: 'confirmation',
+                message: 'Do you want to create a GitHub release anyway?',
+                type: 'confirm',
+            },
+        ]);
+        return result.confirmation;
+    }
+    catch (e) {
+        // Handle the case where the user exits the prompt with ctrl+c
+        return false;
     }
 }