release-please 13.5.0 → 13.7.1

package/CHANGELOG.md

@@ -4,6 +4,29 @@
 
 [1]: https://www.npmjs.com/package/release-please?activeTab=versions
 
+### [13.7.1](https://github.com/googleapis/release-please/compare/v13.7.0...v13.7.1) (2022-03-30)
+
+
+### Bug Fixes
+
+* use lerna typings provided by DefinitelyTyped project ([#1351](https://github.com/googleapis/release-please/issues/1351)) ([86dccdf](https://github.com/googleapis/release-please/commit/86dccdf9dd2fbd8c517a88f4422412c18a944e07))
+
+## [13.7.0](https://github.com/googleapis/release-please/compare/v13.6.0...v13.7.0) (2022-03-24)
+
+
+### Features
+
+* allow snoozing release pull requests ([#1345](https://github.com/googleapis/release-please/issues/1345)) ([ea69708](https://github.com/googleapis/release-please/commit/ea6970813a11cebe2394c19d8d006d352c8fb306)), closes [#1339](https://github.com/googleapis/release-please/issues/1339)
+
+## [13.6.0](https://github.com/googleapis/release-please/compare/v13.5.0...v13.6.0) (2022-03-16)
+
+
+### Features
+
+* add linked-versions plugin for grouping components ([#1327](https://github.com/googleapis/release-please/issues/1327)) ([f398bdf](https://github.com/googleapis/release-please/commit/f398bdffdae69772c61a82cd7158cca3478c2110))
+* introduce generic json updater ([#1332](https://github.com/googleapis/release-please/issues/1332)) ([ecbfcf0](https://github.com/googleapis/release-please/commit/ecbfcf03f7854ced3ace5eafd95f7872ddee1d14))
+* introduce generic xml updater ([#1337](https://github.com/googleapis/release-please/issues/1337)) ([02ef78b](https://github.com/googleapis/release-please/commit/02ef78b4d6a855236ff80fc139fd00a46f88d445))
+
 ## [13.5.0](https://github.com/googleapis/release-please/compare/v13.4.15...v13.5.0) (2022-03-08)
 
 

package/build/src/changelog-notes.d.ts

@@ -1,4 +1,4 @@
-import { ConventionalCommit } from './commit';
+import { Commit, ConventionalCommit } from './commit';
 export interface BuildNotesOptions {
     host?: string;
     owner: string;
@@ -8,6 +8,7 @@ export interface BuildNotesOptions {
     currentTag: string;
     targetBranch: string;
     changelogSections?: ChangelogSection[];
+    commits?: Commit[];
 }
 export interface ChangelogNotes {
     buildNotes(commits: ConventionalCommit[], options: BuildNotesOptions): Promise<string>;

package/build/src/factory.js

@@ -39,6 +39,7 @@ const node_workspace_1 = require("./plugins/node-workspace");
 const cargo_workspace_1 = require("./plugins/cargo-workspace");
 const github_1 = require("./changelog-notes/github");
 const default_2 = require("./changelog-notes/default");
+const linked_versions_1 = require("./plugins/linked-versions");
 // Factory shared by GitHub Action and CLI for creating Release PRs
 // and GitHub Releases:
 // add any new releasers you create to this type as well as the `releasers`
@@ -191,6 +192,14 @@ function buildVersioningStrategy(options) {
     }
 }
 function buildPlugin(options) {
+    if (typeof options.type === 'object') {
+        switch (options.type.type) {
+            case 'linked-versions':
+                return new linked_versions_1.LinkedVersions(options.github, options.targetBranch, options.repositoryConfig, options.type.groupName, options.type.components);
+            default:
+                throw new Error(`Unknown plugin type: ${options.type}`);
+        }
+    }
     switch (options.type) {
         case 'cargo-workspace':
             return new cargo_workspace_1.CargoWorkspace(options.github, options.targetBranch, options.repositoryConfig, options);

package/build/src/manifest.d.ts

@@ -5,6 +5,17 @@ import { PullRequest } from './pull-request';
 import { ReleasePullRequest } from './release-pull-request';
 import { ReleaseType, VersioningStrategyType, ChangelogNotesType } from './factory';
 import { Release } from './release';
+declare type ExtraJsonFile = {
+    type: 'json';
+    path: string;
+    jsonpath: string;
+};
+declare type ExtraXmlFile = {
+    type: 'xml';
+    path: string;
+    xpath: string;
+};
+export declare type ExtraFile = string | ExtraJsonFile | ExtraXmlFile;
 /**
  * These are configurations provided to each strategy per-path.
  */
@@ -27,7 +38,7 @@ export interface ReleaserConfig {
     changelogPath?: string;
     changelogType?: ChangelogNotesType;
     versionFile?: string;
-    extraFiles?: string[];
+    extraFiles?: ExtraFile[];
 }
 export interface CandidateReleasePullRequest {
     path: string;
@@ -80,7 +91,13 @@ interface ReleaserPackageConfig extends ReleaserConfigJson {
     component?: string;
     'changelog-path'?: string;
 }
-export declare type PluginType = 'node-workspace' | 'cargo-workspace';
+declare type DirectPluginType = 'node-workspace' | 'cargo-workspace';
+interface LinkedVersionPluginConfig {
+    type: 'linked-versions';
+    groupName: string;
+    components: string[];
+}
+export declare type PluginType = DirectPluginType | LinkedVersionPluginConfig;
 /**
  * This is the schema of the manifest config json
  */
@@ -206,7 +223,11 @@ export declare class Manifest {
      * @returns {number[]} Pull request numbers of release pull requests
      */
     createPullRequests(): Promise<(PullRequest | undefined)[]>;
+    private findOpenReleasePullRequests;
+    private findSnoozedReleasePullRequests;
     private createOrUpdatePullRequest;
+    private maybeUpdateExistingPullRequest;
+    private maybeUpdateSnoozedPullRequest;
     private findMergedReleasePullRequests;
     /**
      * Find merged, untagged releases and build candidate releases to tag.

package/build/src/manifest.js

@@ -31,6 +31,7 @@ exports.ROOT_PROJECT_PATH = '.';
 const DEFAULT_COMPONENT_NAME = '';
 const DEFAULT_LABELS = ['autorelease: pending'];
 const DEFAULT_RELEASE_LABELS = ['autorelease: tagged'];
+const SNOOZE_LABEL = 'autorelease: snooze';
 exports.MANIFEST_PULL_REQUEST_TITLE_PATTERN = 'chore: release ${branch}';
 class Manifest {
     /**
@@ -270,33 +271,54 @@ class Manifest {
             includeEmpty: true,
             packagePaths: Object.keys(this.repositoryConfig),
         });
-        const commitsPerPath = cs.split(commits);
-        let newReleasePullRequests = [];
+        const splitCommits = cs.split(commits);
+        // limit paths to ones since the last release
+        const commitsPerPath = {};
         for (const path in this.repositoryConfig) {
-            const config = this.repositoryConfig[path];
-            logger_1.logger.info(`Building candidate release pull request for path: ${path}`);
-            logger_1.logger.debug(`type: ${config.releaseType}`);
-            logger_1.logger.debug(`targetBranch: ${this.targetBranch}`);
-            const pathCommits = commitsAfterSha(path === exports.ROOT_PROJECT_PATH ? commits : commitsPerPath[path], releaseShasByPath[path]);
-            logger_1.logger.debug(`commits: ${pathCommits.length}`);
-            const latestReleasePullRequest = releasePullRequestsBySha[releaseShasByPath[path]];
-            if (!latestReleasePullRequest) {
-                logger_1.logger.warn('No latest release pull request found.');
-            }
-            const strategy = strategiesByPath[path];
-            let latestRelease = releasesByPath[path];
+            commitsPerPath[path] = commitsAfterSha(path === exports.ROOT_PROJECT_PATH ? commits : splitCommits[path], releaseShasByPath[path]);
+        }
+        // backfill latest release tags from manifest
+        for (const path in this.repositoryConfig) {
+            const latestRelease = releasesByPath[path];
             if (!latestRelease &&
                 this.releasedVersions[path] &&
                 this.releasedVersions[path].toString() !== '0.0.0') {
                 const version = this.releasedVersions[path];
+                const strategy = strategiesByPath[path];
                 const component = await strategy.getComponent();
                 logger_1.logger.info(`No latest release found for path: ${path}, component: ${component}, but a previous version (${version.toString()}) was specified in the manifest.`);
-                latestRelease = {
+                releasesByPath[path] = {
                     tag: new tag_name_1.TagName(version, component),
                     sha: '',
                     notes: '',
                 };
             }
+        }
+        // Build plugins
+        const plugins = this.plugins.map(pluginType => factory_1.buildPlugin({
+            type: pluginType,
+            github: this.github,
+            targetBranch: this.targetBranch,
+            repositoryConfig: this.repositoryConfig,
+        }));
+        let strategies = strategiesByPath;
+        for (const plugin of plugins) {
+            strategies = await plugin.preconfigure(strategies, commitsPerPath, releasesByPath);
+        }
+        let newReleasePullRequests = [];
+        for (const path in this.repositoryConfig) {
+            const config = this.repositoryConfig[path];
+            logger_1.logger.info(`Building candidate release pull request for path: ${path}`);
+            logger_1.logger.debug(`type: ${config.releaseType}`);
+            logger_1.logger.debug(`targetBranch: ${this.targetBranch}`);
+            const pathCommits = commitsPerPath[path];
+            logger_1.logger.debug(`commits: ${pathCommits.length}`);
+            const latestReleasePullRequest = releasePullRequestsBySha[releaseShasByPath[path]];
+            if (!latestReleasePullRequest) {
+                logger_1.logger.warn('No latest release pull request found.');
+            }
+            const strategy = strategies[path];
+            const latestRelease = releasesByPath[path];
             const releasePullRequest = await strategy.buildReleasePullRequest(pathCommits, latestRelease, (_a = config.draftPullRequest) !== null && _a !== void 0 ? _a : this.draftPullRequest, this.labels);
             if (releasePullRequest) {
                 if (releasePullRequest.version) {
@@ -318,13 +340,6 @@ class Manifest {
                 });
             }
         }
-        // Build plugins
-        const plugins = this.plugins.map(pluginType => factory_1.buildPlugin({
-            type: pluginType,
-            github: this.github,
-            targetBranch: this.targetBranch,
-            repositoryConfig: this.repositoryConfig,
-        }));
         // Combine pull requests into 1 unless configured for separate
         // pull requests
         if (!this.separatePullRequests) {
@@ -384,7 +399,18 @@ class Manifest {
             logger_1.logger.warn('There are untagged, merged release PRs outstanding - aborting');
             return [];
         }
-        // collect open release pull requests
+        // collect open and snoozed release pull requests
+        const openPullRequests = await this.findOpenReleasePullRequests();
+        const snoozedPullRequests = await this.findSnoozedReleasePullRequests();
+        const promises = [];
+        for (const pullRequest of candidatePullRequests) {
+            promises.push(this.createOrUpdatePullRequest(pullRequest, openPullRequests, snoozedPullRequests));
+        }
+        const pullNumbers = await Promise.all(promises);
+        // reject any pull numbers that were not created or updated
+        return pullNumbers.filter(number => !!number);
+    }
+    async findOpenReleasePullRequests() {
         logger_1.logger.info('Looking for open release pull requests');
         const openPullRequests = [];
         const generator = this.github.pullRequestIterator(this.targetBranch, 'OPEN');
@@ -396,34 +422,66 @@ class Manifest {
             }
         }
         logger_1.logger.info(`found ${openPullRequests.length} open release pull requests.`);
-        const promises = [];
-        for (const pullRequest of candidatePullRequests) {
-            promises.push(this.createOrUpdatePullRequest(pullRequest, openPullRequests));
+        return openPullRequests;
+    }
+    async findSnoozedReleasePullRequests() {
+        logger_1.logger.info('Looking for snoozed release pull requests');
+        const snoozedPullRequests = [];
+        const closedGenerator = this.github.pullRequestIterator(this.targetBranch, 'CLOSED');
+        for await (const closedPullRequest of closedGenerator) {
+            if (hasAllLabels([SNOOZE_LABEL], closedPullRequest.labels) &&
+                branch_name_1.BranchName.parse(closedPullRequest.headBranchName) &&
+                pull_request_body_1.PullRequestBody.parse(closedPullRequest.body)) {
+                snoozedPullRequests.push(closedPullRequest);
+            }
         }
-        return await Promise.all(promises);
+        logger_1.logger.info(`found ${snoozedPullRequests.length} snoozed release pull requests.`);
+        return snoozedPullRequests;
     }
-    async createOrUpdatePullRequest(pullRequest, openPullRequests) {
-        // look for existing, open pull rquest
+    async createOrUpdatePullRequest(pullRequest, openPullRequests, snoozedPullRequests) {
+        // look for existing, open pull request
         const existing = openPullRequests.find(openPullRequest => openPullRequest.headBranchName === pullRequest.headRefName);
         if (existing) {
-            // If unchanged, no need to push updates
-            if (existing.body === pullRequest.body.toString()) {
-                logger_1.logger.info(`PR https://github.com/${this.repository.owner}/${this.repository.repo}/pull/${existing.number} remained the same`);
-                return undefined;
-            }
-            const updatedPullRequest = await this.github.updatePullRequest(existing.number, pullRequest, this.targetBranch, {
-                fork: this.fork,
-                signoffUser: this.signoffUser,
-            });
-            return updatedPullRequest;
+            return await this.maybeUpdateExistingPullRequest(existing, pullRequest);
         }
-        else {
-            const newPullRequest = await this.github.createReleasePullRequest(pullRequest, this.targetBranch, {
-                fork: this.fork,
-                signoffUser: this.signoffUser,
-            });
-            return newPullRequest;
+        // look for closed, snoozed pull request
+        const snoozed = snoozedPullRequests.find(openPullRequest => openPullRequest.headBranchName === pullRequest.headRefName);
+        if (snoozed) {
+            return await this.maybeUpdateSnoozedPullRequest(snoozed, pullRequest);
         }
+        const newPullRequest = await this.github.createReleasePullRequest(pullRequest, this.targetBranch, {
+            fork: this.fork,
+            signoffUser: this.signoffUser,
+        });
+        return newPullRequest;
+    }
+    /// only update an existing pull request if it has release note changes
+    async maybeUpdateExistingPullRequest(existing, pullRequest) {
+        // If unchanged, no need to push updates
+        if (existing.body === pullRequest.body.toString()) {
+            logger_1.logger.info(`PR https://github.com/${this.repository.owner}/${this.repository.repo}/pull/${existing.number} remained the same`);
+            return undefined;
+        }
+        const updatedPullRequest = await this.github.updatePullRequest(existing.number, pullRequest, this.targetBranch, {
+            fork: this.fork,
+            signoffUser: this.signoffUser,
+        });
+        return updatedPullRequest;
+    }
+    /// only update an snoozed pull request if it has release note changes
+    async maybeUpdateSnoozedPullRequest(snoozed, pullRequest) {
+        // If unchanged, no need to push updates
+        if (snoozed.body === pullRequest.body.toString()) {
+            logger_1.logger.info(`PR https://github.com/${this.repository.owner}/${this.repository.repo}/pull/${snoozed.number} remained the same`);
+            return undefined;
+        }
+        const updatedPullRequest = await this.github.updatePullRequest(snoozed.number, pullRequest, this.targetBranch, {
+            fork: this.fork,
+            signoffUser: this.signoffUser,
+        });
+        // TODO: consider leaving the snooze label
+        await this.github.removeIssueLabels([SNOOZE_LABEL], snoozed.number);
+        return updatedPullRequest;
     }
     async *findMergedReleasePullRequests() {
         // Find merged release pull requests

package/build/src/plugin.d.ts

@@ -1,5 +1,8 @@
 import { GitHub } from './github';
 import { CandidateReleasePullRequest, RepositoryConfig } from './manifest';
+import { Strategy } from './strategy';
+import { Commit } from './commit';
+import { Release } from './release';
 /**
  * A plugin runs after a repository manifest has built candidate
  * pull requests and can make updates that span across multiple
@@ -16,5 +19,11 @@ export declare abstract class ManifestPlugin {
      * @param {CandidateReleasePullRequest[]} pullRequests Candidate pull requests
      * @returns {CandidateReleasePullRequest[]} Updated pull requests
      */
-    abstract run(pullRequests: CandidateReleasePullRequest[]): Promise<CandidateReleasePullRequest[]>;
+    run(pullRequests: CandidateReleasePullRequest[]): Promise<CandidateReleasePullRequest[]>;
+    /**
+     * Pre-configure strategies.
+     * @param {Record<string, Strategy>} strategiesByPath Strategies indexed by path
+     * @returns {Record<string, Strategy>} Updated strategies indexed by path
+     */
+    preconfigure(strategiesByPath: Record<string, Strategy>, _commitsByPath: Record<string, Commit[]>, _releasesByPath: Record<string, Release>): Promise<Record<string, Strategy>>;
 }

package/build/src/plugin.js

@@ -26,6 +26,22 @@ class ManifestPlugin {
         this.targetBranch = targetBranch;
         this.repositoryConfig = repositoryConfig;
     }
+    /**
+     * Post-process candidate pull requests.
+     * @param {CandidateReleasePullRequest[]} pullRequests Candidate pull requests
+     * @returns {CandidateReleasePullRequest[]} Updated pull requests
+     */
+    async run(pullRequests) {
+        return pullRequests;
+    }
+    /**
+     * Pre-configure strategies.
+     * @param {Record<string, Strategy>} strategiesByPath Strategies indexed by path
+     * @returns {Record<string, Strategy>} Updated strategies indexed by path
+     */
+    async preconfigure(strategiesByPath, _commitsByPath, _releasesByPath) {
+        return strategiesByPath;
+    }
 }
 exports.ManifestPlugin = ManifestPlugin;
 //# sourceMappingURL=plugin.js.map

package/build/src/plugins/linked-versions.d.ts

@@ -0,0 +1,29 @@
+import { ManifestPlugin } from '../plugin';
+import { RepositoryConfig, CandidateReleasePullRequest } from '../manifest';
+import { GitHub } from '../github';
+import { Strategy } from '../strategy';
+import { Commit } from '../commit';
+import { Release } from '../release';
+/**
+ * This plugin reconfigures strategies by linking multiple components
+ * together.
+ *
+ * Release notes are broken up using `<summary>`/`<details>` blocks.
+ */
+export declare class LinkedVersions extends ManifestPlugin {
+    private groupName;
+    private components;
+    constructor(github: GitHub, targetBranch: string, repositoryConfig: RepositoryConfig, groupName: string, components: string[]);
+    /**
+     * Pre-configure strategies.
+     * @param {Record<string, Strategy>} strategiesByPath Strategies indexed by path
+     * @returns {Record<string, Strategy>} Updated strategies indexed by path
+     */
+    preconfigure(strategiesByPath: Record<string, Strategy>, commitsByPath: Record<string, Commit[]>, releasesByPath: Record<string, Release>): Promise<Record<string, Strategy>>;
+    /**
+     * Post-process candidate pull requests.
+     * @param {CandidateReleasePullRequest[]} pullRequests Candidate pull requests
+     * @returns {CandidateReleasePullRequest[]} Updated pull requests
+     */
+    run(candidates: CandidateReleasePullRequest[]): Promise<CandidateReleasePullRequest[]>;
+}

package/build/src/plugins/linked-versions.js

@@ -0,0 +1,125 @@
+"use strict";
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkedVersions = void 0;
+const plugin_1 = require("../plugin");
+const logger_1 = require("../util/logger");
+const factory_1 = require("../factory");
+const merge_1 = require("./merge");
+/**
+ * This plugin reconfigures strategies by linking multiple components
+ * together.
+ *
+ * Release notes are broken up using `<summary>`/`<details>` blocks.
+ */
+class LinkedVersions extends plugin_1.ManifestPlugin {
+    constructor(github, targetBranch, repositoryConfig, groupName, components) {
+        super(github, targetBranch, repositoryConfig);
+        this.groupName = groupName;
+        this.components = new Set(components);
+    }
+    /**
+     * Pre-configure strategies.
+     * @param {Record<string, Strategy>} strategiesByPath Strategies indexed by path
+     * @returns {Record<string, Strategy>} Updated strategies indexed by path
+     */
+    async preconfigure(strategiesByPath, commitsByPath, releasesByPath) {
+        // Find all strategies in the group
+        const groupStrategies = {};
+        for (const path in strategiesByPath) {
+            const strategy = strategiesByPath[path];
+            const component = await strategy.getComponent();
+            if (!component) {
+                continue;
+            }
+            if (this.components.has(component)) {
+                groupStrategies[path] = strategy;
+            }
+        }
+        logger_1.logger.info(`Found ${Object.keys(groupStrategies).length} group components for ${this.groupName}`);
+        const groupVersions = {};
+        const missingReleasePaths = new Set();
+        for (const path in groupStrategies) {
+            const strategy = groupStrategies[path];
+            const latestRelease = releasesByPath[path];
+            const releasePullRequest = await strategy.buildReleasePullRequest(commitsByPath[path], latestRelease);
+            if (releasePullRequest === null || releasePullRequest === void 0 ? void 0 : releasePullRequest.version) {
+                groupVersions[path] = releasePullRequest.version;
+            }
+            else {
+                missingReleasePaths.add(path);
+            }
+        }
+        const versions = Object.values(groupVersions);
+        if (versions.length === 0) {
+            return strategiesByPath;
+        }
+        const primaryVersion = versions.reduce((collector, version) => collector.compare(version) > 0 ? collector : version, versions[0]);
+        const newStrategies = {};
+        for (const path in strategiesByPath) {
+            if (path in groupStrategies) {
+                const component = await strategiesByPath[path].getComponent();
+                logger_1.logger.info(`Replacing strategy for path ${path} with forced version: ${primaryVersion}`);
+                newStrategies[path] = await factory_1.buildStrategy({
+                    ...this.repositoryConfig[path],
+                    github: this.github,
+                    path,
+                    targetBranch: this.targetBranch,
+                    releaseAs: primaryVersion.toString(),
+                });
+                if (missingReleasePaths.has(path)) {
+                    logger_1.logger.debug(`Appending fake commit for path: ${path}`);
+                    commitsByPath[path].push({
+                        sha: '',
+                        message: `chore(${component}): Synchronize ${this.groupName} versions\n\nRelease-As: ${primaryVersion.toString()}`,
+                    });
+                }
+            }
+            else {
+                newStrategies[path] = strategiesByPath[path];
+            }
+        }
+        return newStrategies;
+    }
+    /**
+     * Post-process candidate pull requests.
+     * @param {CandidateReleasePullRequest[]} pullRequests Candidate pull requests
+     * @returns {CandidateReleasePullRequest[]} Updated pull requests
+     */
+    async run(candidates) {
+        const [inScopeCandidates, outOfScopeCandidates] = candidates.reduce((collection, candidate) => {
+            if (!candidate.pullRequest.version) {
+                logger_1.logger.warn('pull request missing version', candidate);
+                return collection;
+            }
+            if (this.components.has(candidate.config.component || '')) {
+                collection[0].push(candidate);
+            }
+            else {
+                collection[1].push(candidate);
+            }
+            return collection;
+        }, [[], []]);
+        // delegate to the merge plugin and add merged pull request
+        if (inScopeCandidates.length > 0) {
+            const merge = new merge_1.Merge(this.github, this.targetBranch, this.repositoryConfig, `chore\${branch}: release ${this.groupName} libraries`);
+            const merged = await merge.run(inScopeCandidates);
+            outOfScopeCandidates.push(...merged);
+        }
+        return outOfScopeCandidates;
+    }
+}
+exports.LinkedVersions = LinkedVersions;
+//# sourceMappingURL=linked-versions.js.map

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

@@ -1,4 +1,4 @@
-import { Package as LernaPackage, PackageJson } from '@lerna/package';
+import { Package as LernaPackage, RawManifest as PackageJson } from '@lerna/package';
 import { GitHub } from '../github';
 import { CandidateReleasePullRequest, RepositoryConfig } from '../manifest';
 import { Version, VersionsMap } from '../version';

package/build/src/strategies/base.d.ts

@@ -3,6 +3,7 @@ import { GitHub } from '../github';
 import { VersioningStrategy } from '../versioning-strategy';
 import { Repository } from '../repository';
 import { ChangelogNotes, ChangelogSection } from '../changelog-notes';
+import { ExtraFile } from '../manifest';
 import { Update } from '../update';
 import { ConventionalCommit, Commit } from '../commit';
 import { Version, VersionsMap } from '../version';
@@ -37,7 +38,7 @@ export interface BaseStrategyOptions {
     changelogNotes?: ChangelogNotes;
     includeComponentInTag?: boolean;
     pullRequestTitlePattern?: string;
-    extraFiles?: string[];
+    extraFiles?: ExtraFile[];
 }
 /**
  * A strategy is responsible for determining which files are
@@ -57,7 +58,7 @@ export declare abstract class BaseStrategy implements Strategy {
     private releaseAs?;
     protected includeComponentInTag: boolean;
     private pullRequestTitlePattern?;
-    readonly extraFiles: string[];
+    readonly extraFiles: ExtraFile[];
     readonly changelogNotes: ChangelogNotes;
     protected changelogSections?: ChangelogSection[];
     constructor(options: BaseStrategyOptions);
@@ -81,7 +82,7 @@ export declare abstract class BaseStrategy implements Strategy {
      * @returns {ConventionalCommit[]} modified commits
      */
     protected postProcessCommits(commits: ConventionalCommit[]): Promise<ConventionalCommit[]>;
-    protected buildReleaseNotes(conventionalCommits: ConventionalCommit[], newVersion: Version, newVersionTag: TagName, latestRelease?: Release): Promise<string>;
+    protected buildReleaseNotes(conventionalCommits: ConventionalCommit[], newVersion: Version, newVersionTag: TagName, latestRelease?: Release, commits?: Commit[]): Promise<string>;
     protected buildPullRequestBody(component: string | undefined, newVersion: Version, releaseNotesBody: string, _conventionalCommits: ConventionalCommit[], _latestRelease?: Release): Promise<PullRequestBody>;
     /**
      * Builds a candidate release pull request

package/build/src/strategies/base.js

@@ -26,6 +26,8 @@ const branch_name_1 = require("../util/branch-name");
 const pull_request_body_1 = require("../util/pull-request-body");
 const composite_1 = require("../updaters/composite");
 const generic_1 = require("../updaters/generic");
+const generic_json_1 = require("../updaters/generic-json");
+const generic_xml_1 = require("../updaters/generic-xml");
 const DEFAULT_CHANGELOG_PATH = 'CHANGELOG.md';
 /**
  * A strategy is responsible for determining which files are
@@ -90,7 +92,7 @@ class BaseStrategy {
     async postProcessCommits(commits) {
         return commits;
     }
-    async buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease) {
+    async buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease, commits) {
         var _a;
         return await this.changelogNotes.buildNotes(conventionalCommits, {
             owner: this.repository.owner,
@@ -100,6 +102,7 @@ class BaseStrategy {
             currentTag: newVersionTag.toString(),
             targetBranch: this.targetBranch,
             changelogSections: this.changelogSections,
+            commits: commits,
         });
     }
     async buildPullRequestBody(component, newVersion, releaseNotesBody, _conventionalCommits, _latestRelease) {
@@ -139,7 +142,7 @@ class BaseStrategy {
         const branchName = component
             ? branch_name_1.BranchName.ofComponentTargetBranch(component, this.targetBranch)
             : branch_name_1.BranchName.ofTargetBranch(this.targetBranch);
-        const releaseNotesBody = await this.buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease);
+        const releaseNotesBody = await this.buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease, commits);
         if (this.changelogEmpty(releaseNotesBody)) {
             logger_1.logger.info(`No user facing commits found since ${latestRelease ? latestRelease.sha : 'beginning of time'} - skipping`);
             return undefined;
@@ -163,12 +166,31 @@ class BaseStrategy {
         };
     }
     extraFileUpdates(version) {
-        const genericUpdater = new generic_1.Generic({ version });
-        return this.extraFiles.map(path => ({
-            path: this.addPath(path),
-            createIfMissing: false,
-            updater: genericUpdater,
-        }));
+        return this.extraFiles.map(extraFile => {
+            if (typeof extraFile === 'object') {
+                switch (extraFile.type) {
+                    case 'json':
+                        return {
+                            path: this.addPath(extraFile.path),
+                            createIfMissing: false,
+                            updater: new generic_json_1.GenericJson(extraFile.jsonpath, version),
+                        };
+                    case 'xml':
+                        return {
+                            path: this.addPath(extraFile.path),
+                            createIfMissing: false,
+                            updater: new generic_xml_1.GenericXml(extraFile.xpath, version),
+                        };
+                    default:
+                        throw new Error(`unsupported extraFile type: ${extraFile.type}`);
+                }
+            }
+            return {
+                path: this.addPath(extraFile),
+                createIfMissing: false,
+                updater: new generic_1.Generic({ version }),
+            };
+        });
     }
     changelogEmpty(changelogEntry) {
         return changelogEntry.split('\n').length <= 1;

package/build/src/strategies/go-yoshi.d.ts

@@ -1,6 +1,6 @@
 import { BaseStrategy, BuildUpdatesOptions, BaseStrategyOptions } from './base';
 import { Update } from '../update';
-import { ConventionalCommit } from '../commit';
+import { Commit, ConventionalCommit } from '../commit';
 import { Version } from '../version';
 import { TagName } from '../util/tag-name';
 import { Release } from '../release';
@@ -9,6 +9,6 @@ export declare class GoYoshi extends BaseStrategy {
     protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
     protected postProcessCommits(commits: ConventionalCommit[]): Promise<ConventionalCommit[]>;
     getIgnoredSubModules(): Promise<Set<string>>;
-    protected buildReleaseNotes(conventionalCommits: ConventionalCommit[], newVersion: Version, newVersionTag: TagName, latestRelease?: Release): Promise<string>;
+    protected buildReleaseNotes(conventionalCommits: ConventionalCommit[], newVersion: Version, newVersionTag: TagName, latestRelease?: Release, commits?: Commit[]): Promise<string>;
     protected initialReleaseVersion(): Version;
 }

package/build/src/strategies/go-yoshi.js

@@ -137,8 +137,8 @@ class GoYoshi extends base_1.BaseStrategy {
     }
     // "closes" is a little presumptuous, let's just indicate that the
     // PR references these other commits:
-    async buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease) {
-        const releaseNotes = await super.buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease);
+    async buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease, commits) {
+        const releaseNotes = await super.buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease, commits);
         return releaseNotes.replace(/, closes /g, ', refs ');
     }
     initialReleaseVersion() {

package/build/src/strategies/java-yoshi.js

@@ -198,9 +198,12 @@ class JavaYoshi extends base_1.BaseStrategy {
                 }),
             });
         });
-        this.extraFiles.forEach(path => {
+        this.extraFiles.forEach(extraFile => {
+            if (typeof extraFile === 'object') {
+                return;
+            }
             updates.push({
-                path,
+                path: extraFile,
                 createIfMissing: false,
                 updater: new java_update_1.JavaUpdate({
                     version,

package/build/src/updaters/generic-json.d.ts

@@ -0,0 +1,13 @@
+import { Updater } from '../update';
+import { Version } from '../version';
+export declare class GenericJson implements Updater {
+    readonly jsonpath: string;
+    readonly version: Version;
+    constructor(jsonpath: string, version: Version);
+    /**
+     * Given initial file contents, return updated contents.
+     * @param {string} content The initial content
+     * @returns {string} The updated content
+     */
+    updateContent(content: string): string;
+}

package/build/src/updaters/generic-json.js

@@ -0,0 +1,43 @@
+"use strict";
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericJson = void 0;
+const jp = require("jsonpath");
+const json_stringify_1 = require("../util/json-stringify");
+const logger_1 = require("../util/logger");
+class GenericJson {
+    constructor(jsonpath, version) {
+        this.jsonpath = jsonpath;
+        this.version = version;
+    }
+    /**
+     * Given initial file contents, return updated contents.
+     * @param {string} content The initial content
+     * @returns {string} The updated content
+     */
+    updateContent(content) {
+        const data = JSON.parse(content);
+        const nodes = jp.apply(data, this.jsonpath, _val => {
+            return this.version.toString();
+        });
+        if (!nodes) {
+            logger_1.logger.warn(`No entries modified in ${this.jsonpath}`);
+            return content;
+        }
+        return json_stringify_1.jsonStringify(data, content);
+    }
+}
+exports.GenericJson = GenericJson;
+//# sourceMappingURL=generic-json.js.map

package/build/src/updaters/generic-xml.d.ts

@@ -0,0 +1,13 @@
+import { Updater } from '../update';
+import { Version } from '../version';
+export declare class GenericXml implements Updater {
+    private xpath;
+    private version;
+    constructor(xpath: string, version: Version);
+    /**
+     * Given initial file contents, return updated contents.
+     * @param {string} content The initial content
+     * @returns {string} The updated content
+     */
+    updateContent(content: string): string;
+}

package/build/src/updaters/generic-xml.js

@@ -0,0 +1,47 @@
+"use strict";
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericXml = void 0;
+const xpath = require("xpath");
+const dom = require("xmldom");
+class GenericXml {
+    constructor(xpath, version) {
+        this.xpath = xpath;
+        this.version = version;
+    }
+    /**
+     * Given initial file contents, return updated contents.
+     * @param {string} content The initial content
+     * @returns {string} The updated content
+     */
+    updateContent(content) {
+        const document = new dom.DOMParser().parseFromString(content);
+        const iterator = xpath.evaluate(this.xpath, document, null, 0, null);
+        let node;
+        let updated = false;
+        while ((node = iterator.iterateNext())) {
+            node.textContent = this.version.toString();
+            updated = true;
+        }
+        if (updated) {
+            return new dom.XMLSerializer().serializeToString(document);
+        }
+        else {
+            return content;
+        }
+    }
+}
+exports.GenericXml = GenericXml;
+//# sourceMappingURL=generic-xml.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-please",
-  "version": "13.5.0",
+  "version": "13.7.1",
   "description": "generate release PRs based on the conventionalcommits.org spec",
   "main": "./build/src/index.js",
   "bin": "./build/src/bin/release-please.js",
@@ -41,11 +41,17 @@
     "@types/chai": "^4.1.7",
     "@types/iarna__toml": "^2.0.1",
     "@types/js-yaml": "^4.0.0",
+    "@types/jsonpath": "^0.2.0",
+    "@types/lerna__collect-updates": "^4.0.0",
+    "@types/lerna__package": "^4.0.2",
+    "@types/lerna__package-graph": "^4.0.1",
+    "@types/lerna__run-topologically": "^4.0.0",
     "@types/mocha": "^9.0.0",
     "@types/node": "^16.0.0",
     "@types/pino": "^7.0.0",
     "@types/semver": "^7.0.0",
     "@types/sinon": "^10.0.0",
+    "@types/xmldom": "^0.1.31",
     "@types/yargs": "^17.0.0",
     "c8": "^7.0.0",
     "chai": "^4.2.0",
@@ -76,6 +82,7 @@
     "detect-indent": "^6.1.0",
     "figures": "^3.0.0",
     "js-yaml": "^4.0.0",
+    "jsonpath": "^1.1.1",
     "node-html-parser": "^5.0.0",
     "parse-github-repo-url": "^1.4.1",
     "semver": "^7.0.0",
@@ -83,6 +90,8 @@
     "typescript": "^3.8.3",
     "unist-util-visit": "^2.0.3",
     "unist-util-visit-parents": "^3.1.1",
+    "xmldom": "^0.6.0",
+    "xpath": "^0.0.32",
     "yargs": "^17.0.0"
   },
   "engines": {