@depup/nx 22.5.4-depup.0

package/src/command-line/release/config/conventional-commits.d.ts

@@ -0,0 +1,3 @@
+import { NxReleaseConfig } from './config';
+export declare const DEFAULT_CONVENTIONAL_COMMITS_CONFIG: NxReleaseConfig['conventionalCommits'];
+//# sourceMappingURL=conventional-commits.d.ts.map

package/src/command-line/release/config/conventional-commits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conventional-commits.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/command-line/release/config/conventional-commits.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE3C,eAAO,MAAM,mCAAmC,EAAE,eAAe,CAAC,qBAAqB,CAuGpF,CAAC"}

package/src/command-line/release/config/conventional-commits.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONVENTIONAL_COMMITS_CONFIG = void 0;
+exports.DEFAULT_CONVENTIONAL_COMMITS_CONFIG = {
+    useCommitScope: true,
+    types: {
+        feat: {
+            semverBump: 'minor',
+            changelog: {
+                title: '🚀 Features',
+                hidden: false,
+            },
+        },
+        fix: {
+            semverBump: 'patch',
+            changelog: {
+                title: '🩹 Fixes',
+                hidden: false,
+            },
+        },
+        perf: {
+            semverBump: 'none',
+            changelog: {
+                title: '🔥 Performance',
+                hidden: false,
+            },
+        },
+        refactor: {
+            semverBump: 'none',
+            changelog: {
+                title: '💅 Refactors',
+                hidden: true,
+            },
+        },
+        docs: {
+            semverBump: 'none',
+            changelog: {
+                title: '📖 Documentation',
+                hidden: true,
+            },
+        },
+        build: {
+            semverBump: 'none',
+            changelog: {
+                title: '📦 Build',
+                hidden: true,
+            },
+        },
+        types: {
+            semverBump: 'none',
+            changelog: {
+                title: '🌊 Types',
+                hidden: true,
+            },
+        },
+        chore: {
+            semverBump: 'none',
+            changelog: {
+                title: '🏡 Chore',
+                hidden: true,
+            },
+        },
+        examples: {
+            semverBump: 'none',
+            changelog: {
+                title: '🏀 Examples',
+                hidden: true,
+            },
+        },
+        test: {
+            semverBump: 'none',
+            changelog: {
+                title: '✅ Tests',
+                hidden: true,
+            },
+        },
+        style: {
+            semverBump: 'none',
+            changelog: {
+                title: '🎨 Styles',
+                hidden: true,
+            },
+        },
+        ci: {
+            semverBump: 'none',
+            changelog: {
+                title: '🤖 CI',
+                hidden: true,
+            },
+        },
+        revert: {
+            semverBump: 'none',
+            changelog: {
+                title: '⏪ Revert',
+                hidden: true,
+            },
+        },
+        __INVALID__: {
+            semverBump: 'none',
+            changelog: {
+                title: 'Invalid based on conventional commits specification',
+                hidden: true,
+            },
+        },
+    },
+};

package/src/command-line/release/config/deep-merge-json.d.ts

@@ -0,0 +1,2 @@
+export declare function deepMergeJson<T extends Record<string, any>>(target: T, source: T): T;
+//# sourceMappingURL=deep-merge-json.d.ts.map

package/src/command-line/release/config/deep-merge-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-merge-json.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/command-line/release/config/deep-merge-json.ts"],"names":[],"mappings":"AAIA,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACzD,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,CAAC,GACR,CAAC,CAoBH"}

package/src/command-line/release/config/deep-merge-json.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMergeJson = deepMergeJson;
+function isObject(obj) {
+    return obj && typeof obj === 'object' && !Array.isArray(obj);
+}
+function deepMergeJson(target, source) {
+    try {
+        // Ensure both objects are valid JSON before attempting to merge values
+        JSON.parse(JSON.stringify(source));
+        JSON.parse(JSON.stringify(target));
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!target[key]) {
+                    Object.assign(target, { [key]: {} });
+                }
+                deepMergeJson(target[key], source[key]);
+            }
+            else {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+        return target;
+    }
+    catch {
+        throw new Error('Invalid JSON was provided');
+    }
+}

