release-please 14.12.0 → 14.13.0

package/CHANGELOG.md

@@ -4,6 +4,13 @@
 
 [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)
 
 

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/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.12.0",
+  "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",