nx 19.2.0-canary.20240601-6f22300 → 19.2.0-canary.20240605-5a06daa

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.shouldCreateGitHubRelease = exports.releaseChangelog = exports.releaseChangelogCLIHandler = void 0;
 const chalk = require("chalk");
 const enquirer_1 = require("enquirer");
+const fs_extra_1 = require("fs-extra");
 const node_fs_1 = require("node:fs");
 const semver_1 = require("semver");
 const tmp_1 = require("tmp");
@@ -18,6 +19,7 @@ const path_1 = require("../../utils/path");
 const workspace_root_1 = require("../../utils/workspace-root");
 const config_1 = require("./config/config");
 const filter_release_groups_1 = require("./config/filter-release-groups");
+const version_plans_1 = require("./config/version-plans");
 const git_1 = require("./utils/git");
 const github_1 = require("./utils/github");
 const launch_editor_1 = require("./utils/launch-editor");
@@ -67,6 +69,12 @@ async function releaseChangelog(args) {
         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) {
@@ -78,6 +86,7 @@ async function releaseChangelog(args) {
         });
         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:
@@ -105,7 +114,6 @@ async function releaseChangelog(args) {
     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 tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose);
     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
@@ -114,23 +122,78 @@ async function releaseChangelog(args) {
         : [];
     (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 the workspace: ${workspaceChangelogFromRef}`);
+    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);
             }
         }
-        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.`);
-        }
     }
-    // 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);
+    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.`);
+            }
+        }
+        // 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,
+        // 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;
@@ -159,9 +222,6 @@ async function releaseChangelog(args) {
             continue;
         }
         for (const project of releaseGroup.projects) {
-            if (projectToAdditionalDependencyBumps.has(project)) {
-                continue;
-            }
             const dependentProjects = (projectsVersionData[project]?.dependentProjects || [])
                 .map((dep) => {
                 return {
@@ -170,7 +230,16 @@ async function releaseChangelog(args) {
                 };
             })
                 .filter((b) => b.newVersion !== null);
-            projectToAdditionalDependencyBumps.set(project, dependentProjects);
+            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 = {};
@@ -185,7 +254,7 @@ async function releaseChangelog(args) {
                 Array.from(releaseGroupToFilteredProjects.get(releaseGroup)).flatMap((project) => {
                     return [
                         project,
-                        ...(projectToAdditionalDependencyBumps.get(project) || []).map((d) => d.dependencyName),
+                        ...(projectsVersionData[project]?.dependentProjects.map((dep) => dep.source) || []),
                     ];
                 })
             : // Otherwise, we use the full list of projects within the release group
@@ -193,29 +262,80 @@ async function releaseChangelog(args) {
         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 allRawCommits = await (0, git_1.getGitDiff)(firstCommit, toSHA);
-                    const allParsedCommits = (0, git_1.parseCommits)(allRawCommits);
-                    const commitsForProject = allParsedCommits.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.filter((c) => applyConventionalCommitsConfigFilter(c, nxReleaseConfig.conventionalCommits));
-                }
-                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.`);
+                let changes = null;
+                // 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,
+                            affectedProjects: Object.keys(vp.projectVersionBumps),
+                            githubReferences: [],
+                        };
+                    })
+                        .filter(Boolean), nxReleaseConfig.conventionalCommits);
                 }
-                if (!commits) {
-                    commits = await getCommits(fromRef, toSHA, nxReleaseConfig.conventionalCommits);
+                else {
+                    let fromRef = args.from ||
+                        (await (0, git_1.getLatestGitTagForPattern)(releaseGroup.releaseTagPattern, {
+                            projectName: project.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, commits, projectsVersionData, releaseGroup, [project], nxReleaseConfig, projectToAdditionalDependencyBumps);
+                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 &&
@@ -240,23 +360,77 @@ async function releaseChangelog(args) {
             }
         }
         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}`);
+            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.`);
                     }
                 }
-                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);
             }
-            // 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, projectToAdditionalDependencyBumps);
+            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 &&
@@ -280,7 +454,7 @@ async function releaseChangelog(args) {
             }
         }
     }
-    await applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues);
+    await applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues, releaseGroups);
     return {
         workspaceChangelog,
         projectChangelogs: allProjectChangelogs,
@@ -326,7 +500,7 @@ function resolveChangelogVersions(args, releaseGroups, releaseGroupToFilteredPro
         projectsVersionData: versionData,
     };
 }