package/src/command-line/release/config/filter-release-groups.d.ts

@@ -0,0 +1,24 @@
+import { ProjectGraph } from '../../../config/project-graph';
+import { NxReleaseConfig } from './config';
+import { GroupVersionPlan, ProjectsVersionPlan } from './version-plans';
+import { NxReleaseDockerConfiguration } from '../../../config/nx-json';
+export type ReleaseGroupWithName = Omit<NxReleaseConfig['groups'][string], 'docker'> & {
+    name: string;
+    resolvedVersionPlans: (ProjectsVersionPlan | GroupVersionPlan)[] | false;
+    docker?: NxReleaseDockerConfiguration & {
+        groupPreVersionCommand?: string;
+    };
+};
+export declare function filterReleaseGroups(projectGraph: ProjectGraph, nxReleaseConfig: NxReleaseConfig, projectsFilter?: string[], groupsFilter?: string[]): {
+    error: null | {
+        title: string;
+        bodyLines?: string[];
+    };
+    filterLog: {
+        title: string;
+        bodyLines: string[];
+    } | null;
+    releaseGroups: ReleaseGroupWithName[];
+    releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>;
+};
+//# sourceMappingURL=filter-release-groups.d.ts.map

package/src/command-line/release/config/filter-release-groups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-release-groups.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/command-line/release/config/filter-release-groups.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAG7D,OAAO,EAAkC,eAAe,EAAE,MAAM,UAAU,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAC;AAEvE,MAAM,MAAM,oBAAoB,GAAG,IAAI,CACrC,eAAe,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,EACjC,QAAQ,CACT,GAAG;IACF,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,EAAE,CAAC,mBAAmB,GAAG,gBAAgB,CAAC,EAAE,GAAG,KAAK,CAAC;IACzE,MAAM,CAAC,EAAE,4BAA4B,GAAG;QAAE,sBAAsB,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC7E,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,YAAY,EAC1B,eAAe,EAAE,eAAe,EAChC,cAAc,CAAC,EAAE,MAAM,EAAE,EACzB,YAAY,CAAC,EAAE,MAAM,EAAE,GACtB;IACD,KAAK,EAAE,IAAI,GAAG;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACtD,SAAS,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,EAAE,CAAC;KACrB,GAAG,IAAI,CAAC;IACT,aAAa,EAAE,oBAAoB,EAAE,CAAC;IACtC,8BAA8B,EAAE,GAAG,CAAC,oBAAoB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;CACxE,CAgMA"}

