release-please 14.10.2 → 14.11.1

package/CHANGELOG.md

@@ -4,6 +4,20 @@
 
 [1]: https://www.npmjs.com/package/release-please?activeTab=versions
 
+## [14.11.1](https://github.com/googleapis/release-please/compare/v14.11.0...v14.11.1) (2022-10-10)
+
+
+### Bug Fixes
+
+* Explicitly sort PRs by updated desc ([#1685](https://github.com/googleapis/release-please/issues/1685)) ([807bda0](https://github.com/googleapis/release-please/commit/807bda0ab3e09e6116b43cd670bab1115bfdbff2))
+
+## [14.11.0](https://github.com/googleapis/release-please/compare/v14.10.2...v14.11.0) (2022-10-05)
+
+
+### Features
+
+* **maven-workspace:** Update all discovered pom.xml within the components ([#1667](https://github.com/googleapis/release-please/issues/1667)) ([ace68d3](https://github.com/googleapis/release-please/commit/ace68d346291db6b591b9b3e1735d12f0a2b2bbc))
+
 ## [14.10.2](https://github.com/googleapis/release-please/compare/v14.10.1...v14.10.2) (2022-10-04)
 
 

package/build/src/factories/plugin-factory.d.ts

@@ -2,6 +2,7 @@ import { PluginType, RepositoryConfig } from '../manifest';
 import { GitHub } from '../github';
 import { ManifestPlugin } from '../plugin';
 import { VersioningStrategyType } from './versioning-strategy-factory';
+import { Logger } from '../util/logger';
 export interface PluginFactoryOptions {
     type: PluginType;
     github: GitHub;
@@ -10,6 +11,8 @@ export interface PluginFactoryOptions {
     manifestPath: string;
     alwaysLinkLocal?: boolean;
     updateAllPackages?: boolean;
+    considerAllArtifacts?: boolean;
+    logger?: Logger;
 }
 export declare type PluginBuilder = (options: PluginFactoryOptions) => ManifestPlugin;
 export declare function buildPlugin(options: PluginFactoryOptions): ManifestPlugin;

package/build/src/factories/plugin-factory.js

@@ -23,9 +23,18 @@ const sentence_case_1 = require("../plugins/sentence-case");
 const group_priority_1 = require("../plugins/group-priority");
 const pluginFactories = {
     'linked-versions': options => new linked_versions_1.LinkedVersions(options.github, options.targetBranch, options.repositoryConfig, options.type.groupName, options.type.components),
-    'cargo-workspace': options => new cargo_workspace_1.CargoWorkspace(options.github, options.targetBranch, options.repositoryConfig, options),
-    'node-workspace': options => new node_workspace_1.NodeWorkspace(options.github, options.targetBranch, options.repositoryConfig, options),
-    'maven-workspace': options => new maven_workspace_1.MavenWorkspace(options.github, options.targetBranch, options.repositoryConfig, options),
+    'cargo-workspace': options => new cargo_workspace_1.CargoWorkspace(options.github, options.targetBranch, options.repositoryConfig, {
+        ...options,
+        ...options.type,
+    }),
+    'node-workspace': options => new node_workspace_1.NodeWorkspace(options.github, options.targetBranch, options.repositoryConfig, {
+        ...options,
+        ...options.type,
+    }),
+    'maven-workspace': options => new maven_workspace_1.MavenWorkspace(options.github, options.targetBranch, options.repositoryConfig, {
+        ...options,
+        ...options.type,
+    }),
     'sentence-case': options => new sentence_case_1.SentenceCase(options.github, options.targetBranch, options.repositoryConfig, options.type.specialWords),
     'group-priority': options => new group_priority_1.GroupPriority(options.github, options.targetBranch, options.repositoryConfig, options.type.groups),
 };

package/build/src/github.js

@@ -676,6 +676,8 @@ class GitHub {
             owner: this.repository.owner,
             repo: this.repository.repo,
             base: targetBranch,
+            sort: 'updated',
+            direction: 'desc',
         })) {
             for (const pull of pulls) {
                 // The REST API does not have an option for "merged"

package/build/src/manifest.d.ts

@@ -146,6 +146,7 @@ export interface SentenceCasePluginConfig extends ConfigurablePluginType {
 }
 export interface WorkspacePluginConfig extends ConfigurablePluginType {
     merge?: boolean;
+    considerAllArtifacts?: boolean;
 }
 export interface GroupPriorityPluginConfig extends ConfigurablePluginType {
     groups: string[];

package/build/src/plugins/maven-workspace.d.ts

@@ -1,6 +1,7 @@
-import { WorkspacePlugin, AllPackages, DependencyGraph } from './workspace';
+import { WorkspacePlugin, AllPackages, DependencyGraph, WorkspacePluginOptions } from './workspace';
 import { Version, VersionsMap } from '../version';
-import { CandidateReleasePullRequest } from '../manifest';
+import { CandidateReleasePullRequest, RepositoryConfig } from '../manifest';
+import { GitHub } from '../github';
 interface Gav {
     groupId: string;
     artifactId: string;
@@ -11,11 +12,56 @@ interface MavenArtifact extends Gav {
     name: string;
     dependencies: Gav[];
     testDependencies: Gav[];
+    managedDependencies: Gav[];
     pomContent: string;
 }
+interface MavenWorkspacePluginOptions extends WorkspacePluginOptions {
+    considerAllArtifacts?: boolean;
+}
 export declare class MavenWorkspace extends WorkspacePlugin<MavenArtifact> {
+    readonly considerAllArtifacts: boolean;
+    constructor(github: GitHub, targetBranch: string, repositoryConfig: RepositoryConfig, options?: MavenWorkspacePluginOptions);
     private fetchPom;
     protected buildAllPackages(candidates: CandidateReleasePullRequest[]): Promise<AllPackages<MavenArtifact>>;
+    /**
+     * Our maven components can have multiple artifacts if using
+     * `considerAllArtifacts`. Find the candidate release for the component
+     * that contains that maven artifact.
+     * @param {MavenArtifact} pkg The artifact to search for
+     * @param {Record<string, CandidateReleasePullRequest} candidatesByPackage
+     *   The candidate pull requests indexed by the package name.
+     * @returns {CandidateReleasePullRequest | undefined} The associated
+     *   candidate release or undefined if there is no existing release yet
+     */
+    protected findCandidateForPackage(pkg: MavenArtifact, candidatesByPackage: Record<string, CandidateReleasePullRequest>): CandidateReleasePullRequest | undefined;
+    /**
+     * Helper to determine which packages we will use to base our search
+     * for touched packages upon. These are usually the packages that
+     * have candidate pull requests open.
+     *
+     * If you configure `updateAllPackages`, we fill force update all
+     * packages as if they had a release.
+     * @param {DependencyGraph<T>} graph All the packages in the repository
+     * @param {Record<string, CandidateReleasePullRequest} candidatesByPackage
+     *   The candidate pull requests indexed by the package name.
+     * @returns {string[]} Package names to
+     */
+    protected packageNamesToUpdate(graph: DependencyGraph<MavenArtifact>, candidatesByPackage: Record<string, CandidateReleasePullRequest>): string[];
+    /**
+     * Helper to build up all the versions we are modifying in this
+     * repository.
+     * @param {DependencyGraph<T>} graph All the packages in the repository
+     * @param {T[]} orderedPackages A list of packages that are currently
+     *   updated by the existing candidate pull requests
+     * @param {Record<string, CandidateReleasePullRequest} candidatesByPackage
+     *   The candidate pull requests indexed by the package name.
+     * @returns A map of all updated versions (package name => Version) and a
+     *   map of all updated versions (component path => Version).
+     */
+    protected buildUpdatedVersions(_graph: DependencyGraph<MavenArtifact>, orderedPackages: MavenArtifact[], candidatesByPackage: Record<string, CandidateReleasePullRequest>): Promise<{
+        updatedVersions: VersionsMap;
+        updatedPathVersions: VersionsMap;
+    }>;
     protected buildGraph(allPackages: MavenArtifact[]): Promise<DependencyGraph<MavenArtifact>>;
     protected bumpVersion(artifact: MavenArtifact): Version;
     protected updateCandidate(existingCandidate: CandidateReleasePullRequest, artifact: MavenArtifact, updatedVersions: VersionsMap): CandidateReleasePullRequest;

package/build/src/plugins/maven-workspace.js

@@ -16,7 +16,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MavenWorkspace = void 0;
 const workspace_1 = require("./workspace");
 const version_1 = require("../version");
-const versioning_strategy_1 = require("../versioning-strategy");
 const dom = require("@xmldom/xmldom");
 const xpath = require("xpath");
 const path_1 = require("path");
@@ -26,65 +25,24 @@ const pull_request_title_1 = require("../util/pull-request-title");
 const pull_request_body_1 = require("../util/pull-request-body");
 const branch_name_1 = require("../util/branch-name");
 const logger_1 = require("../util/logger");
+const java_snapshot_1 = require("../versioning-strategies/java-snapshot");
+const always_bump_patch_1 = require("../versioning-strategies/always-bump-patch");
 const composite_1 = require("../updaters/composite");
 const JAVA_RELEASE_TYPES = new Set(['java', 'java-bom', 'java-yoshi', 'maven']);
 const XPATH_PROJECT_GROUP = '/*[local-name()="project"]/*[local-name()="groupId"]';
 const XPATH_PROJECT_ARTIFACT = '/*[local-name()="project"]/*[local-name()="artifactId"]';
 const XPATH_PROJECT_VERSION = '/*[local-name()="project"]/*[local-name()="version"]';
 const XPATH_PROJECT_DEPENDENCIES = '/*[local-name()="project"]/*[local-name()="dependencies"]/*[local-name()="dependency"]';
+const XPATH_PROJECT_DEPENDENCY_MANAGEMENT_DEPENDENCIES = '/*[local-name()="project"]/*[local-name()="dependencyManagement"]/*[local-name()="dependencies"]/*[local-name()="dependency"]';
 class MavenWorkspace extends workspace_1.WorkspacePlugin {
+    constructor(github, targetBranch, repositoryConfig, options = {}) {
+        var _a;
+        super(github, targetBranch, repositoryConfig, options);
+        this.considerAllArtifacts = (_a = options.considerAllArtifacts) !== null && _a !== void 0 ? _a : true;
+    }
     async fetchPom(path) {
         const content = await this.github.getFileContentsOnBranch(path, this.targetBranch);
-        const document = new dom.DOMParser().parseFromString(content.parsedContent);
-        const groupNodes = xpath.select(XPATH_PROJECT_GROUP, document);
-        if (groupNodes.length === 0) {
-            this.logger.warn(`Missing project.groupId in ${path}`);
-            return;
-        }
-        const artifactNodes = xpath.select(XPATH_PROJECT_ARTIFACT, document);
-        if (artifactNodes.length === 0) {
-            this.logger.warn(`Missing project.artifactId in ${path}`);
-            return;
-        }
-        const versionNodes = xpath.select(XPATH_PROJECT_VERSION, document);
-        if (versionNodes.length === 0) {
-            this.logger.warn(`Missing project.version in ${path}`);
-            return;
-        }
-        const dependencies = [];
-        const testDependencies = [];
-        for (const dependencyNode of xpath.select(XPATH_PROJECT_DEPENDENCIES, document)) {
-            const parsedNode = (0, pom_xml_1.parseDependencyNode)(dependencyNode);
-            if (!parsedNode.version) {
-                continue;
-            }
-            if (parsedNode.scope === 'test') {
-                testDependencies.push({
-                    groupId: parsedNode.groupId,
-                    artifactId: parsedNode.artifactId,
-                    version: parsedNode.version,
-                });
-            }
-            else {
-                dependencies.push({
-                    groupId: parsedNode.groupId,
-                    artifactId: parsedNode.artifactId,
-                    version: parsedNode.version,
-                });
-            }
-        }
-        const groupId = groupNodes[0].firstChild.textContent;
-        const artifactId = artifactNodes[0].firstChild.textContent;
-        return {
-            path,
-            groupId,
-            artifactId,
-            name: `${groupId}:${artifactId}`,
-            version: versionNodes[0].firstChild.textContent,
-            dependencies,
-            testDependencies,
-            pomContent: content.parsedContent,
-        };
+        return parseMavenArtifact(content.parsedContent, path, this.logger);
     }
     async buildAllPackages(candidates) {
         const allPackages = [];
@@ -95,8 +53,11 @@ class MavenWorkspace extends workspace_1.WorkspacePlugin {
             const path = (0, path_1.dirname)(pomFile);
             const config = this.repositoryConfig[path];
             if (!config) {
-                this.logger.info(`path '${path}' not configured, ignoring '${pomFile}'`);
-                continue;
+                if (!this.considerAllArtifacts) {
+                    this.logger.info(`path '${path}' not configured, ignoring '${pomFile}'`);
+                    continue;
+                }
+                this.logger.info(`path '${path}' not configured, but 'considerAllArtifacts' option enabled`);
             }
             const mavenArtifact = await this.fetchPom(pomFile);
             if (!mavenArtifact) {
@@ -117,16 +78,126 @@ class MavenWorkspace extends workspace_1.WorkspacePlugin {
             candidatesByPackage,
         };
     }
+    /**
+     * Our maven components can have multiple artifacts if using
+     * `considerAllArtifacts`. Find the candidate release for the component
+     * that contains that maven artifact.
+     * @param {MavenArtifact} pkg The artifact to search for
+     * @param {Record<string, CandidateReleasePullRequest} candidatesByPackage
+     *   The candidate pull requests indexed by the package name.
+     * @returns {CandidateReleasePullRequest | undefined} The associated
+     *   candidate release or undefined if there is no existing release yet
+     */
+    findCandidateForPackage(pkg, candidatesByPackage) {
+        this.logger.debug(`Looking for existing candidate for ${pkg.name}`);
+        const packageName = this.packageNameFromPackage(pkg);
+        const existingCandidate = candidatesByPackage[packageName];
+        if (existingCandidate) {
+            return existingCandidate;
+        }
+        // fall back to finding the nearest candidate for that artifact
+        return Object.values(candidatesByPackage).find(candidate => pkg.path.startsWith(`${candidate.path}/`));
+    }
+    /**
+     * Helper to determine which packages we will use to base our search
+     * for touched packages upon. These are usually the packages that
+     * have candidate pull requests open.
+     *
+     * If you configure `updateAllPackages`, we fill force update all
+     * packages as if they had a release.
+     * @param {DependencyGraph<T>} graph All the packages in the repository
+     * @param {Record<string, CandidateReleasePullRequest} candidatesByPackage
+     *   The candidate pull requests indexed by the package name.
+     * @returns {string[]} Package names to
+     */
+    packageNamesToUpdate(graph, candidatesByPackage) {
+        if (this.considerAllArtifacts) {
+            const candidatePaths = Object.values(candidatesByPackage).map(candidate => candidate.path);
+            // Find artifacts that are in an existing candidate release
+            return Array.from(graph.values())
+                .filter(({ value }) => candidatePaths.find(path => value.path === path || value.path.startsWith(`${path}/`)))
+                .map(({ value }) => this.packageNameFromPackage(value));
+        }
+        return super.packageNamesToUpdate(graph, candidatesByPackage);
+    }
+    /**
+     * Helper to build up all the versions we are modifying in this
+     * repository.
+     * @param {DependencyGraph<T>} graph All the packages in the repository
+     * @param {T[]} orderedPackages A list of packages that are currently
+     *   updated by the existing candidate pull requests
+     * @param {Record<string, CandidateReleasePullRequest} candidatesByPackage
+     *   The candidate pull requests indexed by the package name.
+     * @returns A map of all updated versions (package name => Version) and a
+     *   map of all updated versions (component path => Version).
+     */
+    async buildUpdatedVersions(_graph, orderedPackages, candidatesByPackage) {
+        const updatedVersions = new Map();
+        const updatedPathVersions = new Map();
+        // Look for updated pom.xml files
+        for (const [_, candidate] of Object.entries(candidatesByPackage)) {
+            const pomUpdates = candidate.pullRequest.updates.filter(update => update.path.endsWith('pom.xml'));
+            for (const pomUpdate of pomUpdates) {
+                if (!pomUpdate.cachedFileContents) {
+                    pomUpdate.cachedFileContents =
+                        await this.github.getFileContentsOnBranch(pomUpdate.path, this.targetBranch);
+                }
+                if (pomUpdate.cachedFileContents) {
+                    // pre-run the version updater on this artifact and extract the
+                    // new version
+                    const updatedArtifact = parseMavenArtifact(pomUpdate.updater.updateContent(pomUpdate.cachedFileContents.parsedContent), pomUpdate.path, this.logger);
+                    if (updatedArtifact) {
+                        this.logger.debug(`updating ${updatedArtifact.name} to ${updatedArtifact.version}`);
+                        updatedVersions.set(updatedArtifact.name, version_1.Version.parse(updatedArtifact.version));
+                    }
+                }
+                else {
+                    this.logger.warn(`${pomUpdate.path} does not have cached contents`);
+                }
+            }
+            if (candidate.pullRequest.version) {
+                updatedPathVersions.set(candidate.path, candidate.pullRequest.version);
+            }
+        }
+        for (const pkg of orderedPackages) {
+            const packageName = this.packageNameFromPackage(pkg);
+            this.logger.debug(`Looking for next version for: ${packageName}`);
+            const existingCandidate = candidatesByPackage[packageName];
+            if (existingCandidate) {
+                const version = existingCandidate.pullRequest.version;
+                this.logger.debug(`version: ${version} from release-please`);
+                updatedVersions.set(packageName, version);
+            }
+            else {
+                const version = this.bumpVersion(pkg);
+                if (updatedVersions.get(packageName)) {
+                    this.logger.debug('version already set');
+                }
+                else {
+                    this.logger.debug(`version: ${version} forced bump`);
+                    updatedVersions.set(packageName, version);
+                    updatedPathVersions.set(this.pathFromPackage(pkg), version);
+                }
+            }
+        }
+        return {
+            updatedVersions,
+            updatedPathVersions,
+        };
+    }
     async buildGraph(allPackages) {
+        this.logger.trace('building graph', allPackages);
         const artifactsByName = allPackages.reduce((collection, mavenArtifact) => {
             collection[mavenArtifact.name] = mavenArtifact;
             return collection;
         }, {});
+        this.logger.trace('artifacts by name', artifactsByName);
         const graph = new Map();
         for (const mavenArtifact of allPackages) {
             const allDeps = [
                 ...mavenArtifact.dependencies,
                 ...mavenArtifact.testDependencies,
+                ...mavenArtifact.managedDependencies,
             ];
             const workspaceDeps = allDeps.filter(dep => artifactsByName[packageNameFromGav(dep)]);
             graph.set(mavenArtifact.name, {
@@ -137,8 +208,8 @@ class MavenWorkspace extends workspace_1.WorkspacePlugin {
         return graph;
     }
     bumpVersion(artifact) {
-        const version = version_1.Version.parse(artifact.version);
-        return new versioning_strategy_1.PatchVersionUpdate().bump(version);
+        const strategy = new java_snapshot_1.JavaSnapshot(new always_bump_patch_1.AlwaysBumpPatch());
+        return strategy.bump(version_1.Version.parse(artifact.version), [FAKE_COMMIT]);
     }
     updateCandidate(existingCandidate, artifact, updatedVersions) {
         const version = updatedVersions.get(artifact.name);
@@ -251,4 +322,91 @@ function getChangelogDepsNotes(artifact, updater, updatedVersions, logger = logg
     }
     return '';
 }
+/**
+ * Helper to parse a pom.xml file and extract important fields
+ * @param {string} pomContent The XML contents as a string
+ * @param {string} path The path to the file in the repository including the filename.
+ * @param {Logger} logger Context logger
+ * @returns {MavenArtifact | undefined} Returns undefined if we are missing key
+ *   attributes. We log a warning in these cases.
+ */
+function parseMavenArtifact(pomContent, path, logger) {
+    const document = new dom.DOMParser().parseFromString(pomContent);
+    const groupNodes = xpath.select(XPATH_PROJECT_GROUP, document);
+    if (groupNodes.length === 0) {
+        logger.warn(`Missing project.groupId in ${path}`);
+        return;
+    }
+    const artifactNodes = xpath.select(XPATH_PROJECT_ARTIFACT, document);
+    if (artifactNodes.length === 0) {
+        logger.warn(`Missing project.artifactId in ${path}`);
+        return;
+    }
+    const versionNodes = xpath.select(XPATH_PROJECT_VERSION, document);
+    if (versionNodes.length === 0) {
+        logger.warn(`Missing project.version in ${path}`);
+        return;
+    }
+    const dependencies = [];
+    const testDependencies = [];
+    for (const dependencyNode of xpath.select(XPATH_PROJECT_DEPENDENCIES, document)) {
+        const parsedNode = (0, pom_xml_1.parseDependencyNode)(dependencyNode);
+        if (!parsedNode.version) {
+            continue;
+        }
+        if (parsedNode.scope === 'test') {
+            testDependencies.push({
+                groupId: parsedNode.groupId,
+                artifactId: parsedNode.artifactId,
+                version: parsedNode.version,
+            });
+        }
+        else {
+            dependencies.push({
+                groupId: parsedNode.groupId,
+                artifactId: parsedNode.artifactId,
+                version: parsedNode.version,
+            });
+        }
+    }
+    const managedDependencies = [];
+    for (const dependencyNode of xpath.select(XPATH_PROJECT_DEPENDENCY_MANAGEMENT_DEPENDENCIES, document)) {
+        const parsedNode = (0, pom_xml_1.parseDependencyNode)(dependencyNode);
+        if (!parsedNode.version) {
+            continue;
+        }
+        managedDependencies.push({
+            groupId: parsedNode.groupId,
+            artifactId: parsedNode.artifactId,
+            version: parsedNode.version,
+        });
+    }
+    const groupId = groupNodes[0].firstChild.textContent;
+    const artifactId = artifactNodes[0].firstChild.textContent;
+    return {
+        path: (0, path_1.dirname)(path),
+        groupId,
+        artifactId,
+        name: `${groupId}:${artifactId}`,
+        version: versionNodes[0].firstChild.textContent,
+        dependencies,
+        testDependencies,
+        managedDependencies,
+        pomContent,
+    };
+}
+// We use a fake commit to leverage the Java versioning strategy
+// (it should be a patch version bump and potentially remove the
+// -SNAPSHOT portion of the version)
+const FAKE_COMMIT = {
+    message: 'fix: fake fix',
+    type: 'fix',
+    scope: null,
+    notes: [],
+    references: [],
+    bareMessage: 'fake fix',
+    breaking: false,
+    sha: 'abc123',
+    files: [],
+};
 //# sourceMappingURL=maven-workspace.js.map

package/build/src/plugins/workspace.d.ts

@@ -35,6 +35,45 @@ export declare abstract class WorkspacePlugin<T> extends ManifestPlugin {
     private merge;
     constructor(github: GitHub, targetBranch: string, repositoryConfig: RepositoryConfig, options?: WorkspacePluginOptions);
     run(candidates: CandidateReleasePullRequest[]): Promise<CandidateReleasePullRequest[]>;
+    /**
+     * Helper for finding a candidate release based on the package name.
+     * By default, we assume that the package name matches the release
+     * component.
+     * @param {T} pkg The package being released
+     * @param {Record<string, CandidateReleasePullRequest} candidatesByPackage
+     *   The candidate pull requests indexed by the package name.
+     * @returns {CandidateReleasePullRequest | undefined} The associated
+     *   candidate release or undefined if there is no existing release yet
+     */
+    protected findCandidateForPackage(pkg: T, candidatesByPackage: Record<string, CandidateReleasePullRequest>): CandidateReleasePullRequest | undefined;
+    /**
+     * Helper to determine which packages we will use to base our search
+     * for touched packages upon. These are usually the packages that
+     * have candidate pull requests open.
+     *
+     * If you configure `updateAllPackages`, we fill force update all
+     * packages as if they had a release.
+     * @param {DependencyGraph<T>} graph All the packages in the repository
+     * @param {Record<string, CandidateReleasePullRequest} candidatesByPackage
+     *   The candidate pull requests indexed by the package name.
+     * @returns {string[]} Package names to
+     */
+    protected packageNamesToUpdate(graph: DependencyGraph<T>, candidatesByPackage: Record<string, CandidateReleasePullRequest>): string[];
+    /**
+     * Helper to build up all the versions we are modifying in this
+     * repository.
+     * @param {DependencyGraph<T>} _graph All the packages in the repository
+     * @param {T[]} orderedPackages A list of packages that are currently
+     *   updated by the existing candidate pull requests
+     * @param {Record<string, CandidateReleasePullRequest} candidatesByPackage
+     *   The candidate pull requests indexed by the package name.
+     * @returns A map of all updated versions (package name => Version) and a
+     *   map of all updated versions (component path => Version).
+     */
+    protected buildUpdatedVersions(_graph: DependencyGraph<T>, orderedPackages: T[], candidatesByPackage: Record<string, CandidateReleasePullRequest>): Promise<{
+        updatedVersions: VersionsMap;
+        updatedPathVersions: VersionsMap;
+    }>;
     /**
      * Given a package, return the new bumped version after updating
      * the dependency.

package/build/src/plugins/workspace.js

@@ -61,44 +61,39 @@ class WorkspacePlugin extends plugin_1.ManifestPlugin {
         const { allPackages, candidatesByPackage } = await this.buildAllPackages(inScopeCandidates);
         this.logger.info(`Building dependency graph for ${allPackages.length} packages`);
         const graph = await this.buildGraph(allPackages);
-        const packageNamesToUpdate = this.updateAllPackages
-            ? allPackages.map(this.packageNameFromPackage)
-            : Object.keys(candidatesByPackage);
+        const packageNamesToUpdate = this.packageNamesToUpdate(graph, candidatesByPackage);
         const orderedPackages = this.buildGraphOrder(graph, packageNamesToUpdate);
         this.logger.info(`Updating ${orderedPackages.length} packages`);
-        const updatedVersions = new Map();
-        const updatedPathVersions = new Map();
-        for (const pkg of orderedPackages) {
-            const packageName = this.packageNameFromPackage(pkg);
-            this.logger.debug(`package: ${packageName}`);
-            const existingCandidate = candidatesByPackage[packageName];
-            if (existingCandidate) {
-                const version = existingCandidate.pullRequest.version;
-                this.logger.debug(`version: ${version} from release-please`);
-                updatedVersions.set(packageName, version);
-            }
-            else {
-                const version = this.bumpVersion(pkg);
-                this.logger.debug(`version: ${version} forced bump`);
-                updatedVersions.set(packageName, version);
-                updatedPathVersions.set(this.pathFromPackage(pkg), version);
-            }
-        }
+        const { updatedVersions, updatedPathVersions } = await this.buildUpdatedVersions(graph, orderedPackages, candidatesByPackage);
         let newCandidates = [];
+        // In some cases, there are multiple packages within a single candidate. We
+        // only want to process each candidate package once.
+        const newCandidatePaths = new Set();
         for (const pkg of orderedPackages) {
-            const packageName = this.packageNameFromPackage(pkg);
-            const existingCandidate = candidatesByPackage[packageName];
+            const existingCandidate = this.findCandidateForPackage(pkg, candidatesByPackage);
             if (existingCandidate) {
                 // if already has an pull request, update the changelog and update
-                this.logger.info(`Updating exising candidate pull request for ${this.packageNameFromPackage(pkg)}`);
-                const newCandidate = this.updateCandidate(existingCandidate, pkg, updatedVersions);
-                newCandidates.push(newCandidate);
+                this.logger.info(`Updating exising candidate pull request for ${this.packageNameFromPackage(pkg)}, path: ${existingCandidate.path}`);
+                if (newCandidatePaths.has(existingCandidate.path)) {
+                    this.logger.info(`Already updated candidate for path: ${existingCandidate.path}`);
+                }
+                else {
+                    const newCandidate = this.updateCandidate(existingCandidate, pkg, updatedVersions);
+                    newCandidatePaths.add(newCandidate.path);
+                    newCandidates.push(newCandidate);
+                }
             }
             else {
                 // otherwise, build a new pull request with changelog and entry update
                 this.logger.info(`Creating new candidate pull request for ${this.packageNameFromPackage(pkg)}`);
                 const newCandidate = this.newCandidate(pkg, updatedVersions);
-                newCandidates.push(newCandidate);
+                if (newCandidatePaths.has(newCandidate.path)) {
+                    this.logger.info(`Already created new candidate for path: ${newCandidate.path}`);
+                }
+                else {
+                    newCandidatePaths.add(newCandidate.path);
+                    newCandidates.push(newCandidate);
+                }
             }
         }
         if (this.merge) {
@@ -119,6 +114,73 @@ class WorkspacePlugin extends plugin_1.ManifestPlugin {
         newCandidates = this.postProcessCandidates(newCandidates, updatedVersions);
         return [...outOfScopeCandidates, ...newCandidates];
     }
+    /**
+     * Helper for finding a candidate release based on the package name.
+     * By default, we assume that the package name matches the release
+     * component.
+     * @param {T} pkg The package being released
+     * @param {Record<string, CandidateReleasePullRequest} candidatesByPackage
+     *   The candidate pull requests indexed by the package name.
+     * @returns {CandidateReleasePullRequest | undefined} The associated
+     *   candidate release or undefined if there is no existing release yet
+     */
+    findCandidateForPackage(pkg, candidatesByPackage) {
+        const packageName = this.packageNameFromPackage(pkg);
+        return candidatesByPackage[packageName];
+    }
+    /**
+     * Helper to determine which packages we will use to base our search
+     * for touched packages upon. These are usually the packages that
+     * have candidate pull requests open.
+     *
+     * If you configure `updateAllPackages`, we fill force update all
+     * packages as if they had a release.
+     * @param {DependencyGraph<T>} graph All the packages in the repository
+     * @param {Record<string, CandidateReleasePullRequest} candidatesByPackage
+     *   The candidate pull requests indexed by the package name.
+     * @returns {string[]} Package names to
+     */
+    packageNamesToUpdate(graph, candidatesByPackage) {
+        if (this.updateAllPackages) {
+            return Array.from(graph.values()).map(({ value }) => this.packageNameFromPackage(value));
+        }
+        return Object.keys(candidatesByPackage);
+    }
+    /**
+     * Helper to build up all the versions we are modifying in this
+     * repository.
+     * @param {DependencyGraph<T>} _graph All the packages in the repository
+     * @param {T[]} orderedPackages A list of packages that are currently
+     *   updated by the existing candidate pull requests
+     * @param {Record<string, CandidateReleasePullRequest} candidatesByPackage
+     *   The candidate pull requests indexed by the package name.
+     * @returns A map of all updated versions (package name => Version) and a
+     *   map of all updated versions (component path => Version).
+     */
+    async buildUpdatedVersions(_graph, orderedPackages, candidatesByPackage) {
+        const updatedVersions = new Map();
+        const updatedPathVersions = new Map();
+        for (const pkg of orderedPackages) {
+            const packageName = this.packageNameFromPackage(pkg);
+            this.logger.debug(`package: ${packageName}`);
+            const existingCandidate = candidatesByPackage[packageName];
+            if (existingCandidate) {
+                const version = existingCandidate.pullRequest.version;
+                this.logger.debug(`version: ${version} from release-please`);
+                updatedVersions.set(packageName, version);
+            }
+            else {
+                const version = this.bumpVersion(pkg);
+                this.logger.debug(`version: ${version} forced bump`);
+                updatedVersions.set(packageName, version);
+                updatedPathVersions.set(this.pathFromPackage(pkg), version);
+            }
+        }
+        return {
+            updatedVersions,
+            updatedPathVersions,
+        };
+    }
     /**
      * Helper to invert the graph from package => packages that it depends on
      * to package => packages that depend on it.
@@ -163,6 +225,7 @@ class WorkspacePlugin extends plugin_1.ManifestPlugin {
         return Array.from(visited).sort((a, b) => this.packageNameFromPackage(a).localeCompare(this.packageNameFromPackage(b)));
     }
     visitPostOrder(graph, name, visited, path) {
+        this.logger.debug(`visiting ${name}, path: ${path}`);
         if (path.indexOf(name) !== -1) {
             throw new Error(`found cycle in dependency graph: ${path.join(' -> ')} -> ${name}`);
         }
@@ -178,12 +241,16 @@ class WorkspacePlugin extends plugin_1.ManifestPlugin {
                 this.logger.warn(`dependency not found in graph: ${depName}`);
                 return;
             }
+            this.logger.info(`visiting ${depName} next`);
             this.visitPostOrder(graph, depName, visited, nextPath);
         }
         if (!visited.has(node.value)) {
             this.logger.debug(`marking ${name} as visited and adding ${this.packageNameFromPackage(node.value)} to order`);
             visited.add(node.value);
         }
+        else {
+            this.logger.debug(`${node.value} already visited`);
+        }
     }
 }
 exports.WorkspacePlugin = WorkspacePlugin;

package/build/src/util/logger.js

@@ -46,7 +46,7 @@ class CheckpointLogger {
 }
 exports.CheckpointLogger = CheckpointLogger;
 /* eslint-enable @typescript-eslint/no-explicit-any */
-exports.logger = new CheckpointLogger();
+exports.logger = new CheckpointLogger(true);
 function setLogger(userLogger) {
     exports.logger = userLogger;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-please",
-  "version": "14.10.2",
+  "version": "14.11.1",
   "description": "generate release PRs based on the conventionalcommits.org spec",
   "main": "./build/src/index.js",
   "bin": "./build/src/bin/release-please.js",

package/schemas/config.json

@@ -292,6 +292,10 @@
                   "merge": {
                     "description": "Whether to merge in-scope pull requests into a combined release pull request. Defaults to `true`.",
                     "type": "boolean"
+                  },
+                  "considerAllArtifacts": {
+                    "description": "Whether to analyze all packages in the workspace for cross-component version bumping. This currently only works for the maven-workspace plugin. Defaults to `true`.",
+                    "type": "boolean"
                   }
                 }
               },