-async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues) {
+async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues, releaseGroups) {
     let latestCommit = toSHA;
     const changes = tree.listChanges();
     /**
@@ -363,9 +537,30 @@ async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTa
         }
         return;
     }
+    const changedFiles = changes.map((f) => f.path);
+    let deletedFiles = [];
+    if (args.deleteVersionPlans && !args.dryRun) {
+        const planFiles = new Set();
+        releaseGroups.forEach((group) => {
+            if (group.versionPlans) {
+                group.versionPlans.forEach((plan) => {
+                    (0, fs_extra_1.removeSync)(plan.absolutePath);
+                    planFiles.add(plan.relativePath);
+                });
+            }
+        });
+        deletedFiles = Array.from(planFiles);
+    }
     // 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);
+        await (0, shared_1.commitChanges)({
+            changedFiles,
+            deletedFiles,
+            isDryRun: !!args.dryRun,
+            isVerbose: !!args.verbose,
+            gitCommitMessages: commitMessageValues,
+            gitCommitArgs: args.gitCommitArgs || nxReleaseConfig.changelog.git.commitArgs,
+        });
         // Resolve the commit we just made
         latestCommit = await (0, git_1.getCommitHash)('HEAD');
     }
@@ -373,7 +568,8 @@ async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTa
         changes.length) {
         output_1.output.logSingleLine(`Staging changed files with git`);
         await (0, git_1.gitAdd)({
-            changedFiles: changes.map((f) => f.path),
+            changedFiles,
+            deletedFiles,
             dryRun: args.dryRun,
             verbose: args.verbose,
         });
@@ -397,7 +593,7 @@ async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTa
     }
     return;
 }
-async function generateChangelogForWorkspace(tree, args, projectGraph, nxReleaseConfig, workspaceChangelogVersion, commits) {
+async function generateChangelogForWorkspace({ tree, args, projectGraph, nxReleaseConfig, workspaceChangelogVersion, changes, commits, }) {
     const config = nxReleaseConfig.changelog.workspaceChangelog;
     // The entire feature is disabled at the workspace level, exit early
     if (config === false) {
@@ -458,6 +654,7 @@ async function generateChangelogForWorkspace(tree, args, projectGraph, nxRelease
     const githubRepoSlug = (0, github_1.getGitHubRepoSlug)(gitRemote);
     let contents = await changelogRenderer({
         projectGraph,
+        changes,
         commits,
         releaseVersion: releaseVersion.rawVersion,
         project: null,
@@ -507,7 +704,7 @@ async function generateChangelogForWorkspace(tree, args, projectGraph, nxRelease
         contents,
     };
 }
-async function generateChangelogForProjects(tree, args, projectGraph, commits, projectsVersionData, releaseGroup, projects, nxReleaseConfig, projectToAdditionalDependencyBumps) {
+async function generateChangelogForProjects({ tree, args, projectGraph, changes, commits, projectsVersionData, releaseGroup, projects, nxReleaseConfig, projectToAdditionalDependencyBumps, }) {
     const config = releaseGroup.changelog;
     // The entire feature is disabled at the release group level, exit early
     if (config === false) {
@@ -551,6 +748,7 @@ async function generateChangelogForProjects(tree, args, projectGraph, commits, p
             : undefined;
         let contents = await changelogRenderer({
             projectGraph,
+            changes,
             commits,
             releaseVersion: releaseVersion.rawVersion,
             project: project.name,
@@ -623,24 +821,36 @@ function checkChangelogFilesEnabled(nxReleaseConfig) {
     }
     return false;
 }
-async function getCommits(fromSHA, toSHA, conventionalCommitsConfig) {
+async function getCommits(fromSHA, toSHA) {
     const rawCommits = await (0, git_1.getGitDiff)(fromSHA, toSHA);
     // Parse as conventional commits
-    const parsedCommits = (0, git_1.parseCommits)(rawCommits);
-    if (conventionalCommitsConfig === null) {
-        return parsedCommits;
-    }
-    // Apply filtering based on the conventional commits configuration
-    return parsedCommits.filter((c) => applyConventionalCommitsConfigFilter(c, conventionalCommitsConfig));
+    return (0, git_1.parseCommits)(rawCommits);
 }
-function applyConventionalCommitsConfigFilter(commit, conventionalCommitsConfig) {
-    const type = commit.type;
-    const typeConfig = conventionalCommitsConfig.types[type];
-    if (!typeConfig) {
-        // don't include commits with unknown types
-        return false;
-    }
-    return !typeConfig.changelog.hidden;
+function filterHiddenChanges(changes, conventionalCommitsConfig) {
+    return changes.filter((change) => {
+        const type = change.type;
+        const typeConfig = conventionalCommitsConfig.types[type];
+        if (!typeConfig) {
+            // don't include changes with unknown types
+            return false;
+        }
+        return !typeConfig.changelog.hidden;
+    });
+}
+// TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
+function filterHiddenCommits(commits, conventionalCommitsConfig) {
+    if (!commits) {
+        return [];
+    }
+    return commits.filter((commit) => {
+        const type = commit.type;
+        const typeConfig = conventionalCommitsConfig.types[type];
+        if (!typeConfig) {
+            // don't include commits with unknown types
+            return false;
+        }
+        return !typeConfig.changelog.hidden;
+    });
 }
 function shouldCreateGitHubRelease(changelogConfig, createReleaseArg = undefined) {
     if (createReleaseArg !== undefined) {
@@ -665,3 +875,22 @@ async function promptForGitHubRelease() {
         return false;
     }
 }
+function getProjectsAffectedByCommit(commit, fileToProjectMap) {
+    const affectedProjects = new Set();
+    for (const file of commit.affectedFiles) {
+        affectedProjects.add(fileToProjectMap[file]);
+    }
+    return Array.from(affectedProjects);
+}
+function commitChangesNonProjectFiles(commit, nonProjectFiles) {
+    return nonProjectFiles.some((fileData) => commit.affectedFiles.includes(fileData.file));
+}
+function createFileToProjectMap(projectFileMap) {
+    const fileToProjectMap = {};
+    for (const [projectName, projectFiles] of Object.entries(projectFileMap)) {
+        for (const file of projectFiles) {
+            fileToProjectMap[file.file] = projectName;
+        }
+    }
+    return fileToProjectMap;
+}

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

@@ -6,7 +6,6 @@ export interface NxReleaseArgs {
     projects?: string[];
     dryRun?: boolean;
     verbose?: boolean;
-    firstRelease?: boolean;
 }
 interface GitCommitAndTagOptions {
     stageChanges?: boolean;
@@ -17,13 +16,13 @@ interface GitCommitAndTagOptions {
     gitTagMessage?: string;
     gitTagArgs?: string;
 }
-export type VersionOptions = NxReleaseArgs & GitCommitAndTagOptions & {
+export type VersionOptions = NxReleaseArgs & GitCommitAndTagOptions & VersionPlanArgs & FirstReleaseArgs & {
     specifier?: string;
     preid?: string;
     stageChanges?: boolean;
     generatorOptionsOverrides?: Record<string, unknown>;
 };
-export type ChangelogOptions = NxReleaseArgs & GitCommitAndTagOptions & {
+export type ChangelogOptions = NxReleaseArgs & GitCommitAndTagOptions & VersionPlanArgs & FirstReleaseArgs & {
     version?: string | null;
     versionData?: VersionData;
     to?: string;
@@ -34,14 +33,24 @@ export type ChangelogOptions = NxReleaseArgs & GitCommitAndTagOptions & {
 };
 export type PublishOptions = NxReleaseArgs & Partial<RunManyOptions> & {
     outputStyle?: OutputStyle;
-} & {
+} & FirstReleaseArgs & {
     registry?: string;
     tag?: string;
     otp?: number;
 };
-export type ReleaseOptions = NxReleaseArgs & {
+export type PlanOptions = NxReleaseArgs & {
+    bump?: string;
+    message?: string;
+};
+export type ReleaseOptions = NxReleaseArgs & FirstReleaseArgs & {
     yes?: boolean;
     skipPublish?: boolean;
 };
+export type VersionPlanArgs = {
+    deleteVersionPlans?: boolean;
+};
+export type FirstReleaseArgs = {
+    firstRelease?: boolean;
+};
 export declare const yargsReleaseCommand: CommandModule<Record<string, unknown>, NxReleaseArgs>;
 export {};