package/src/command-line/release/config/filter-release-groups.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterReleaseGroups = filterReleaseGroups;
+const find_matching_projects_1 = require("../../../utils/find-matching-projects");
+const config_1 = require("./config");
+function filterReleaseGroups(projectGraph, nxReleaseConfig, projectsFilter, groupsFilter) {
+    let filterLog = null;
+    let releaseGroups = Object.entries(nxReleaseConfig.groups).map(([name, group]) => {
+        return {
+            ...group,
+            name,
+            resolvedVersionPlans: group.versionPlans ? [] : false,
+        };
+    });
+    const filteredProjectToReleaseGroup = new Map();
+    const releaseGroupToFilteredProjects = new Map();
+    for (const releaseGroup of releaseGroups) {
+        for (const project of releaseGroup.projects) {
+            filteredProjectToReleaseGroup.set(project, releaseGroup);
+            if (!releaseGroupToFilteredProjects.has(releaseGroup)) {
+                releaseGroupToFilteredProjects.set(releaseGroup, new Set());
+            }
+            releaseGroupToFilteredProjects.get(releaseGroup).add(project);
+        }
+    }
+    /**
+     * User is filtering to a subset of projects. We need to make sure that what they have provided can be reconciled
+     * against their configuration in terms of release groups.
+     */
+    if (projectsFilter?.length) {
+        const matchingProjectsForFilter = (0, find_matching_projects_1.findMatchingProjects)(projectsFilter, projectGraph.nodes);
+        if (!matchingProjectsForFilter.length) {
+            return {
+                error: {
+                    title: `Your --projects filter "${projectsFilter}" did not match any projects in the workspace`,
+                },
+                filterLog: null,
+                releaseGroups: [],
+                releaseGroupToFilteredProjects,
+            };
+        }
+        // Remove any non-matching projects from filteredProjectToReleaseGroup
+        for (const project of filteredProjectToReleaseGroup.keys()) {
+            if (!matchingProjectsForFilter.includes(project)) {
+                filteredProjectToReleaseGroup.delete(project);
+            }
+        }
+        // Filter out any non-matching projects from the release group to filtered projects map
+        for (const releaseGroup of releaseGroups) {
+            releaseGroup.projects
+                .filter((p) => !matchingProjectsForFilter.includes(p))
+                .forEach((p) => releaseGroupToFilteredProjects.get(releaseGroup).delete(p));
+        }
+        /**
+         * If there are release groups specified, each filtered project must match at least one release
+         * group, otherwise the command + config combination is invalid.
+         */
+        if (releaseGroups.length) {
+            const unmatchedProjects = matchingProjectsForFilter.filter((p) => !filteredProjectToReleaseGroup.has(p));
+            if (unmatchedProjects.length) {
+                return {
+                    error: {
+                        title: `The following projects which match your projects filter "${projectsFilter}" did not match any configured release groups:`,
+                        bodyLines: unmatchedProjects.map((p) => `- ${p}`),
+                    },
+                    filterLog: null,
+                    releaseGroups: [],
+                    releaseGroupToFilteredProjects,
+                };
+            }
+        }
+        /**
+         * If the user is filtering to a subset of projects, we need to make sure that they are all within release groups
+         * with "independent" configured for their projectsRelationship. If not, the filtering is invalid, and they should instead
+         * be targeting the release groups directly using the --group flag, or they should update their configuration to
+         * make the projects they were trying to filter be independently releasable.
+         */
+        const releaseGroupsForFilteredProjects = Array.from(new Set(Array.from(filteredProjectToReleaseGroup.values())));
+        const releaseGroupsThatAreNotIndependent = releaseGroupsForFilteredProjects.filter((rg) => rg.projectsRelationship !== 'independent');
+        if (releaseGroupsThatAreNotIndependent.length) {
+            // Special handling for IMPLICIT_DEFAULT_RELEASE_GROUP
+            if (releaseGroupsThatAreNotIndependent.length === 1 &&
+                releaseGroupsThatAreNotIndependent[0].name ===
+                    config_1.IMPLICIT_DEFAULT_RELEASE_GROUP) {
+                return {
+                    error: {
+                        title: `In order to release specific projects independently with --projects those projects must be configured appropriately. For example, by setting \`"projectsRelationship": "independent"\` in your nx.json config.`,
+                        bodyLines: [],
+                    },
+                    filterLog: null,
+                    releaseGroups: [],
+                    releaseGroupToFilteredProjects,
+                };
+            }
+            return {
+                error: {
+                    title: `Your --projects filter "${projectsFilter}" matched projects in the following release groups which do not have "independent" configured for their "projectsRelationship":`,
+                    bodyLines: releaseGroupsThatAreNotIndependent.map((rg) => `- ${rg.name}`),
+                },
+                filterLog: null,
+                releaseGroups: [],
+                releaseGroupToFilteredProjects,
+            };
+        }
+        filterLog = {
+            title: `Your filter "${projectsFilter}" matched the following projects:`,
+            bodyLines: matchingProjectsForFilter.map((p) => {
+                const releaseGroupForProject = filteredProjectToReleaseGroup.get(p);
+                if (releaseGroupForProject.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP) {
+                    return `- ${p}`;
+                }
+                return `- ${p} (release group "${releaseGroupForProject.name}")`;
+            }),
+        };
+        // Filter the releaseGroups collection appropriately
+        for (const [releaseGroupWithName, matchingProjects,] of releaseGroupToFilteredProjects.entries()) {
+            if (matchingProjects.size === 0) {
+                releaseGroupToFilteredProjects.delete(releaseGroupWithName);
+            }
+        }
+        releaseGroups = releaseGroups.filter((rg) => releaseGroupToFilteredProjects.get(rg)?.size > 0);
+        return {
+            error: null,
+            filterLog,
+            releaseGroups,
+            releaseGroupToFilteredProjects,
+        };
+    }
+    /**
+     * The user is filtering by release group
+     */
+    if (groupsFilter?.length) {
+        releaseGroups
+            .filter((g) => !groupsFilter.includes(g.name))
+            .forEach((g) => releaseGroupToFilteredProjects.delete(g));
+        releaseGroups = releaseGroups.filter((g) => groupsFilter.includes(g.name));
+    }
+    if (!releaseGroups.length) {
+        return {
+            error: {
+                title: groupsFilter
+                    ? `Your --groups filter "${groupsFilter}" did not match any release groups in the workspace`
+                    : // Getting to this point should be impossible, as we should have explicitly handled any errors/invalid config by now
+                        `No projects could be matched for versioning, please report this case and include your nx.json config and command line arguments`,
+            },
+            filterLog: null,
+            releaseGroups: [],
+            releaseGroupToFilteredProjects,
+        };
+    }
+    return {
+        error: null,
+        filterLog,
+        releaseGroups,
+        releaseGroupToFilteredProjects,
+    };
+}

