nx 22.0.0-beta.3 → 22.0.0-beta.5

package/src/command-line/release/version/release-group-processor.js

@@ -2,17 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReleaseGroupProcessor = exports.BUMP_TYPE_REASON_TEXT = void 0;
 const semver = require("semver");
-const config_1 = require("../config/config");
 const workspace_root_1 = require("../../../utils/workspace-root");
-const git_1 = require("../utils/git");
+const config_1 = require("../config/config");
 const resolve_semver_specifier_1 = require("../utils/resolve-semver-specifier");
-const shared_1 = require("../utils/shared");
-const version_1 = require("../version");
 const derive_specifier_from_conventional_commits_1 = require("./derive-specifier-from-conventional-commits");
 const deriver_specifier_from_version_plans_1 = require("./deriver-specifier-from-version-plans");
-const project_logger_1 = require("./project-logger");
-const resolve_current_version_1 = require("./resolve-current-version");
-const topological_sort_1 = require("./topological-sort");
 const version_actions_1 = require("./version-actions");
 exports.BUMP_TYPE_REASON_TEXT = {
     DEPENDENCY_WAS_BUMPED: ', because a dependency was bumped, ',
@@ -25,19 +19,12 @@ exports.BUMP_TYPE_REASON_TEXT = {
     NOOP_VERSION_ACTIONS: ', because this project uses docker and has been configured to skip VersionActions, ',
 };
 class ReleaseGroupProcessor {
-    constructor(tree, projectGraph, nxReleaseConfig, releaseGroups, releaseGroupToFilteredProjects, options) {
+    constructor(tree, projectGraph, nxReleaseConfig, releaseGraph, options) {
         this.tree = tree;
         this.projectGraph = projectGraph;
         this.nxReleaseConfig = nxReleaseConfig;
-        this.releaseGroups = releaseGroups;
-        this.releaseGroupToFilteredProjects = releaseGroupToFilteredProjects;
+        this.releaseGraph = releaseGraph;
         this.options = options;
-        /**
-         * Stores the relationships between release groups, including their dependencies
-         * and dependents. This is used for determining processing order and propagating
-         * version changes between related groups.
-         */
-        this.groupGraph = new Map();
         /**
          * Tracks which release groups have already been processed to avoid
          * processing them multiple times. Used during the group traversal.
@@ -49,103 +36,15 @@ class ReleaseGroupProcessor {
          * projects need their dependencies updated.
          */
         this.bumpedProjects = new Set();
-        /**
-         * Cache of release groups sorted in topological order to ensure dependencies
-         * are processed before dependents. Computed once and reused throughout processing.
-         */
-        this.sortedReleaseGroups = [];
-        /**
-         * Maps each release group to its projects sorted in topological order.
-         * Ensures projects are processed after their dependencies within each group.
-         */
-        this.sortedProjects = new Map();
-        /**
-         * Track the unique afterAllProjectsVersioned functions involved in the current versioning process,
-         * so that we can ensure they are only invoked once per versioning execution.
-         */
-        this.uniqueAfterAllProjectsVersioned = new Map();
-        /**
-         * Track the versionActions for each project so that we can invoke certain instance methods.
-         */
-        this.projectsToVersionActions = new Map();
         /**
          * versionData that will ultimately be returned to the nx release version handler by getVersionData()
          */
         this.versionData = new Map();
-        /**
-         * Set of all projects that are configured in the nx release config.
-         * Used to validate dependencies and identify projects that should be updated.
-         */
-        this.allProjectsConfiguredForNxRelease = new Set();
-        /**
-         * Set of projects that will be processed in the current run.
-         * This is potentially a subset of allProjectsConfiguredForNxRelease based on filters
-         * and dependency relationships.
-         */
-        this.allProjectsToProcess = new Set();
-        /**
-         * Caches the current version of each project to avoid repeated disk/registry/git tag lookups.
-         * Often used during new version calculation. Will be null if the current version resolver is set to 'none'.
-         */
-        this.cachedCurrentVersions = new Map();
-        /**
-         * Caches git tag information for projects that resolve their version from git tags.
-         * This avoids performing expensive git operations multiple times for the same project.
-         */
-        this.cachedLatestMatchingGitTag = new Map();
-        /**
-         * Temporary storage for dependent project names while building the dependency graph.
-         * This is used as an intermediate step before creating the full dependent projects data.
-         */
-        this.tmpCachedDependentProjects = new Map();
-        /**
-         * Resolve the data regarding dependent projects for each project upfront so that it remains accurate
-         * even after updates are applied to manifests.
-         */
-        this.originalDependentProjectsPerProject = new Map();
-        /**
-         * In the case of fixed release groups that are configured to resolve the current version from a registry
-         * or a git tag, it would be a waste of time and resources to resolve the current version for each individual
-         * project, therefore we maintain a cache of the current version for each applicable fixed release group here.
-         */
-        this.currentVersionsPerFixedReleaseGroup = new Map();
-        /**
-         * Cache of project loggers for each project.
-         */
-        this.projectLoggers = new Map();
         /**
          * Track any version plan files that have been processed so that we can delete them after versioning is complete,
          * while leaving any unprocessed files in place.
          */
         this.processedVersionPlanFiles = new Set();
-        /**
-         * Certain configuration options can be overridden at the project level, and otherwise fall back to the release group level.
-         * Many also have a specific default value if nothing is set at either level. To avoid applying this hierarchy for each project
-         * every time such a configuration option is needed, we cache the result per project here.
-         */
-        this.finalConfigsByProject = new Map();
-        /**
-         * Maps each project to its release group for quick O(1) lookups.
-         * This avoids having to scan through all release groups to find a project.
-         */
-        this.projectToReleaseGroup = new Map();
-        /**
-         * Maps each project to its dependents (projects that depend on it).
-         * This is the inverse of the projectToDependencies map and enables
-         * efficient lookup of dependent projects for propagating version changes.
-         */
-        this.projectToDependents = new Map();
-        /**
-         * Maps each project to its dependencies (projects it depends on).
-         * Used for building dependency graphs and determining processing order.
-         */
-        this.projectToDependencies = new Map();
-        /**
-         * Caches the updateDependents setting for each project to avoid repeated
-         * lookups and calculations. This determines if dependent projects should
-         * be automatically updated when a dependency changes.
-         */
-        this.projectToUpdateDependentsSetting = new Map();
         /**
          * To match legacy versioning behavior in the case of semver versions with leading "v" characters,
          * e.g. "v1.0.0", we strip the leading "v" and use the rest of the string as the user given specifier
@@ -163,249 +62,22 @@ class ReleaseGroupProcessor {
         else {
             this.userGivenSpecifier = options.userGivenSpecifier;
         }
-    }
-    /**
-     * Initialize the processor by building the group graph and preparing for processing.
-     * This method must be called before processGroups().
-     */
-    async init() {
-        // Precompute project to release group mapping for O(1) lookups
-        this.setupProjectReleaseGroupMapping();
-        // Setup projects to process and resolve version actions
-        await this.setupProjectsToProcess();
-        // Precompute dependency relationships
-        await this.precomputeDependencyRelationships();
-        // Process dependency graph to find dependents to process
-        this.findDependentsToProcess();
-        // Build the group graph structure
-        for (const group of this.releaseGroups) {
-            this.groupGraph.set(group.name, {
-                group,
-                dependencies: new Set(),
-                dependents: new Set(),
+        // Ensure that there is an entry in versionData for each project being processed
+        for (const projectName of this.releaseGraph.allProjectsToProcess) {
+            this.versionData.set(projectName, {
+                currentVersion: this.getCurrentCachedVersionForProject(projectName),
+                newVersion: null,
+                dockerVersion: null,
+                dependentProjects: this.getOriginalDependentProjects(projectName),
             });
         }
-        // Process each project within each release group
-        for (const [, releaseGroupNode] of this.groupGraph) {
-            for (const projectName of releaseGroupNode.group.projects) {
-                const projectGraphNode = this.projectGraph.nodes[projectName];
-                // Check if the project has been filtered out of explicit versioning before continuing any further
-                if (!this.allProjectsToProcess.has(projectName)) {
-                    continue;
-                }
-                const versionActions = this.getVersionActionsForProject(projectName);
-                const finalConfigForProject = this.getFinalConfigForProject(projectName);
-                let latestMatchingGitTag;
-                const releaseTagPattern = releaseGroupNode.group.releaseTagPattern;
-                // Cache the last matching git tag for relevant projects
-                if (finalConfigForProject.currentVersionResolver === 'git-tag') {
-                    latestMatchingGitTag = await (0, git_1.getLatestGitTagForPattern)(releaseTagPattern, {
-                        projectName: projectGraphNode.name,
-                    }, {
-                        checkAllBranchesWhen: releaseGroupNode.group.releaseTagPatternCheckAllBranchesWhen,
-                        preid: this.options.preid,
-                        releaseTagPatternRequireSemver: releaseGroupNode.group.releaseTagPatternRequireSemver,
-                        releaseTagPatternStrictPreid: releaseGroupNode.group.releaseTagPatternStrictPreid,
-                    });
-                    this.cachedLatestMatchingGitTag.set(projectName, latestMatchingGitTag);
-                }
-                // Cache the current version for the project
-                const currentVersion = await (0, resolve_current_version_1.resolveCurrentVersion)(this.tree, projectGraphNode, releaseGroupNode.group, versionActions, this.projectLoggers.get(projectName), this.currentVersionsPerFixedReleaseGroup, finalConfigForProject, releaseTagPattern, latestMatchingGitTag);
-                this.cachedCurrentVersions.set(projectName, currentVersion);
-            }
-            // Ensure that there is an entry in versionData for each project being processed, even if they don't end up being bumped
-            for (const projectName of this.allProjectsToProcess) {
-                this.versionData.set(projectName, {
-                    currentVersion: this.getCurrentCachedVersionForProject(projectName),
-                    newVersion: null,
-                    dockerVersion: null,
-                    dependentProjects: this.getOriginalDependentProjects(projectName),
-                });
-            }
-        }
-        // Build the dependency relationships between groups
-        this.buildGroupDependencyGraph();
-        // Topologically sort the release groups and projects for efficient processing
-        this.sortedReleaseGroups = this.topologicallySortReleaseGroups();
-        // Sort projects within each release group
-        for (const group of this.releaseGroups) {
-            this.sortedProjects.set(group.name, this.topologicallySortProjects(group));
-        }
-        // Populate the dependent projects data
-        await this.populateDependentProjectsData();
-    }
-    /**
-     * Setup mapping from project to release group and cache updateDependents settings
-     */
-    setupProjectReleaseGroupMapping() {
-        for (const group of this.releaseGroups) {
-            for (const project of group.projects) {
-                this.projectToReleaseGroup.set(project, group);
-                // Cache updateDependents setting relevant for each project
-                const updateDependents = group.version
-                    ?.updateDependents || 'auto';
-                this.projectToUpdateDependentsSetting.set(project, updateDependents);
-            }
-        }
-    }
-    /**
-     * Determine which projects should be processed and resolve their version actions
-     */
-    async setupProjectsToProcess() {
-        // Track the projects being directly versioned
-        let projectsToProcess = new Set();
-        const resolveVersionActionsForProjectCallbacks = [];
-        // Precompute all projects in nx release config
-        for (const [groupName, group] of Object.entries(this.nxReleaseConfig.groups)) {
-            for (const project of group.projects) {
-                this.allProjectsConfiguredForNxRelease.add(project);
-                // Create a project logger for the project
-                this.projectLoggers.set(project, new project_logger_1.ProjectLogger(project));
-                // If group filtering is applied and the current group is captured by the filter, add the project to the projectsToProcess
-                if (this.options.filters.groups?.includes(groupName)) {
-                    projectsToProcess.add(project);
-                    // Otherwise, if project filtering is applied and the current project is captured by the filter, add the project to the projectsToProcess
-                }
-                else if (this.options.filters.projects?.includes(project)) {
-                    projectsToProcess.add(project);
-                }
-                const projectGraphNode = this.projectGraph.nodes[project];
-                /**
-                 * Try and resolve a cached ReleaseGroupWithName for the project. It may not be present
-                 * if the user filtered by group and excluded this parent group from direct versioning,
-                 * so fallback to the release group config and apply the name manually.
-                 */
-                let releaseGroup = this.projectToReleaseGroup.get(project);
-                if (!releaseGroup) {
-                    releaseGroup = {
-                        ...group,
-                        name: groupName,
-                        resolvedVersionPlans: false,
-                    };
-                }
-                // Resolve the final configuration for the project
-                const finalConfigForProject = this.resolveFinalConfigForProject(releaseGroup, projectGraphNode);
-                this.finalConfigsByProject.set(project, finalConfigForProject);
-                /**
-                 * For our versionActions validation to accurate, we need to wait until the full allProjectsToProcess
-                 * set is populated so that all dependencies, including those across release groups, are included.
-                 *
-                 * In order to save us fully traversing the graph again to arrive at this project level, schedule a callback
-                 * to resolve the versionActions for the project only once we have all the projects to process.
-                 */
-                resolveVersionActionsForProjectCallbacks.push(async () => {
-                    const { versionActionsPath, versionActions, afterAllProjectsVersioned, } = await (0, version_actions_1.resolveVersionActionsForProject)(this.tree, releaseGroup, projectGraphNode, finalConfigForProject, 
-                    // Will be fully populated by the time this callback is executed
-                    this.allProjectsToProcess.has(project));
-                    if (!this.uniqueAfterAllProjectsVersioned.has(versionActionsPath)) {
-                        this.uniqueAfterAllProjectsVersioned.set(versionActionsPath, afterAllProjectsVersioned);
-                    }
-                    let versionActionsToUse = versionActions;
-                    // Check if this project should skip version actions based on docker configuration
-                    const shouldSkip = (0, shared_1.shouldSkipVersionActions)(finalConfigForProject.dockerOptions, project);
-                    if (shouldSkip) {
-                        versionActionsToUse = new version_actions_1.NOOP_VERSION_ACTIONS(releaseGroup, projectGraphNode, finalConfigForProject);
-                    }
-                    this.projectsToVersionActions.set(project, versionActionsToUse);
-                });
-            }
-        }
-        // If no filters are applied, process all projects
-        if (!this.options.filters.groups?.length &&
-            !this.options.filters.projects?.length) {
-            projectsToProcess = this.allProjectsConfiguredForNxRelease;
-        }
-        // If no projects are set to be processed, throw an error. This should be impossible because the filter validation in version.ts should have already caught this
-        if (projectsToProcess.size === 0) {
-            throw new Error('No projects are set to be processed, please report this as a bug on https://github.com/nrwl/nx/issues');
-        }
-        this.allProjectsToProcess = new Set(projectsToProcess);
-        // Execute all the callbacks to resolve the version actions for the projects
-        for (const cb of resolveVersionActionsForProjectCallbacks) {
-            await cb();
-        }
-    }
-    /**
-     * Find all dependents that should be processed due to dependency updates
-     */
-    findDependentsToProcess() {
-        const projectsToProcess = Array.from(this.allProjectsToProcess);
-        const allTrackedDependents = new Set();
-        const dependentsToProcess = new Set();
-        // BFS traversal of dependency graph to find all transitive dependents
-        let currentLevel = [...projectsToProcess];
-        while (currentLevel.length > 0) {
-            const nextLevel = [];
-            // Get all dependents for the current level at once
-            const dependents = this.getAllNonImplicitDependents(currentLevel);
-            // Process each dependent
-            for (const dep of dependents) {
-                // Skip if we've already seen this dependent or it's already in projectsToProcess
-                if (allTrackedDependents.has(dep) ||
-                    this.allProjectsToProcess.has(dep)) {
-                    continue;
-                }
-                // Track that we've seen this dependent
-                allTrackedDependents.add(dep);
-                // If both the dependent and its dependency have updateDependents='auto',
-                // add the dependent to the projects to process
-                if (this.hasAutoUpdateDependents(dep)) {
-                    // Check if any of its dependencies in the current level have auto update
-                    const hasDependencyWithAutoUpdate = currentLevel.some((proj) => this.hasAutoUpdateDependents(proj) &&
-                        this.getProjectDependents(proj).has(dep));
-                    if (hasDependencyWithAutoUpdate) {
-                        dependentsToProcess.add(dep);
-                    }
-                }
-                // Add to next level for traversal
-                nextLevel.push(dep);
-            }
-            // Move to next level
-            currentLevel = nextLevel;
-        }
-        // Add all dependents that should be processed to allProjectsToProcess
-        dependentsToProcess.forEach((dep) => this.allProjectsToProcess.add(dep));
-    }
-    buildGroupDependencyGraph() {
-        for (const [releaseGroupName, releaseGroupNode] of this.groupGraph) {
-            for (const projectName of releaseGroupNode.group.projects) {
-                const projectDeps = this.getProjectDependencies(projectName);
-                for (const dep of projectDeps) {
-                    const dependencyGroup = this.getReleaseGroupNameForProject(dep);
-                    if (dependencyGroup && dependencyGroup !== releaseGroupName) {
-                        releaseGroupNode.dependencies.add(dependencyGroup);
-                        this.groupGraph
-                            .get(dependencyGroup)
-                            .dependents.add(releaseGroupName);
-                    }
-                }
-            }
-        }
-    }
-    async populateDependentProjectsData() {
-        for (const [projectName, dependentProjectNames] of this
-            .tmpCachedDependentProjects) {
-            const dependentProjectsData = [];
-            for (const dependentProjectName of dependentProjectNames) {
-                const versionActions = this.getVersionActionsForProject(dependentProjectName);
-                const { currentVersion, dependencyCollection } = await versionActions.readCurrentVersionOfDependency(this.tree, this.projectGraph, projectName);
-                dependentProjectsData.push({
-                    source: dependentProjectName,
-                    target: projectName,
-                    type: 'static',
-                    dependencyCollection,
-                    rawVersionSpec: currentVersion,
-                });
-            }
-            this.originalDependentProjectsPerProject.set(projectName, dependentProjectsData);
-        }
     }
     getReleaseGroupNameForProject(projectName) {
-        const group = this.projectToReleaseGroup.get(projectName);
+        const group = this.releaseGraph.projectToReleaseGroup.get(projectName);
         return group ? group.name : null;
     }
     getNextGroup() {
-        for (const [groupName, groupNode] of this.groupGraph) {
+        for (const [groupName, groupNode] of this.releaseGraph.groupGraph) {
             if (!this.processedGroups.has(groupName) &&
                 Array.from(groupNode.dependencies).every((dep) => this.processedGroups.has(dep))) {
                 return groupName;
@@ -415,19 +87,28 @@ class ReleaseGroupProcessor {
     }
     async processGroups() {
         const processOrder = [];
-        // Use the topologically sorted groups instead of getNextGroup
-        for (const nextGroup of this.sortedReleaseGroups) {
+        // Use the topologically sorted groups
+        for (const nextGroup of this.releaseGraph.sortedReleaseGroups) {
             // Skip groups that have already been processed (could happen with circular dependencies)
             if (this.processedGroups.has(nextGroup)) {
                 continue;
             }
-            const allDependenciesProcessed = Array.from(this.groupGraph.get(nextGroup).dependencies).every((dep) => this.processedGroups.has(dep));
+            // The next group might not present in the groupGraph if it has been filtered out
+            if (!this.releaseGraph.groupGraph.has(nextGroup)) {
+                continue;
+            }
+            const allDependenciesProcessed = Array.from(this.releaseGraph.groupGraph.get(nextGroup).dependencies).every((dep) => this.processedGroups.has(dep));
             if (!allDependenciesProcessed) {
                 // If we encounter a group whose dependencies aren't all processed,
                 // it means there's a circular dependency that our topological sort broke.
                 // We need to process any unprocessed dependencies first.
-                for (const dep of this.groupGraph.get(nextGroup).dependencies) {
+                for (const dep of this.releaseGraph.groupGraph.get(nextGroup)
+                    .dependencies) {
                     if (!this.processedGroups.has(dep)) {
+                        // The next group might not present in the groupGraph if it has been filtered out
+                        if (!this.releaseGraph.groupGraph.has(dep)) {
+                            continue;
+                        }
                         await this.processGroup(dep);
                         this.processedGroups.add(dep);
                         processOrder.push(dep);
@@ -441,7 +122,7 @@ class ReleaseGroupProcessor {
         return processOrder;
     }
     flushAllProjectLoggers() {
-        for (const projectLogger of this.projectLoggers.values()) {
+        for (const projectLogger of this.releaseGraph.projectLoggers.values()) {
             projectLogger.flush();
         }
     }
@@ -467,7 +148,7 @@ class ReleaseGroupProcessor {
     async afterAllProjectsVersioned(rootVersionActionsOptions) {
         const changedFiles = new Set();
         const deletedFiles = new Set();
-        for (const [, afterAllProjectsVersioned] of this
+        for (const [, afterAllProjectsVersioned] of this.releaseGraph
             .uniqueAfterAllProjectsVersioned) {
             const { changedFiles: changedFilesForVersionActions, deletedFiles: deletedFilesForVersionActions, } = await afterAllProjectsVersioned(this.tree.root, {
                 dryRun: this.options.dryRun,
@@ -489,7 +170,7 @@ class ReleaseGroupProcessor {
     async processDockerProjects(dockerVersionScheme, dockerVersion) {
         const dockerProjects = new Map();
         for (const project of this.versionData.keys()) {
-            const finalConfigForProject = this.finalConfigsByProject.get(project);
+            const finalConfigForProject = this.releaseGraph.finalConfigsByProject.get(project);
             if (Object.keys(finalConfigForProject.dockerOptions).length === 0) {
                 continue;
             }
@@ -524,8 +205,8 @@ class ReleaseGroupProcessor {
         this.flushAllProjectLoggers();
     }
     async processGroup(releaseGroupName) {
-        const groupNode = this.groupGraph.get(releaseGroupName);
-        const bumped = await this.bumpVersions(groupNode.group);
+        const groupNode = this.releaseGraph.groupGraph.get(releaseGroupName);
+        await this.bumpVersions(groupNode.group);
         // Flush the project loggers for the group
         for (const project of groupNode.group.projects) {
             const projectLogger = this.getProjectLoggerForProject(project);
@@ -551,7 +232,7 @@ class ReleaseGroupProcessor {
             // No direct bump for this group, but we may still need to bump if a dependency group has been bumped
             let bumpedByDependency = false;
             // Use sorted projects to check for dependencies in processed groups
-            const sortedProjects = this.sortedProjects.get(releaseGroup.name) || [];
+            const sortedProjects = this.releaseGraph.sortedProjects.get(releaseGroup.name) || [];
             // Iterate through each project in the release group in topological order
             for (const project of sortedProjects) {
                 const dependencies = this.projectGraph.dependencies[project] || [];
@@ -609,7 +290,8 @@ class ReleaseGroupProcessor {
         }
         const { newVersion } = await this.calculateNewVersion(firstProject, newVersionInput, newVersionInputReason, newVersionInputReasonData);
         // Use sorted projects for processing projects in the right order
-        const sortedProjects = this.sortedProjects.get(releaseGroup.name) || releaseGroup.projects;
+        const sortedProjects = this.releaseGraph.sortedProjects.get(releaseGroup.name) ||
+            releaseGroup.projects;
         // First, update versions for all projects in the fixed group in topological order
         for (const project of sortedProjects) {
             const versionActions = this.getVersionActionsForProject(project);
@@ -645,12 +327,12 @@ class ReleaseGroupProcessor {
         return bumped;
     }
     async bumpIndependentVersionGroup(releaseGroup) {
-        const releaseGroupFilteredProjects = this.releaseGroupToFilteredProjects.get(releaseGroup);
+        const releaseGroupFilteredProjects = this.releaseGraph.releaseGroupToFilteredProjects.get(releaseGroup);
         let bumped = false;
         const projectBumpTypes = new Map();
         const projectsToUpdate = new Set();
-        // First pass: Determine bump types
-        for (const project of this.allProjectsToProcess) {
+        // First pass: Determine bump types (only for projects in this release group)
+        for (const project of releaseGroupFilteredProjects) {
             const { newVersionInput: bumpType, newVersionInputReason: bumpTypeReason, newVersionInputReasonData: bumpTypeReasonData, } = await this.determineVersionBumpForProject(releaseGroup, project);
             projectBumpTypes.set(project, {
                 bumpType,
@@ -663,7 +345,7 @@ class ReleaseGroupProcessor {
         }
         // Second pass: Update versions using topologically sorted projects
         // This ensures dependencies are processed before dependents
-        const sortedProjects = this.sortedProjects.get(releaseGroup.name) || [];
+        const sortedProjects = this.releaseGraph.sortedProjects.get(releaseGroup.name) || [];
         // Process projects in topological order
         for (const project of sortedProjects) {
             if (projectsToUpdate.has(project) &&
@@ -699,7 +381,7 @@ class ReleaseGroupProcessor {
         const cachedFinalConfigForProject = this.getCachedFinalConfigForProject(projectName);
         if (cachedFinalConfigForProject.specifierSource === 'conventional-commits') {
             const currentVersion = this.getCurrentCachedVersionForProject(projectName);
-            const bumpType = await (0, derive_specifier_from_conventional_commits_1.deriveSpecifierFromConventionalCommits)(this.nxReleaseConfig, this.projectGraph, projectLogger, releaseGroup, projectGraphNode, !!semver.prerelease(currentVersion ?? ''), this.cachedLatestMatchingGitTag.get(projectName), cachedFinalConfigForProject.fallbackCurrentVersionResolver, this.options.preid);
+            const bumpType = await (0, derive_specifier_from_conventional_commits_1.deriveSpecifierFromConventionalCommits)(this.nxReleaseConfig, this.projectGraph, projectLogger, releaseGroup, projectGraphNode, !!semver.prerelease(currentVersion ?? ''), this.releaseGraph.cachedLatestMatchingGitTag.get(projectName), cachedFinalConfigForProject.fallbackCurrentVersionResolver, this.options.preid);
             return {
                 newVersionInput: bumpType,
                 newVersionInputReason: 'CONVENTIONAL_COMMITS',
@@ -753,151 +435,29 @@ class ReleaseGroupProcessor {
         throw new Error(`Unhandled version bump config, please report this as a bug on https://github.com/nrwl/nx/issues`);
     }
     getVersionActionsForProject(projectName) {
-        const versionActions = this.projectsToVersionActions.get(projectName);
+        const versionActions = this.releaseGraph.projectsToVersionActions.get(projectName);
         if (!versionActions) {
             throw new Error(`No versionActions found for project ${projectName}, please report this as a bug on https://github.com/nrwl/nx/issues`);
         }
         return versionActions;
     }
-    getFinalConfigForProject(projectName) {
-        const finalConfig = this.finalConfigsByProject.get(projectName);
-        if (!finalConfig) {
-            throw new Error(`No final config found for project ${projectName}, please report this as a bug on https://github.com/nrwl/nx/issues`);
-        }
-        return finalConfig;
-    }
     getProjectLoggerForProject(projectName) {
-        const projectLogger = this.projectLoggers.get(projectName);
+        const projectLogger = this.releaseGraph.projectLoggers.get(projectName);
         if (!projectLogger) {
             throw new Error(`No project logger found for project ${projectName}, please report this as a bug on https://github.com/nrwl/nx/issues`);
         }
         return projectLogger;
     }
     getCurrentCachedVersionForProject(projectName) {
-        return this.cachedCurrentVersions.get(projectName);
+        return this.releaseGraph.cachedCurrentVersions.get(projectName);
     }
     getCachedFinalConfigForProject(projectName) {
-        const cachedFinalConfig = this.finalConfigsByProject.get(projectName);
+        const cachedFinalConfig = this.releaseGraph.finalConfigsByProject.get(projectName);
         if (!cachedFinalConfig) {
             throw new Error(`Unexpected error: No cached config found for project ${projectName}, please report this as a bug on https://github.com/nrwl/nx/issues`);
         }
         return cachedFinalConfig;
     }
-    /**
-     * Apply project and release group precedence and default values, as well as validate the final configuration,
-     * ready to be cached.
-     */
-    resolveFinalConfigForProject(releaseGroup, projectGraphNode) {
-        const releaseGroupVersionConfig = releaseGroup.version;
-        const projectVersionConfig = projectGraphNode.data.release?.version;
-        const projectDockerConfig = projectGraphNode.data.release?.docker;
-        /**
-         * specifierSource
-         *
-         * If the user has provided a specifier, it always takes precedence,
-         * so the effective specifier source is 'prompt', regardless of what
-         * the project or release group config says.
-         */
-        const specifierSource = this.userGivenSpecifier
-            ? 'prompt'
-            : projectVersionConfig?.specifierSource ??
-                releaseGroupVersionConfig?.specifierSource ??
-                'prompt';
-        /**
-         * versionPrefix, defaults to auto
-         */
-        const versionPrefix = projectVersionConfig?.versionPrefix ??
-            releaseGroupVersionConfig?.versionPrefix ??
-            'auto';
-        if (versionPrefix && !version_1.validReleaseVersionPrefixes.includes(versionPrefix)) {
-            throw new Error(`Invalid value for versionPrefix: "${versionPrefix}"
-
-Valid values are: ${version_1.validReleaseVersionPrefixes
-                .map((s) => `"${s}"`)
-                .join(', ')}`);
-        }
-        // Merge docker options configured in project with release group config
-        // Project level configuration should take preference
-        const dockerOptions = {
-            ...(releaseGroup.docker ?? {}),
-            ...(projectDockerConfig ?? {}),
-        };
-        /**
-         * currentVersionResolver, defaults to disk
-         */
-        let currentVersionResolver = projectVersionConfig?.currentVersionResolver ??
-            releaseGroupVersionConfig?.currentVersionResolver ??
-            'disk';
-        // Check if this project should skip version actions based on docker configuration
-        const shouldSkip = (0, shared_1.shouldSkipVersionActions)(dockerOptions, projectGraphNode.name);
-        if (shouldSkip) {
-            // If the project skips version actions, it doesn't need to resolve a current version
-            currentVersionResolver = 'none';
-        }
-        else if (specifierSource === 'conventional-commits' &&
-            currentVersionResolver !== 'git-tag') {
-            throw new Error(`Invalid currentVersionResolver "${currentVersionResolver}" provided for project "${projectGraphNode.name}". Must be "git-tag" when "specifierSource" is "conventional-commits"`);
-        }
-        /**
-         * currentVersionResolverMetadata, defaults to {}
-         */
-        const currentVersionResolverMetadata = projectVersionConfig?.currentVersionResolverMetadata ??
-            releaseGroupVersionConfig?.currentVersionResolverMetadata ??
-            {};
-        /**
-         * preserveLocalDependencyProtocols
-         *
-         * This was false by default in legacy versioning, but is true by default now.
-         */
-        const preserveLocalDependencyProtocols = projectVersionConfig?.preserveLocalDependencyProtocols ??
-            releaseGroupVersionConfig?.preserveLocalDependencyProtocols ??
-            true;
-        const preserveMatchingDependencyRanges = projectVersionConfig?.preserveMatchingDependencyRanges ??
-            releaseGroupVersionConfig?.preserveMatchingDependencyRanges ??
-            true;
-        /**
-         * fallbackCurrentVersionResolver, defaults to disk when performing a first release, otherwise undefined
-         */
-        const fallbackCurrentVersionResolver = projectVersionConfig?.fallbackCurrentVersionResolver ??
-            releaseGroupVersionConfig?.fallbackCurrentVersionResolver ??
-            // Always fall back to disk if this is the first release
-            (this.options.firstRelease ? 'disk' : undefined);
-        /**
-         * versionActionsOptions, defaults to {}
-         */
-        let versionActionsOptions = projectVersionConfig?.versionActionsOptions ??
-            releaseGroupVersionConfig?.versionActionsOptions ??
-            {};
-        // Apply any optional overrides that may be passed in from the programmatic API
-        versionActionsOptions = {
-            ...versionActionsOptions,
-            ...(this.options.versionActionsOptionsOverrides ?? {}),
-        };
-        const manifestRootsToUpdate = (projectVersionConfig?.manifestRootsToUpdate ??
-            releaseGroupVersionConfig?.manifestRootsToUpdate ??
-            []).map((manifestRoot) => {
-            if (typeof manifestRoot === 'string') {
-                return {
-                    path: manifestRoot,
-                    // Apply the project level preserveLocalDependencyProtocols setting that was already resolved
-                    preserveLocalDependencyProtocols,
-                };
-            }
-            return manifestRoot;
-        });
-        return {
-            specifierSource,
-            currentVersionResolver,
-            currentVersionResolverMetadata,
-            fallbackCurrentVersionResolver,
-            versionPrefix,
-            preserveLocalDependencyProtocols,
-            preserveMatchingDependencyRanges,
-            versionActionsOptions,
-            manifestRootsToUpdate,
-            dockerOptions,
-        };
-    }
     async calculateNewVersion(project, newVersionInput, // any arbitrary string, whether or not it is valid is dependent upon the version actions implementation
     newVersionInputReason, newVersionInputReasonData) {
         const currentVersion = this.getCurrentCachedVersionForProject(project);
@@ -908,7 +468,7 @@ Valid values are: ${version_1.validReleaseVersionPrefixes
         return { currentVersion, newVersion };
     }
     async updateDependenciesForProject(projectName) {
-        if (!this.allProjectsToProcess.has(projectName)) {
+        if (!this.releaseGraph.allProjectsToProcess.has(projectName)) {
             throw new Error(`Unable to find ${projectName} in allProjectsToProcess, please report this as a bug on https://github.com/nrwl/nx/issues`);
         }
         const versionActions = this.getVersionActionsForProject(projectName);
@@ -916,7 +476,7 @@ Valid values are: ${version_1.validReleaseVersionPrefixes
         const dependenciesToUpdate = {};
         const dependencies = this.projectGraph.dependencies[projectName] || [];
         for (const dep of dependencies) {
-            if (this.allProjectsToProcess.has(dep.target) &&
+            if (this.releaseGraph.allProjectsToProcess.has(dep.target) &&
                 this.bumpedProjects.has(dep.target)) {
                 const targetVersionData = this.versionData.get(dep.target);
                 if (targetVersionData) {
@@ -973,18 +533,18 @@ Valid values are: ${version_1.validReleaseVersionPrefixes
             projectLogger.buffer(`⚠️ Cannot find release group for ${projectName}, skipping dependent updates`);
             return;
         }
-        const releaseGroup = this.groupGraph.get(releaseGroupName).group;
+        const releaseGroup = this.releaseGraph.groupGraph.get(releaseGroupName).group;
         const releaseGroupVersionConfig = releaseGroup.version;
         // Get updateDependents from the release group level config
-        const updateDependents = releaseGroupVersionConfig?.updateDependents ||
-            'auto';
-        // Only update dependencies for dependents if the group's updateDependents is 'auto'
-        if (updateDependents === 'auto') {
+        const updateDependents = releaseGroupVersionConfig?.updateDependents || 'always';
+        // Only update dependencies for dependents if the group's updateDependents is 'auto' or 'always'
+        if (updateDependents === 'auto' || updateDependents === 'always') {
             const dependents = this.getNonImplicitDependentsForProject(projectName);
-            await this.updateDependenciesForDependents(dependents);
-            for (const dependent of dependents) {
-                if (this.allProjectsToProcess.has(dependent) &&
-                    !this.bumpedProjects.has(dependent)) {
+            // Only process dependents that are actually being processed
+            const dependentsToProcess = dependents.filter((dep) => this.releaseGraph.allProjectsToProcess.has(dep));
+            await this.updateDependenciesForDependents(dependentsToProcess);
+            for (const dependent of dependentsToProcess) {
+                if (!this.bumpedProjects.has(dependent)) {
                     await this.bumpVersionForProject(dependent, 'patch', 'DEPENDENCY_WAS_BUMPED', {});
                 }
             }
@@ -998,18 +558,18 @@ Valid values are: ${version_1.validReleaseVersionPrefixes
     }
     async updateDependenciesForDependents(dependents) {
         for (const dependent of dependents) {
-            if (!this.allProjectsToProcess.has(dependent)) {
+            if (!this.releaseGraph.allProjectsToProcess.has(dependent)) {
                 throw new Error(`Unable to find project "${dependent}" in allProjectsToProcess, please report this as a bug on https://github.com/nrwl/nx/issues`);
             }
             await this.updateDependenciesForProject(dependent);
         }
     }
     getOriginalDependentProjects(project) {
-        return this.originalDependentProjectsPerProject.get(project) || [];
+        return (this.releaseGraph.originalDependentProjectsPerProject.get(project) || []);
     }
     async getFixedReleaseGroupBumpType(releaseGroupName) {
-        const releaseGroup = this.groupGraph.get(releaseGroupName).group;
-        const releaseGroupFilteredProjects = this.releaseGroupToFilteredProjects.get(releaseGroup);
+        const releaseGroup = this.releaseGraph.groupGraph.get(releaseGroupName).group;
+        const releaseGroupFilteredProjects = this.releaseGraph.releaseGroupToFilteredProjects.get(releaseGroup);
         if (releaseGroupFilteredProjects.size === 0) {
             return 'none';
         }
@@ -1029,82 +589,11 @@ Valid values are: ${version_1.validReleaseVersionPrefixes
         return sideEffectBump;
     }
     getProjectDependents(project) {
-        return this.projectToDependents.get(project) || new Set();
-    }
-    getAllNonImplicitDependents(projects) {
-        return projects
-            .flatMap((project) => {
-            const dependentProjectNames = this.getNonImplicitDependentsForProject(project);
-            this.tmpCachedDependentProjects.set(project, dependentProjectNames);
-            return dependentProjectNames;
-        })
-            .filter((dep) => !this.allProjectsToProcess.has(dep));
+        return this.releaseGraph.projectToDependents.get(project) || new Set();
     }
     getNonImplicitDependentsForProject(project) {
         // Use the cached dependents for O(1) lookup instead of O(n) scan
         return Array.from(this.getProjectDependents(project));
     }
-    hasAutoUpdateDependents(projectName) {
-        return this.projectToUpdateDependentsSetting.get(projectName) === 'auto';
-    }
-    topologicallySortReleaseGroups() {
-        // Get all release group names
-        const groupNames = Array.from(this.groupGraph.keys());
-        // Function to get dependencies of a group
-        const getGroupDependencies = (groupName) => {
-            const groupNode = this.groupGraph.get(groupName);
-            if (!groupNode) {
-                return [];
-            }
-            return Array.from(groupNode.dependencies);
-        };
-        // Perform topological sort
-        return (0, topological_sort_1.topologicalSort)(groupNames, getGroupDependencies);
-    }
-    topologicallySortProjects(releaseGroup) {
-        // For fixed relationship groups, the order doesn't matter since all projects will
-        // be versioned identically, but we still sort them for consistency
-        const projects = releaseGroup.projects.filter((p) => 
-        // Only include projects that are in allProjectsToProcess
-        this.allProjectsToProcess.has(p));
-        // Function to get dependencies of a project that are in the same release group
-        const getProjectDependenciesInSameGroup = (project) => {
-            const deps = this.getProjectDependencies(project);
-            // Only include dependencies that are in the same release group and in allProjectsToProcess
-            return Array.from(deps).filter((dep) => this.getReleaseGroupNameForProject(dep) === releaseGroup.name &&
-                this.allProjectsToProcess.has(dep));
-        };
-        // Perform topological sort
-        return (0, topological_sort_1.topologicalSort)(projects, getProjectDependenciesInSameGroup);
-    }
-    /**
-     * Precompute project -> dependents/dependencies relationships for O(1) lookups
-     */
-    async precomputeDependencyRelationships() {
-        for (const projectName of this.allProjectsConfiguredForNxRelease) {
-            const versionActions = this.projectsToVersionActions.get(projectName);
-            // Create a new set for this project's dependencies
-            if (!this.projectToDependencies.has(projectName)) {
-                this.projectToDependencies.set(projectName, new Set());
-            }
-            const deps = await versionActions.readDependencies(this.tree, this.projectGraph);
-            for (const dep of deps) {
-                // Skip dependencies not covered by nx release
-                if (!this.allProjectsConfiguredForNxRelease.has(dep.target)) {
-                    continue;
-                }
-                // Add this dependency to the project's dependencies
-                this.projectToDependencies.get(projectName).add(dep.target);
-                // Add this project as a dependent of the target
-                if (!this.projectToDependents.has(dep.target)) {
-                    this.projectToDependents.set(dep.target, new Set());
-                }
-                this.projectToDependents.get(dep.target).add(projectName);
-            }
-        }
-    }
-    getProjectDependencies(project) {
-        return this.projectToDependencies.get(project) || new Set();
-    }
 }
 exports.ReleaseGroupProcessor = ReleaseGroupProcessor;