release-please 14.11.2 → 14.13.0

package/CHANGELOG.md

@@ -4,6 +4,20 @@
 
 [1]: https://www.npmjs.com/package/release-please?activeTab=versions
 
+## [14.13.0](https://github.com/googleapis/release-please/compare/v14.12.0...v14.13.0) (2022-10-13)
+
+
+### Features
+
+* Handle extremely large pull request body fields ([#1689](https://github.com/googleapis/release-please/issues/1689)) ([ecc424d](https://github.com/googleapis/release-please/commit/ecc424db9a86e742eb6b4f6f9271a8eae13e4efc))
+
+## [14.12.0](https://github.com/googleapis/release-please/compare/v14.11.2...v14.12.0) (2022-10-12)
+
+
+### Features
+
+* Added expo strategy and updater ([#1646](https://github.com/googleapis/release-please/issues/1646)) ([9cb84cb](https://github.com/googleapis/release-please/commit/9cb84cb18211c61ed94d856b936fff30036b0988))
+
 ## [14.11.2](https://github.com/googleapis/release-please/compare/v14.11.1...v14.11.2) (2022-10-11)
 
 

package/README.md

@@ -141,6 +141,7 @@ Release Please automates releases for the following flavors of repositories:
 | `krm-blueprint`     | [A kpt package, with 1 or more KRM files and a CHANGELOG.md](https://github.com/GoogleCloudPlatform/blueprints/tree/main/catalog/project) |
 | `maven`             | [Strategy for Maven projects, generates SNAPSHOT version after each release and updates `pom.xml` automatically](docs/java.md) |
 | `node`              | [A Node.js repository, with a package.json and CHANGELOG.md](https://github.com/yargs/yargs) |
+| `expo`              | [An Expo based React Native repository, with a package.json, app.json and CHANGELOG.md](https://github.com/yargs/yargs) |
 | `ocaml`             | [An OCaml repository, containing 1 or more opam or esy files and a CHANGELOG.md](https://github.com/grain-lang/binaryen.ml) |
 | `php`               | A repository with a composer.json and a CHANGELOG.md |
 | `python`            | [A Python repository, with a setup.py, setup.cfg, CHANGELOG.md](https://github.com/googleapis/python-storage) and optionally a pyproject.toml and a <project>/\_\_init\_\_.py |

package/build/src/factory.js

@@ -45,6 +45,7 @@ const helm_1 = require("./strategies/helm");
 const elixir_1 = require("./strategies/elixir");
 const dart_1 = require("./strategies/dart");
 const node_1 = require("./strategies/node");
+const expo_1 = require("./strategies/expo");
 const always_bump_patch_1 = require("./versioning-strategies/always-bump-patch");
 const service_pack_1 = require("./versioning-strategies/service-pack");
 const dependency_manifest_1 = require("./versioning-strategies/dependency-manifest");
@@ -81,6 +82,7 @@ const releasers = {
     }),
     'krm-blueprint': options => new krm_blueprint_1.KRMBlueprint(options),
     node: options => new node_1.Node(options),
+    expo: options => new expo_1.Expo(options),
     ocaml: options => new ocaml_1.OCaml(options),
     php: options => new php_1.PHP(options),
     'php-yoshi': options => new php_yoshi_1.PHPYoshi(options),

package/build/src/github.d.ts

@@ -73,6 +73,10 @@ interface FileDiff {
     readonly originalContent: string | null;
 }
 export declare type ChangeSet = Map<string, FileDiff>;
+interface CreatePullRequestOptions {
+    fork?: boolean;
+    draft?: boolean;
+}
 export declare class GitHub {
     readonly repository: Repository;
     private octokit;
@@ -226,6 +230,7 @@ export declare class GitHub {
      * @param {string} path The path to the file in the repository
      * @param {string} branch The branch to fetch from
      * @returns {GitHubFileContents}
+     * @throws {FileNotFoundError} if the file cannot be found
      * @throws {GitHubAPIError} on other API errors
      */
     getFileContentsOnBranch(path: string, branch: string): Promise<GitHubFileContents>;
@@ -281,6 +286,8 @@ export declare class GitHub {
     /**
      * Open a pull request
      *
+     * @deprecated This logic is handled by the Manifest class now as it
+     *   can be more complicated if the release notes are too big
      * @param {ReleasePullRequest} releasePullRequest Pull request data to update
      * @param {string} targetBranch The base branch of the pull request
      * @param {GitHubPR} options The pull request options
@@ -291,10 +298,17 @@ export declare class GitHub {
         fork?: boolean;
         skipLabeling?: boolean;
     }): Promise<PullRequest>;
-    createPullRequest: (pullRequest: PullRequest, targetBranch: string, message: string, updates: Update[], options?: {
-        fork?: boolean | undefined;
-        draft?: boolean | undefined;
-    } | undefined) => Promise<PullRequest>;
+    /**
+     * Open a pull request
+     *
+     * @param {PullRequest} pullRequest Pull request data to update
+     * @param {string} targetBranch The base branch of the pull request
+     * @param {string} message The commit message for the commit
+     * @param {Update[]} updates The files to update
+     * @param {CreatePullRequestOptions} options The pull request options
+     * @throws {GitHubAPIError} on an API error
+     */
+    createPullRequest: (pullRequest: PullRequest, targetBranch: string, message: string, updates: Update[], options?: CreatePullRequestOptions | undefined) => Promise<PullRequest>;
     /**
      * Fetch a pull request given the pull number
      * @param {number} number The pull request number
@@ -387,6 +401,43 @@ export declare class GitHub {
      * @param {string} previousTag Optional. Name of previous tag to analyze commits since
      */
     generateReleaseNotes(tagName: string, targetCommitish: string, previousTag?: string): Promise<string>;
+    /**
+     * Create a single file on a new branch based on an existing
+     * branch. This will force-push to that branch.
+     * @param {string} filename Filename with path in the repository
+     * @param {string} contents Contents of the file
+     * @param {string} newBranchName Name of the new branch
+     * @param {string} baseBranchName Name of the base branch (where
+     *   new branch is forked from)
+     * @returns {string} HTML URL of the new file
+     */
+    createFileOnNewBranch(filename: string, contents: string, newBranchName: string, baseBranchName: string): Promise<string>;
+    /**
+     * Helper to fetch the SHA of a branch
+     * @param {string} branchName The name of the branch
+     * @return {string | undefined} Returns the SHA of the branch
+     *   or undefined if it can't be found.
+     */
+    private getBranchSha;
+    /**
+     * Helper to fork a branch from an existing branch. Uses `force` so
+     * it will overwrite the contents of `targetBranchName` to match
+     * the current contents of `baseBranchName`.
+     *
+     * @param {string} targetBranchName The name of the new forked branch
+     * @param {string} baseBranchName The base branch from which to fork.
+     * @returns {string} The branch SHA
+     * @throws {ConfigurationError} if the base branch cannot be found.
+     */
+    private forkBranch;
+    /**
+     * Helper to create a new branch from a given SHA.
+     * @param {string} branchName The new branch name
+     * @param {string} branchSha The SHA of the branch
+     * @returns {string} The SHA of the new branch
+     */
+    private createNewBranch;
+    private updateBranchSha;
 }
 export declare const sleepInMs: (ms: number) => Promise<unknown>;
 export {};

package/build/src/github.js

@@ -130,6 +130,16 @@ class GitHub {
             this.logger.debug(`finding files by glob: ${glob}, ref: ${ref}, prefix: ${prefix}`);
             return await this.fileCache.findFilesByGlob(glob, ref, prefix);
         });
+        /**
+         * Open a pull request
+         *
+         * @param {PullRequest} pullRequest Pull request data to update
+         * @param {string} targetBranch The base branch of the pull request
+         * @param {string} message The commit message for the commit
+         * @param {Update[]} updates The files to update
+         * @param {CreatePullRequestOptions} options The pull request options
+         * @throws {GitHubAPIError} on an API error
+         */
         this.createPullRequest = wrapAsync(async (pullRequest, targetBranch, message, updates, options) => {
             //  Update the files for the release if not already supplied
             const changes = await this.buildChangeSet(updates, targetBranch);
@@ -914,6 +924,7 @@ class GitHub {
      * @param {string} path The path to the file in the repository
      * @param {string} branch The branch to fetch from
      * @returns {GitHubFileContents}
+     * @throws {FileNotFoundError} if the file cannot be found
      * @throws {GitHubAPIError} on other API errors
      */
     async getFileContentsOnBranch(path, branch) {
@@ -963,6 +974,8 @@ class GitHub {
     /**
      * Open a pull request
      *
+     * @deprecated This logic is handled by the Manifest class now as it
+     *   can be more complicated if the release notes are too big
      * @param {ReleasePullRequest} releasePullRequest Pull request data to update
      * @param {string} targetBranch The base branch of the pull request
      * @param {GitHubPR} options The pull request options
@@ -1060,6 +1073,119 @@ class GitHub {
         });
         return resp.data.body;
     }
+    /**
+     * Create a single file on a new branch based on an existing
+     * branch. This will force-push to that branch.
+     * @param {string} filename Filename with path in the repository
+     * @param {string} contents Contents of the file
+     * @param {string} newBranchName Name of the new branch
+     * @param {string} baseBranchName Name of the base branch (where
+     *   new branch is forked from)
+     * @returns {string} HTML URL of the new file
+     */
+    async createFileOnNewBranch(filename, contents, newBranchName, baseBranchName) {
+        // create or update new branch to match base branch
+        await this.forkBranch(newBranchName, baseBranchName);
+        // use the single file upload API
+        const { data: { content }, } = await this.octokit.repos.createOrUpdateFileContents({
+            owner: this.repository.owner,
+            repo: this.repository.repo,
+            path: filename,
+            // contents need to be base64 encoded
+            content: Buffer.from(contents, 'binary').toString('base64'),
+            message: 'Saving release notes',
+            branch: newBranchName,
+        });
+        if (!(content === null || content === void 0 ? void 0 : content.html_url)) {
+            throw new Error(`Failed to write to file: ${filename} on branch: ${newBranchName}`);
+        }
+        return content.html_url;
+    }
+    /**
+     * Helper to fetch the SHA of a branch
+     * @param {string} branchName The name of the branch
+     * @return {string | undefined} Returns the SHA of the branch
+     *   or undefined if it can't be found.
+     */
+    async getBranchSha(branchName) {
+        this.logger.debug(`Looking up SHA for branch: ${branchName}`);
+        try {
+            const { data: { object: { sha }, }, } = await this.octokit.git.getRef({
+                owner: this.repository.owner,
+                repo: this.repository.repo,
+                ref: `heads/${branchName}`,
+            });
+            this.logger.debug(`SHA for branch: ${sha}`);
+            return sha;
+        }
+        catch (e) {
+            if (e instanceof request_error_1.RequestError && e.status === 404) {
+                this.logger.debug(`Branch: ${branchName} does not exist`);
+                return undefined;
+            }
+            throw e;
+        }
+    }
+    /**
+     * Helper to fork a branch from an existing branch. Uses `force` so
+     * it will overwrite the contents of `targetBranchName` to match
+     * the current contents of `baseBranchName`.
+     *
+     * @param {string} targetBranchName The name of the new forked branch
+     * @param {string} baseBranchName The base branch from which to fork.
+     * @returns {string} The branch SHA
+     * @throws {ConfigurationError} if the base branch cannot be found.
+     */
+    async forkBranch(targetBranchName, baseBranchName) {
+        const baseBranchSha = await this.getBranchSha(baseBranchName);
+        if (!baseBranchSha) {
+            // this is highly unlikely to be thrown as we will have
+            // already attempted to read from the branch
+            throw new errors_1.ConfigurationError(`Unable to find base branch: ${baseBranchName}`, 'core', `${this.repository.owner}/${this.repository.repo}`);
+        }
+        // see if newBranchName exists
+        if (await this.getBranchSha(targetBranchName)) {
+            // branch already exists, update it to the match the base branch
+            const branchSha = await this.updateBranchSha(targetBranchName, baseBranchSha);
+            this.logger.debug(`Updated ${targetBranchName} to match ${baseBranchName} at ${branchSha}`);
+            return branchSha;
+        }
+        else {
+            // branch does not exist, create a new branch from the base branch
+            const branchSha = await this.createNewBranch(targetBranchName, baseBranchSha);
+            this.logger.debug(`Forked ${targetBranchName} from ${baseBranchName} at ${branchSha}`);
+            return branchSha;
+        }
+    }
+    /**
+     * Helper to create a new branch from a given SHA.
+     * @param {string} branchName The new branch name
+     * @param {string} branchSha The SHA of the branch
+     * @returns {string} The SHA of the new branch
+     */
+    async createNewBranch(branchName, branchSha) {
+        this.logger.debug(`Creating new branch: ${branchName} at ${branchSha}`);
+        const { data: { object: { sha }, }, } = await this.octokit.git.createRef({
+            owner: this.repository.owner,
+            repo: this.repository.repo,
+            ref: `refs/heads/${branchName}`,
+            sha: branchSha,
+        });
+        this.logger.debug(`New branch: ${branchName} at ${sha}`);
+        return sha;
+    }
+    async updateBranchSha(branchName, branchSha) {
+        this.logger.debug(`Updating branch ${branchName} to ${branchSha}`);
+        const { data: { object: { sha }, }, } = await this.octokit.git.updateRef({
+            owner: this.repository.owner,
+            repo: this.repository.repo,
+            ref: `heads/${branchName}`,
+            sha: branchSha,
+            force: true,
+        });
+        this.logger.debug(`Updated branch: ${branchName} to ${sha}`);
+        return sha;
+    }
 }
 exports.GitHub = GitHub;
 /**

package/build/src/manifest.d.ts

@@ -211,6 +211,7 @@ export declare class Manifest {
     readonly releaseSearchDepth: number;
     readonly commitSearchDepth: number;
     readonly logger: Logger;
+    private pullRequestOverflowHandler;
     /**
      * Create a Manifest from explicit config in code. This assumes that the
      * repository has a single component at the root path.

package/build/src/manifest.js

@@ -21,10 +21,11 @@ const tag_name_1 = require("./util/tag-name");
 const branch_name_1 = require("./util/branch-name");
 const pull_request_title_1 = require("./util/pull-request-title");
 const factory_1 = require("./factory");
-const pull_request_body_1 = require("./util/pull-request-body");
 const merge_1 = require("./plugins/merge");
 const release_please_manifest_1 = require("./updaters/release-please-manifest");
 const errors_1 = require("./errors");
+const pull_request_overflow_handler_1 = require("./util/pull-request-overflow-handler");
+const signoff_commit_message_1 = require("./util/signoff-commit-message");
 exports.DEFAULT_RELEASE_PLEASE_CONFIG = 'release-please-config.json';
 exports.DEFAULT_RELEASE_PLEASE_MANIFEST = '.release-please-manifest.json';
 exports.ROOT_PROJECT_PATH = '.';
@@ -100,6 +101,7 @@ class Manifest {
             repositoryConfig: this.repositoryConfig,
             manifestPath: this.manifestPath,
         }));
+        this.pullRequestOverflowHandler = new pull_request_overflow_handler_1.FilePullRequestOverflowHandler(this.github, this.logger);
     }
     /**
      * Create a Manifest from config files in the repository.
@@ -451,11 +453,16 @@ class Manifest {
         const openPullRequests = [];
         const generator = this.github.pullRequestIterator(this.targetBranch, 'OPEN', Number.MAX_SAFE_INTEGER, false);
         for await (const openPullRequest of generator) {
-            if ((hasAllLabels(this.labels, openPullRequest.labels) ||
-                hasAllLabels(this.snapshotLabels, openPullRequest.labels)) &&
-                branch_name_1.BranchName.parse(openPullRequest.headBranchName, this.logger) &&
-                pull_request_body_1.PullRequestBody.parse(openPullRequest.body, this.logger)) {
-                openPullRequests.push(openPullRequest);
+            if (hasAllLabels(this.labels, openPullRequest.labels) ||
+                hasAllLabels(this.snapshotLabels, openPullRequest.labels)) {
+                const body = await this.pullRequestOverflowHandler.parseOverflow(openPullRequest);
+                if (body) {
+                    // maybe replace with overflow body
+                    openPullRequests.push({
+                        ...openPullRequest,
+                        body: body.toString(),
+                    });
+                }
             }
         }
         this.logger.info(`found ${openPullRequests.length} open release pull requests.`);
@@ -467,9 +474,15 @@ class Manifest {
         const closedGenerator = this.github.pullRequestIterator(this.targetBranch, 'CLOSED', 200, false);
         for await (const closedPullRequest of closedGenerator) {
             if (hasAllLabels([exports.SNOOZE_LABEL], closedPullRequest.labels) &&
-                branch_name_1.BranchName.parse(closedPullRequest.headBranchName, this.logger) &&
-                pull_request_body_1.PullRequestBody.parse(closedPullRequest.body, this.logger)) {
-                snoozedPullRequests.push(closedPullRequest);
+                branch_name_1.BranchName.parse(closedPullRequest.headBranchName, this.logger)) {
+                const body = await this.pullRequestOverflowHandler.parseOverflow(closedPullRequest);
+                if (body) {
+                    // maybe replace with overflow body
+                    snoozedPullRequests.push({
+                        ...closedPullRequest,
+                        body: body.toString(),
+                    });
+                }
             }
         }
         this.logger.info(`found ${snoozedPullRequests.length} snoozed release pull requests.`);
@@ -486,10 +499,21 @@ class Manifest {
         if (snoozed) {
             return await this.maybeUpdateSnoozedPullRequest(snoozed, pullRequest);
         }
-        const newPullRequest = await this.github.createReleasePullRequest(pullRequest, this.targetBranch, {
+        const body = await this.pullRequestOverflowHandler.handleOverflow(pullRequest);
+        const message = this.signoffUser
+            ? (0, signoff_commit_message_1.signoffCommitMessage)(pullRequest.title.toString(), this.signoffUser)
+            : pullRequest.title.toString();
+        const newPullRequest = await this.github.createPullRequest({
+            headBranchName: pullRequest.headRefName,
+            baseBranchName: this.targetBranch,
+            number: -1,
+            title: pullRequest.title.toString(),
+            body,
+            labels: this.skipLabeling ? [] : pullRequest.labels,
+            files: [],
+        }, this.targetBranch, message, pullRequest.updates, {
             fork: this.fork,
-            signoffUser: this.signoffUser,
-            skipLabeling: this.skipLabeling,
+            draft: pullRequest.draft,
         });
         return newPullRequest;
     }
@@ -529,12 +553,17 @@ class Manifest {
                 continue;
             }
             this.logger.debug(`Found pull request #${pullRequest.number}: '${pullRequest.title}'`);
-            const pullRequestBody = pull_request_body_1.PullRequestBody.parse(pullRequest.body, this.logger);
+            // if the pull request body overflows, handle it
+            const pullRequestBody = await this.pullRequestOverflowHandler.parseOverflow(pullRequest);
             if (!pullRequestBody) {
                 this.logger.debug('could not parse pull request body as a release PR');
                 continue;
             }
-            yield pullRequest;
+            // replace with the complete fetched body
+            yield {
+                ...pullRequest,
+                body: pullRequestBody.toString(),
+            };
         }
     }
     /**

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

@@ -0,0 +1,15 @@
+import { BuildUpdatesOptions } from './base';
+import { Node } from './node';
+import { Update } from '../update';
+import { Version } from '../version';
+/**
+ * Strategy for building Expo based React Native projects. This strategy extends
+ * the Node strategy to additionally update the `app.json` file of a project.
+ */
+export declare class Expo extends Node {
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    /**
+     * Determine the Expo SDK version by parsing the package.json dependencies.
+     */
+    getExpoSDKVersion(): Promise<Version>;
+}

package/build/src/strategies/expo.js

@@ -0,0 +1,51 @@
+"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.Expo = void 0;
+const node_1 = require("./node");
+const app_json_1 = require("../updaters/expo/app-json");
+const version_1 = require("../version");
+/**
+ * Strategy for building Expo based React Native projects. This strategy extends
+ * the Node strategy to additionally update the `app.json` file of a project.
+ */
+class Expo extends node_1.Node {
+    async buildUpdates(options) {
+        const version = options.newVersion;
+        const updates = await super.buildUpdates(options);
+        const expoSDKVersion = await this.getExpoSDKVersion();
+        updates.push({
+            path: this.addPath('app.json'),
+            createIfMissing: false,
+            updater: new app_json_1.AppJson({ version, expoSDKVersion }),
+        });
+        return updates;
+    }
+    /**
+     * Determine the Expo SDK version by parsing the package.json dependencies.
+     */
+    async getExpoSDKVersion() {
+        var _a, _b, _c, _d;
+        const pkgJsonContents = await this.getPkgJsonContents();
+        const pkg = JSON.parse(pkgJsonContents.parsedContent);
+        return version_1.Version.parse(((_a = pkg.dependencies) === null || _a === void 0 ? void 0 : _a.expo) ||
+            ((_b = pkg.devDependencies) === null || _b === void 0 ? void 0 : _b.expo) ||
+            ((_c = pkg.peerDependencies) === null || _c === void 0 ? void 0 : _c.expo) ||
+            ((_d = pkg.optionalDependencies) === null || _d === void 0 ? void 0 : _d.expo) ||
+            '0.0.0');
+    }
+}
+exports.Expo = Expo;
+//# sourceMappingURL=expo.js.map

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

@@ -1,9 +1,10 @@
 import { BaseStrategy, BuildUpdatesOptions } from './base';
 import { Update } from '../update';
+import { GitHubFileContents } from '@google-automations/git-file-utils';
 export declare class Node extends BaseStrategy {
     private pkgJsonContents?;
     protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
     getDefaultPackageName(): Promise<string | undefined>;
     protected normalizeComponent(component: string | undefined): string;
-    private getPkgJsonContents;
+    protected getPkgJsonContents(): Promise<GitHubFileContents>;
 }

package/build/src/updaters/expo/app-json.d.ts

@@ -0,0 +1,31 @@
+import { Logger } from '../../util/logger';
+import { DefaultUpdater, UpdateOptions } from '../default';
+import { Version } from '../../version';
+export interface AppJson {
+    expo: {
+        version: string;
+        ios?: {
+            buildNumber?: string;
+        };
+        android?: {
+            versionCode?: string;
+        };
+    };
+}
+export interface AppJsonOptions extends UpdateOptions {
+    expoSDKVersion: Version;
+}
+/**
+ * This updates a React Natve Expo project app.json file's main, ios and android
+ * versions. All values except the `android.versionCode` are standard semver
+ * version numbers. For the `android.versionCode`, the semver number is used as
+ * the basis for the `versionCode`.
+ */
+export declare class AppJson extends DefaultUpdater {
+    expoSDKVersion: Version;
+    constructor(options: AppJsonOptions);
+    /**
+     * Given initial file contents, return updated contents.
+     */
+    updateContent(content: string, logger?: Logger): string;
+}

package/build/src/updaters/expo/app-json.js

@@ -0,0 +1,67 @@
+"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.AppJson = void 0;
+const json_stringify_1 = require("../../util/json-stringify");
+const logger_1 = require("../../util/logger");
+const default_1 = require("../default");
+/**
+ * This updates a React Natve Expo project app.json file's main, ios and android
+ * versions. All values except the `android.versionCode` are standard semver
+ * version numbers. For the `android.versionCode`, the semver number is used as
+ * the basis for the `versionCode`.
+ */
+class AppJson extends default_1.DefaultUpdater {
+    constructor(options) {
+        super(options);
+        this.expoSDKVersion = options.expoSDKVersion;
+    }
+    /**
+     * Given initial file contents, return updated contents.
+     */
+    updateContent(content, logger = logger_1.logger) {
+        var _a, _b;
+        const parsed = JSON.parse(content);
+        logger.info(`updating Expo version from ${parsed.expo.version} to ${this.version}`);
+        parsed.expo.version = this.version.toString();
+        if ((_a = parsed.expo.ios) === null || _a === void 0 ? void 0 : _a.buildNumber) {
+            logger.info(`updating iOS version from ${parsed.expo.ios.buildNumber} to ${this.version}`);
+            parsed.expo.ios.buildNumber = this.version.toString();
+        }
+        if ((_b = parsed.expo.android) === null || _b === void 0 ? void 0 : _b.versionCode) {
+            // Android versionCode
+            // https://developer.android.com/studio/publish/versioning#appversioning
+            let expoMajorVersion = 0;
+            try {
+                expoMajorVersion = this.expoSDKVersion.major;
+            }
+            catch (e) {
+                // Rethrow with a nice error message.
+                throw new Error('Unable to determine the Expo SDK version for this project. Make sure that the expo package is installed for your project.');
+            }
+            // Implements the `versionCode` strategy described by Maxi Rosson
+            // @see https://medium.com/@maxirosson/versioning-android-apps-d6ec171cfd82
+            const versionCode = expoMajorVersion * 10000000 +
+                this.version.major * 10000 +
+                this.version.minor * 100 +
+                this.version.patch;
+            logger.info(`updating Android version from ${parsed.expo.android.versionCode} to ${versionCode}`);
+            parsed.expo.android.versionCode = versionCode.toString();
+        }
+        return (0, json_stringify_1.jsonStringify)(parsed, content);
+    }
+}
+exports.AppJson = AppJson;
+//# sourceMappingURL=app-json.js.map

package/build/src/util/pull-request-body.js

@@ -36,8 +36,10 @@ class PullRequestBody {
             return undefined;
         }
         let data = extractMultipleReleases(parts.content, logger);
+        let useComponents = true;
         if (data.length === 0) {
             data = extractSingleRelease(parts.content, logger);
+            useComponents = false;
             if (data.length === 0) {
                 logger.warn('Failed to parse releases.');
             }
@@ -45,6 +47,7 @@ class PullRequestBody {
         return new PullRequestBody(data, {
             header: parts.header,
             footer: parts.footer,
+            useComponents,
         });
     }
     notes() {

package/build/src/util/pull-request-overflow-handler.d.ts

@@ -0,0 +1,54 @@
+import { PullRequestBody } from './pull-request-body';
+import { GitHub } from '../github';
+import { PullRequest } from '../pull-request';
+import { Logger } from './logger';
+import { ReleasePullRequest } from '../release-pull-request';
+/**
+ * Interface for managing the pull request body contents when the content
+ * is too large to fit into a pull request.
+ */
+export interface PullRequestOverflowHandler {
+    /**
+     * If a pull request's body is too big, store it somewhere and return
+     * a new pull request body with information about the new location.
+     * @param {ReleasePullRequest} pullRequest The candidate release pull request
+     * @returns {string} The new pull request body which may contain a link to
+     *   the full content.
+     */
+    handleOverflow(pullRequest: ReleasePullRequest, maxSize?: number): Promise<string>;
+    /**
+     * Given a pull request, parse the pull request body from the pull request
+     * or storage if the body was too big to store in the pull request body.
+     * @param {PullRequest} pullRequest The pull request from GitHub
+     * @return {PullRequestBody} The parsed pull request body
+     */
+    parseOverflow(pullRequest: PullRequest): Promise<PullRequestBody | undefined>;
+}
+/**
+ * This implementation of PullRequestOverflowHandler stores the full release
+ * notes on a new git branch. The branch name is derived from the head branch
+ * name of the release pull request.
+ */
+export declare class FilePullRequestOverflowHandler implements PullRequestOverflowHandler {
+    private github;
+    private logger;
+    constructor(github: GitHub, logger?: Logger);
+    /**
+     * Optionally store the full release notes into `release-notes.md` file
+     * on a new branch if they do not fit into the body of a pull request.
+     *
+     * The new release notes will have a link to the GitHub UI for that file
+     * which should render the release notes nicely.
+     * @param {ReleasePullRequest} pullRequest The candidate release pull request
+     * @returns {string} The new pull request body which contains a link to
+     *   the full content.
+     */
+    handleOverflow(pullRequest: ReleasePullRequest, maxSize?: number): Promise<string>;
+    /**
+     * Given a pull request, retrieve the full release notes from the stored
+     * file if the body was too big to store in the pull request body.
+     * @param {PullRequest} pullRequest The pull request from GitHub
+     * @return {PullRequestBody} The parsed pull request body
+     */
+    parseOverflow(pullRequest: PullRequest): Promise<PullRequestBody | undefined>;
+}

package/build/src/util/pull-request-overflow-handler.js

@@ -0,0 +1,78 @@
+"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.FilePullRequestOverflowHandler = void 0;
+const pull_request_body_1 = require("./pull-request-body");
+const logger_1 = require("./logger");
+const url_1 = require("url");
+const MAX_ISSUE_BODY_SIZE = 65536;
+const OVERFLOW_MESSAGE = 'This release is too large to preview in the pull request body. View the full release notes here:';
+const OVERFLOW_MESSAGE_REGEX = new RegExp(`${OVERFLOW_MESSAGE} (?<url>.*)`);
+const RELEASE_NOTES_FILENAME = 'release-notes.md';
+const FILE_PATH_REGEX = new RegExp(`blob/(?<branchName>.*)/${RELEASE_NOTES_FILENAME}`);
+/**
+ * This implementation of PullRequestOverflowHandler stores the full release
+ * notes on a new git branch. The branch name is derived from the head branch
+ * name of the release pull request.
+ */
+class FilePullRequestOverflowHandler {
+    constructor(github, logger = logger_1.logger) {
+        this.github = github;
+        this.logger = logger;
+    }
+    /**
+     * Optionally store the full release notes into `release-notes.md` file
+     * on a new branch if they do not fit into the body of a pull request.
+     *
+     * The new release notes will have a link to the GitHub UI for that file
+     * which should render the release notes nicely.
+     * @param {ReleasePullRequest} pullRequest The candidate release pull request
+     * @returns {string} The new pull request body which contains a link to
+     *   the full content.
+     */
+    async handleOverflow(pullRequest, maxSize = MAX_ISSUE_BODY_SIZE) {
+        const notes = pullRequest.body.toString();
+        if (notes.length > maxSize) {
+            const notesBranchName = `${pullRequest.headRefName}--release-notes`;
+            const url = await this.github.createFileOnNewBranch(RELEASE_NOTES_FILENAME, notes, notesBranchName, this.github.repository.defaultBranch);
+            return `${OVERFLOW_MESSAGE} ${url}`;
+        }
+        return notes;
+    }
+    /**
+     * Given a pull request, retrieve the full release notes from the stored
+     * file if the body was too big to store in the pull request body.
+     * @param {PullRequest} pullRequest The pull request from GitHub
+     * @return {PullRequestBody} The parsed pull request body
+     */
+    async parseOverflow(pullRequest) {
+        var _a, _b;
+        const match = pullRequest.body.match(OVERFLOW_MESSAGE_REGEX);
+        if ((_a = match === null || match === void 0 ? void 0 : match.groups) === null || _a === void 0 ? void 0 : _a.url) {
+            this.logger.info(`Pull request body overflows, parsing full body from: ${match.groups.url}`);
+            const url = new url_1.URL(match.groups.url);
+            const pathMatch = url.pathname.match(FILE_PATH_REGEX);
+            if ((_b = pathMatch === null || pathMatch === void 0 ? void 0 : pathMatch.groups) === null || _b === void 0 ? void 0 : _b.branchName) {
+                const fileContents = await this.github.getFileContentsOnBranch(RELEASE_NOTES_FILENAME, pathMatch.groups.branchName);
+                return pull_request_body_1.PullRequestBody.parse(fileContents.parsedContent);
+            }
+            this.logger.warn(`Could not parse branch from ${match.groups.url}`);
+            return pull_request_body_1.PullRequestBody.parse(pullRequest.body, this.logger);
+        }
+        return pull_request_body_1.PullRequestBody.parse(pullRequest.body, this.logger);
+    }
+}
+exports.FilePullRequestOverflowHandler = FilePullRequestOverflowHandler;
+//# sourceMappingURL=pull-request-overflow-handler.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-please",
-  "version": "14.11.2",
+  "version": "14.13.0",
   "description": "generate release PRs based on the conventionalcommits.org spec",
   "main": "./build/src/index.js",
   "bin": "./build/src/bin/release-please.js",
@@ -38,7 +38,7 @@
     }
   },
   "devDependencies": {
-    "@octokit/types": "^7.0.0",
+    "@octokit/types": "^8.0.0",
     "@types/chai": "^4.1.7",
     "@types/diff": "^5.0.2",
     "@types/iarna__toml": "^2.0.1",