package/src/command-line/release/config/version-plans.d.ts

@@ -0,0 +1,43 @@
+import { ReleaseType } from 'semver';
+import { RawGitCommit } from '../utils/git';
+import { ReleaseGroupWithName } from './filter-release-groups';
+export interface VersionPlanFile {
+    absolutePath: string;
+    relativePath: string;
+    fileName: string;
+    createdOnMs: number;
+}
+export interface RawVersionPlan extends VersionPlanFile {
+    content: Record<string, string>;
+    message: string;
+}
+export interface VersionPlan extends VersionPlanFile {
+    message: string;
+    /**
+     * The commit that added the version plan file, will be null if the file was never committed.
+     * For optimal performance, we don't apply it at the time of reading the raw contents, because
+     * it hasn't yet passed further validation at that point.
+     */
+    commit: RawGitCommit | null;
+}
+export interface GroupVersionPlan extends VersionPlan {
+    groupVersionBump: ReleaseType;
+    /**
+     * The commit that added the version plan file, will be null if the file was never committed.
+     * For optimal performance, we don't apply it at the time of reading the raw contents, because.
+     * it hasn't yet passed validation.
+     */
+    commit: RawGitCommit | null;
+    /**
+     * Will not be set if the group name was the trigger, otherwise will be a list of
+     * all the individual project names explicitly found in the version plan file.
+     */
+    triggeredByProjects?: string[];
+}
+export interface ProjectsVersionPlan extends VersionPlan {
+    projectVersionBumps: Record<string, ReleaseType>;
+}
+export declare function readRawVersionPlans(): Promise<RawVersionPlan[]>;
+export declare function setResolvedVersionPlansOnGroups(rawVersionPlans: RawVersionPlan[], releaseGroups: ReleaseGroupWithName[], allProjectNamesInWorkspace: string[], isVerbose: boolean): Promise<ReleaseGroupWithName[]>;
+export declare function getVersionPlansAbsolutePath(): string;
+//# sourceMappingURL=version-plans.d.ts.map

package/src/command-line/release/config/version-plans.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-plans.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/command-line/release/config/version-plans.ts"],"names":[],"mappings":"AAIA,OAAO,EAAiB,WAAW,EAAE,MAAM,QAAQ,CAAC;AAEpD,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAG/D,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAe,SAAQ,eAAe;IACrD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAY,SAAQ,eAAe;IAClD,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,gBAAgB,EAAE,WAAW,CAAC;IAC9B;;;;OAIG;IACH,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5B;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CAClD;AAgBD,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC,CAgDrE;AAED,wBAAsB,+BAA+B,CACnD,eAAe,EAAE,cAAc,EAAE,EACjC,aAAa,EAAE,oBAAoB,EAAE,EACrC,0BAA0B,EAAE,MAAM,EAAE,EACpC,SAAS,EAAE,OAAO,GACjB,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAwNjC;AASD,wBAAgB,2BAA2B,WAE1C"}

package/src/command-line/release/config/version-plans.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRawVersionPlans = readRawVersionPlans;
+exports.setResolvedVersionPlansOnGroups = setResolvedVersionPlansOnGroups;
+exports.getVersionPlansAbsolutePath = getVersionPlansAbsolutePath;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const path_1 = require("path");
+const semver_1 = require("semver");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const config_1 = require("./config");
+const fm = require('front-matter');
+const versionPlansDirectory = (0, path_1.join)('.nx', 'version-plans');
+const allowedAttributeValues = [
+    // Stable releases (with conventional-commit style aliases)
+    '"major" (aliases: "feat!" or "fix!")',
+    '"minor" (alias: "feat")',
+    '"patch" (alias: "fix")',
+    // Prereleases
+    '"premajor"',
+    '"preminor"',
+    '"prepatch"',
+    '"prerelease"',
+];
+async function readRawVersionPlans() {
+    const versionPlansPath = getVersionPlansAbsolutePath();
+    if (!(0, node_fs_1.existsSync)(versionPlansPath)) {
+        return [];
+    }
+    const versionPlans = [];
+    const versionPlanFiles = (0, node_fs_1.readdirSync)(versionPlansPath);
+    for (const versionPlanFile of versionPlanFiles) {
+        const filePath = (0, path_1.join)(versionPlansPath, versionPlanFile);
+        const versionPlanContent = (0, node_fs_1.readFileSync)(filePath).toString();
+        const versionPlanStats = await (0, promises_1.stat)(filePath);
+        const parsedContent = fm(versionPlanContent);
+        /**
+         * For convenience allow:
+         * - feat to be used as an alias of minor
+         * - fix to be used as an alias of patch
+         * - Either feat! or fix! to be used as an alias of major
+         */
+        for (const [key, value] of Object.entries(parsedContent.attributes)) {
+            switch (value) {
+                case 'feat':
+                    parsedContent.attributes[key] = 'minor';
+                    break;
+                case 'fix':
+                    parsedContent.attributes[key] = 'patch';
+                    break;
+                case 'feat!':
+                case 'fix!':
+                    parsedContent.attributes[key] = 'major';
+                    break;
+            }
+        }
+        versionPlans.push({
+            absolutePath: filePath,
+            relativePath: (0, path_1.join)(versionPlansDirectory, versionPlanFile),
+            fileName: versionPlanFile,
+            content: parsedContent.attributes,
+            message: parsedContent.body,
+            createdOnMs: versionPlanStats.birthtimeMs,
+        });
+    }
+    return versionPlans;
+}
+async function setResolvedVersionPlansOnGroups(rawVersionPlans, releaseGroups, allProjectNamesInWorkspace, isVerbose) {
+    const groupsByName = releaseGroups.reduce((acc, group) => acc.set(group.name, group), new Map());
+    const isDefaultGroup = isDefault(releaseGroups);
+    for (const rawVersionPlan of rawVersionPlans) {
+        if (!rawVersionPlan.message) {
+            throw new Error(`Please add a changelog message to version plan: '${rawVersionPlan.fileName}'`);
+        }
+        for (const [key, value] of Object.entries(rawVersionPlan.content)) {
+            if (groupsByName.has(key)) {
+                const group = groupsByName.get(key);
+                if (!group.resolvedVersionPlans) {
+                    if (isDefaultGroup) {
+                        throw new Error(`Found a version bump in '${rawVersionPlan.fileName}' but version plans are not enabled.`);
+                    }
+                    else {
+                        throw new Error(`Found a version bump for group '${key}' in '${rawVersionPlan.fileName}' but the group does not have version plans enabled.`);
+                    }
+                }
+                if (group.projectsRelationship === 'independent') {
+                    if (isDefaultGroup) {
+                        throw new Error(`Found a version bump in '${rawVersionPlan.fileName}' but projects are configured to be independently versioned. Individual projects should be bumped instead.`);
+                    }
+                    else {
+                        throw new Error(`Found a version bump for group '${key}' in '${rawVersionPlan.fileName}' but the group's projects are independently versioned. Individual projects of '${key}' should be bumped instead.`);
+                    }
+                }
+                if (!isReleaseType(value)) {
+                    if (isDefaultGroup) {
+                        throw new Error(`Found a version bump in '${rawVersionPlan.fileName}' with an invalid release type. Please specify one of: ${allowedAttributeValues.join(', ')}.`);
+                    }
+                    else {
+                        throw new Error(`Found a version bump for group '${key}' in '${rawVersionPlan.fileName}' with an invalid release type. Please specify one of: ${allowedAttributeValues.join(', ')}.`);
+                    }
+                }
+                const existingPlan = (group.resolvedVersionPlans.find((plan) => plan.fileName === rawVersionPlan.fileName));
+                if (existingPlan) {
+                    if (existingPlan.groupVersionBump !== value) {
+                        if (isDefaultGroup) {
+                            throw new Error(`Found a version bump in '${rawVersionPlan.fileName}' that conflicts with another version bump. When in fixed versioning mode, all version bumps must match.`);
+                        }
+                        else {
+                            throw new Error(`Found a version bump for group '${key}' in '${rawVersionPlan.fileName}' that conflicts with another version bump for this group. When the group is in fixed versioning mode, all groups' version bumps within the same version plan must match.`);
+                        }
+                    }
+                }
+                else {
+                    group.resolvedVersionPlans.push({
+                        absolutePath: rawVersionPlan.absolutePath,
+                        relativePath: rawVersionPlan.relativePath,
+                        fileName: rawVersionPlan.fileName,
+                        createdOnMs: rawVersionPlan.createdOnMs,
+                        message: rawVersionPlan.message,
+                        groupVersionBump: value,
+                        commit: await getCommitForVersionPlanFile(rawVersionPlan, isVerbose),
+                    });
+                }
+            }
+            else {
+                const groupForProject = releaseGroups.find((group) => group.projects.includes(key));
+                if (!groupForProject) {
+                    if (!allProjectNamesInWorkspace.includes(key)) {
+                        throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but the project does not exist in the workspace.`);
+                    }
+                    if (isDefaultGroup) {
+                        throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but the project is not configured for release. Ensure it is included by the 'release.projects' globs in nx.json.`);
+                    }
+                    else {
+                        throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but the project is not in any configured release groups.`);
+                    }
+                }
+                if (!groupForProject.resolvedVersionPlans) {
+                    if (isDefaultGroup) {
+                        throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but version plans are not enabled.`);
+                    }
+                    else {
+                        throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' but the project's group '${groupForProject.name}' does not have version plans enabled.`);
+                    }
+                }
+                if (!isReleaseType(value)) {
+                    throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' with an invalid release type. Please specify one of: ${allowedAttributeValues.join(', ')}.`);
+                }
+                if (groupForProject.projectsRelationship === 'independent') {
+                    const existingPlan = (groupForProject.resolvedVersionPlans.find((plan) => plan.fileName === rawVersionPlan.fileName));
+                    if (existingPlan) {
+                        existingPlan.projectVersionBumps[key] = value;
+                    }
+                    else {
+                        groupForProject.resolvedVersionPlans.push({
+                            absolutePath: rawVersionPlan.absolutePath,
+                            relativePath: rawVersionPlan.relativePath,
+                            fileName: rawVersionPlan.fileName,
+                            createdOnMs: rawVersionPlan.createdOnMs,
+                            message: rawVersionPlan.message,
+                            projectVersionBumps: {
+                                [key]: value,
+                            },
+                            commit: await getCommitForVersionPlanFile(rawVersionPlan, isVerbose),
+                        });
+                    }
+                }
+                else {
+                    const existingPlan = (groupForProject.resolvedVersionPlans.find((plan) => plan.fileName === rawVersionPlan.fileName));
+                    // This can occur if the same fixed release group has multiple entries for different projects within
+                    // the same version plan file. This will be the case when users are using the default release group.
+                    if (existingPlan) {
+                        if (existingPlan.groupVersionBump !== value) {
+                            if (isDefaultGroup) {
+                                throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' that conflicts with another version bump. When in fixed versioning mode, all version bumps must match.`);
+                            }
+                            else {
+                                throw new Error(`Found a version bump for project '${key}' in '${rawVersionPlan.fileName}' that conflicts with another project's version bump in the same release group '${groupForProject.name}'. When the group is in fixed versioning mode, all projects' version bumps within the same group must match.`);
+                            }
+                        }
+                        else {
+                            // Avoid duplicates when releaseGraph is reused and version plans are resolved multiple times
+                            if (!existingPlan.triggeredByProjects.includes(key)) {
+                                existingPlan.triggeredByProjects.push(key);
+                            }
+                        }
+                    }
+                    else {
+                        groupForProject.resolvedVersionPlans.push({
+                            absolutePath: rawVersionPlan.absolutePath,
+                            relativePath: rawVersionPlan.relativePath,
+                            fileName: rawVersionPlan.fileName,
+                            createdOnMs: rawVersionPlan.createdOnMs,
+                            message: rawVersionPlan.message,
+                            // This is a fixed group, so the version bump is for the group, even if a project within it was specified
+                            // but we track the projects that triggered the version bump so that we can accurately produce changelog entries.
+                            groupVersionBump: value,
+                            triggeredByProjects: [key],
+                            commit: await getCommitForVersionPlanFile(rawVersionPlan, isVerbose),
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // Order the plans from newest to oldest
+    releaseGroups.forEach((group) => {
+        if (group.resolvedVersionPlans) {
+            group.resolvedVersionPlans.sort((a, b) => b.createdOnMs - a.createdOnMs);
+        }
+    });
+    return releaseGroups;
+}
+function isDefault(releaseGroups) {
+    return (releaseGroups.length === 1 &&
+        releaseGroups.some((group) => group.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP));
+}
+function getVersionPlansAbsolutePath() {
+    return (0, path_1.join)(workspace_root_1.workspaceRoot, versionPlansDirectory);
+}
+function isReleaseType(value) {
+    return semver_1.RELEASE_TYPES.includes(value);
+}
+async function getCommitForVersionPlanFile(rawVersionPlan, isVerbose) {
+    return new Promise((resolve) => {
+        (0, node_child_process_1.exec)(`git log --diff-filter=A --pretty=format:"%s|%h|%an|%ae|%b" -n 1 -- ${rawVersionPlan.absolutePath}`, {
+            windowsHide: false,
+        }, (error, stdout, stderr) => {
+            if (error) {
+                if (isVerbose) {
+                    console.error(`Error executing git command for ${rawVersionPlan.relativePath}: ${error.message}`);
+                }
+                return resolve(null);
+            }
+            if (stderr) {
+                if (isVerbose) {
+                    console.error(`Git command stderr for ${rawVersionPlan.relativePath}: ${stderr}`);
+                }
+                return resolve(null);
+            }
+            const [message, shortHash, authorName, authorEmail, ...body] = stdout
+                .trim()
+                .split('|');
+            const commitDetails = {
+                message: message || '',
+                shortHash: shortHash || '',
+                author: { name: authorName || '', email: authorEmail || '' },
+                body: body.join('|') || '', // Handle case where body might be empty or contain multiple '|'
+            };
+            return resolve(commitDetails);
+        });
+    });
+}