release-please 13.4.7 → 13.4.11

package/CHANGELOG.md

@@ -4,6 +4,42 @@
 
 [1]: https://www.npmjs.com/package/release-please?activeTab=versions
 
+### [13.4.11](https://github.com/googleapis/release-please/compare/v13.4.10...v13.4.11) (2022-02-18)
+
+
+### Bug Fixes
+
+* introduce file cache to simplify fetching files including file mode ([#1280](https://github.com/googleapis/release-please/issues/1280)) ([d7280b7](https://github.com/googleapis/release-please/commit/d7280b7eac3056e28399a0b80ea26002f0dff1b4))
+
+### [13.4.10](https://github.com/googleapis/release-please/compare/v13.4.9...v13.4.10) (2022-02-16)
+
+
+### Bug Fixes
+
+* **go-yoshi:** dynamically load list of ignored submodules for google-cloud-go ([#1291](https://github.com/googleapis/release-please/issues/1291)) ([36f6ad9](https://github.com/googleapis/release-please/commit/36f6ad94fe471e5a46cc46ebd6f5b5c581a29c2c))
+* manifest release can handle componentless entry ([#1300](https://github.com/googleapis/release-please/issues/1300)) ([6b58573](https://github.com/googleapis/release-please/commit/6b585734fe7b49f0e351b73b27260a304d6c80dd))
+* return uploadUrl and body when creating release ([#1298](https://github.com/googleapis/release-please/issues/1298)) ([5d767c5](https://github.com/googleapis/release-please/commit/5d767c536594a8e24d274a4268cda1f1aa3babff))
+
+### [13.4.9](https://github.com/googleapis/release-please/compare/v13.4.8...v13.4.9) (2022-02-14)
+
+
+### Bug Fixes
+
+* standalone releases should only be released by its matching component ([#1296](https://github.com/googleapis/release-please/issues/1296)) ([75dd686](https://github.com/googleapis/release-please/commit/75dd686a667da397b54498f543128d4cc6bb784e))
+
+### [13.4.8](https://github.com/googleapis/release-please/compare/v13.4.7...v13.4.8) (2022-02-08)
+
+
+### Bug Fixes
+
+* allow configuring includeComponentInTag and tagSeparator from manifest config ([71d9b6d](https://github.com/googleapis/release-please/commit/71d9b6d5775bb1a35157c7ec512ef4d1d9f7feec))
+* check recent commits and latest releases for latest version ([#1267](https://github.com/googleapis/release-please/issues/1267)) ([f931842](https://github.com/googleapis/release-please/commit/f931842a117c97dd117f161c89beb1c9e2257fa2))
+* correctly fetch full list of files ([71d9b6d](https://github.com/googleapis/release-please/commit/71d9b6d5775bb1a35157c7ec512ef4d1d9f7feec))
+* **go-yoshi:** allows using go-yoshi with manifest ([#1287](https://github.com/googleapis/release-please/issues/1287)) ([71d9b6d](https://github.com/googleapis/release-please/commit/71d9b6d5775bb1a35157c7ec512ef4d1d9f7feec))
+* **go-yoshi:** should not always skip modules ([71d9b6d](https://github.com/googleapis/release-please/commit/71d9b6d5775bb1a35157c7ec512ef4d1d9f7feec))
+* Manifest should be able to find tagged versions without a release ([71d9b6d](https://github.com/googleapis/release-please/commit/71d9b6d5775bb1a35157c7ec512ef4d1d9f7feec))
+* provide pull request to commit parser allow overrides ([#1285](https://github.com/googleapis/release-please/issues/1285)) ([e54028b](https://github.com/googleapis/release-please/commit/e54028bb39c4535f42b0b90c60b7f331847d005c))
+
 ### [13.4.7](https://github.com/googleapis/release-please/compare/v13.4.6...v13.4.7) (2022-02-02)
 
 

package/build/src/errors/index.d.ts

@@ -29,4 +29,8 @@ export declare class DuplicateReleaseError extends GitHubAPIError {
     tag: string;
     constructor(requestError: RequestError, tag: string);
 }
+export declare class FileNotFoundError extends Error {
+    path: string;
+    constructor(path: string);
+}
 export {};

package/build/src/errors/index.js

@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DuplicateReleaseError = exports.AuthError = exports.GitHubAPIError = exports.MissingRequiredFileError = exports.ConfigurationError = void 0;
+exports.FileNotFoundError = exports.DuplicateReleaseError = exports.AuthError = exports.GitHubAPIError = exports.MissingRequiredFileError = exports.ConfigurationError = void 0;
 class ConfigurationError extends Error {
     constructor(message, releaserName, repository) {
         super(`${releaserName} (${repository}): ${message}`);
@@ -38,6 +38,7 @@ class GitHubAPIError extends Error {
         this.body = GitHubAPIError.parseErrorBody(requestError);
         this.name = GitHubAPIError.name;
         this.cause = requestError;
+        this.stack = requestError.stack;
     }
     static parseErrorBody(requestError) {
         const body = requestError.response;
@@ -65,4 +66,12 @@ class DuplicateReleaseError extends GitHubAPIError {
     }
 }
 exports.DuplicateReleaseError = DuplicateReleaseError;
+class FileNotFoundError extends Error {
+    constructor(path) {
+        super(`Failed to find file: ${path}`);
+        this.path = path;
+        this.name = FileNotFoundError.name;
+    }
+}
+exports.FileNotFoundError = FileNotFoundError;
 //# sourceMappingURL=index.js.map

package/build/src/factory.js

@@ -123,6 +123,7 @@ async function buildStrategy(options) {
         changelogNotes,
         pullRequestTitlePattern: options.pullRequestTitlePattern,
         extraFiles: options.extraFiles,
+        tagSeparator: options.tagSeparator,
     };
     switch (options.releaseType) {
         case 'ruby': {

package/build/src/github.d.ts

@@ -9,6 +9,7 @@ import { Repository } from './repository';
 import { ReleasePullRequest } from './release-pull-request';
 import { Update } from './update';
 import { Release } from './release';
+import { GitHubFileContents } from './util/file-cache';
 declare type RequestBuilderType = typeof request;
 declare type DefaultFunctionType = RequestBuilderType['defaults'];
 declare type RequestFunctionType = ReturnType<DefaultFunctionType>;
@@ -30,11 +31,6 @@ interface GitHubCreateOptions {
     octokitAPIs?: OctokitAPIs;
     token?: string;
 }
-export interface GitHubFileContents {
-    sha: string;
-    content: string;
-    parsedContent: string;
-}
 declare type CommitFilter = (commit: Commit) => boolean;
 interface CommitIteratorOptions {
     maxResults?: number;
@@ -57,6 +53,7 @@ export interface GitHubRelease {
     notes?: string;
     url: string;
     draft?: boolean;
+    uploadUrl?: string;
 }
 export interface GitHubTag {
     name: string;
@@ -67,6 +64,7 @@ export declare class GitHub {
     private octokit;
     private request;
     private graphql;
+    private fileCache;
     private constructor();
     /**
      * Build a new GitHub client with auto-detected default branch.
@@ -184,24 +182,6 @@ export declare class GitHub {
      * @throws {GitHubAPIError} on other API errors
      */
     getFileContents(path: string): Promise<GitHubFileContents>;
-    /**
-     * Fetch the contents of a file with the Contents API
-     *
-     * @param {string} path The path to the file in the repository
-     * @param {string} branch The branch to fetch from
-     * @returns {GitHubFileContents}
-     * @throws {GitHubAPIError} on other API errors
-     */
-    getFileContentsWithSimpleAPI: (path: string, ref: string, isBranch?: any) => Promise<GitHubFileContents>;
-    /**
-     * Fetch the contents of a file using the Git data API
-     *
-     * @param {string} path The path to the file in the repository
-     * @param {string} branch The branch to fetch from
-     * @returns {GitHubFileContents}
-     * @throws {GitHubAPIError} on other API errors
-     */
-    getFileContentsWithDataAPI: (path: string, branch: string) => Promise<GitHubFileContents>;
     /**
      * Fetch the contents of a file
      *

package/build/src/github.js

@@ -26,6 +26,7 @@ exports.GH_GRAPHQL_URL = 'https://api.github.com';
 const logger_1 = require("./util/logger");
 const manifest_1 = require("./manifest");
 const signoff_commit_message_1 = require("./util/signoff-commit-message");
+const file_cache_1 = require("./util/file-cache");
 class GitHub {
     constructor(options) {
         /**
@@ -37,13 +38,25 @@ class GitHub {
          */
         this.getCommitFiles = wrapAsync(async (sha) => {
             logger_1.logger.debug(`Backfilling file list for commit: ${sha}`);
-            const resp = await this.octokit.repos.getCommit({
+            const files = [];
+            for await (const resp of this.octokit.paginate.iterator(this.octokit.repos.getCommit, {
                 owner: this.repository.owner,
                 repo: this.repository.repo,
                 ref: sha,
-            });
-            const files = resp.data.files || [];
-            return files.map(file => file.filename).filter(filename => !!filename);
+            })) {
+                for (const f of resp.data.files || []) {
+                    if (f.filename) {
+                        files.push(f.filename);
+                    }
+                }
+            }
+            if (files.length >= 3000) {
+                logger_1.logger.warn(`Found ${files.length} files. This may not include all the files.`);
+            }
+            else {
+                logger_1.logger.debug(`Found ${files.length} files`);
+            }
+            return files;
         });
         this.graphqlRequest = wrapAsync(async (opts, maxRetries = 1) => {
             while (maxRetries >= 0) {
@@ -58,58 +71,6 @@ class GitHub {
                 maxRetries -= 1;
             }
         });
-        /**
-         * Fetch the contents of a file with the Contents API
-         *
-         * @param {string} path The path to the file in the repository
-         * @param {string} branch The branch to fetch from
-         * @returns {GitHubFileContents}
-         * @throws {GitHubAPIError} on other API errors
-         */
-        this.getFileContentsWithSimpleAPI = wrapAsync(async (path, ref, isBranch = true) => {
-            ref = isBranch ? fullyQualifyBranchRef(ref) : ref;
-            const options = {
-                owner: this.repository.owner,
-                repo: this.repository.repo,
-                path,
-                ref,
-            };
-            const resp = await this.request('GET /repos/:owner/:repo/contents/:path', options);
-            return {
-                parsedContent: Buffer.from(resp.data.content, 'base64').toString('utf8'),
-                content: resp.data.content,
-                sha: resp.data.sha,
-            };
-        });
-        /**
-         * Fetch the contents of a file using the Git data API
-         *
-         * @param {string} path The path to the file in the repository
-         * @param {string} branch The branch to fetch from
-         * @returns {GitHubFileContents}
-         * @throws {GitHubAPIError} on other API errors
-         */
-        this.getFileContentsWithDataAPI = wrapAsync(async (path, branch) => {
-            const repoTree = await this.octokit.git.getTree({
-                owner: this.repository.owner,
-                repo: this.repository.repo,
-                tree_sha: branch,
-            });
-            const blobDescriptor = repoTree.data.tree.find(tree => tree.path === path);
-            if (!blobDescriptor) {
-                throw new Error(`Could not find requested path: ${path}`);
-            }
-            const resp = await this.octokit.git.getBlob({
-                owner: this.repository.owner,
-                repo: this.repository.repo,
-                file_sha: blobDescriptor.sha,
-            });
-            return {
-                parsedContent: Buffer.from(resp.data.content, 'base64').toString('utf8'),
-                content: resp.data.content,
-                sha: resp.data.sha,
-            };
-        });
         /**
          * Returns a list of paths to all files with a given name.
          *
@@ -312,9 +273,13 @@ class GitHub {
                 name: resp.data.name || undefined,
                 tagName: resp.data.tag_name,
                 sha: resp.data.target_commitish,
-                notes: resp.data.body_text,
+                notes: resp.data.body_text ||
+                    resp.data.body ||
+                    resp.data.body_html ||
+                    undefined,
                 url: resp.data.html_url,
                 draft: resp.data.draft,
+                uploadUrl: resp.data.upload_url,
             };
         }, e => {
             if (e instanceof request_error_1.RequestError) {
@@ -383,6 +348,7 @@ class GitHub {
         this.octokit = options.octokitAPIs.octokit;
         this.request = options.octokitAPIs.request;
         this.graphql = options.octokitAPIs.graphql;
+        this.fileCache = new file_cache_1.RepositoryFileCache(this.octokit, this.repository);
     }
     /**
      * Build a new GitHub client with auto-detected default branch.
@@ -509,6 +475,7 @@ class GitHub {
         }
     }
     async mergeCommitsGraphQL(targetBranch, cursor, options = {}) {
+        var _a;
         logger_1.logger.debug(`Fetching merge commits on branch ${targetBranch} with cursor: ${cursor}`);
         const response = await this.graphqlRequest({
             query: `query pullRequestsSince($owner: String!, $repo: String!, $num: Int!, $maxFilesChanged: Int, $targetBranch: String!, $cursor: String) {
@@ -562,7 +529,7 @@ class GitHub {
             repo: this.repository.repo,
             num: 25,
             targetBranch,
-            maxFilesChanged: 64,
+            maxFilesChanged: 100,
         });
         // if the branch does exist, return null
         if (!response.repository.ref) {
@@ -592,9 +559,15 @@ class GitHub {
                     labels: pullRequest.labels.nodes.map(node => node.name),
                     files,
                 };
-                // We cannot directly fetch files on commits via graphql, only provide file
-                // information for commits with associated pull requests
-                commit.files = files;
+                if (((_a = pullRequest.files.pageInfo) === null || _a === void 0 ? void 0 : _a.hasNextPage) && options.backfillFiles) {
+                    logger_1.logger.info(`PR #${pullRequest.number} has many files, backfilling`);
+                    commit.files = await this.getCommitFiles(graphCommit.sha);
+                }
+                else {
+                    // We cannot directly fetch files on commits via graphql, only provide file
+                    // information for commits with associated pull requests
+                    commit.files = files;
+                }
             }
             else if (options.backfillFiles) {
                 // In this case, there is no squashed merge commit. This could be a simple
@@ -848,15 +821,7 @@ class GitHub {
      */
     async getFileContentsOnBranch(path, branch) {
         logger_1.logger.debug(`Fetching ${path} from branch ${branch}`);
-        try {
-            return await this.getFileContentsWithSimpleAPI(path, branch);
-        }
-        catch (err) {
-            if (err.status === 403) {
-                return await this.getFileContentsWithDataAPI(path, branch);
-            }
-            throw err;
-        }
+        return await this.fileCache.getFileContents(path, branch);
     }
     async getFileJson(path, branch) {
         const content = await this.getFileContentsOnBranch(path, branch);
@@ -915,15 +880,7 @@ class GitHub {
         for (const update of updates) {
             let content;
             try {
-                if (update.cachedFileContents) {
-                    // we already loaded the file contents earlier, let's not
-                    // hit GitHub again.
-                    content = { data: update.cachedFileContents };
-                }
-                else {
-                    const fileContent = await this.getFileContentsOnBranch(update.path, defaultBranch);
-                    content = { data: fileContent };
-                }
+                content = await this.getFileContentsOnBranch(update.path, defaultBranch);
             }
             catch (err) {
                 if (err.status !== 404)
@@ -936,13 +893,13 @@ class GitHub {
                 }
             }
             const contentText = content
-                ? Buffer.from(content.data.content, 'base64').toString('utf8')
+                ? Buffer.from(content.content, 'base64').toString('utf8')
                 : undefined;
             const updatedContent = update.updater.updateContent(contentText);
             if (updatedContent) {
                 changes.set(update.path, {
                     content: updatedContent,
-                    mode: '100644',
+                    mode: (content === null || content === void 0 ? void 0 : content.mode) || file_cache_1.DEFAULT_FILE_MODE,
                 });
             }
         }
@@ -982,17 +939,6 @@ class GitHub {
     }
 }
 exports.GitHub = GitHub;
-// Takes a potentially unqualified branch name, and turns it
-// into a fully qualified ref.
-//
-// e.g. main -> refs/heads/main
-function fullyQualifyBranchRef(refName) {
-    let final = refName;
-    if (final.indexOf('/') < 0) {
-        final = `refs/heads/${final}`;
-    }
-    return final;
-}
 /**
  * Normalize a provided prefix by removing leading and trailing
  * slashes.

package/build/src/manifest.d.ts

@@ -22,6 +22,7 @@ export interface ReleaserConfig {
     packageName?: string;
     includeComponentInTag?: boolean;
     pullRequestTitlePattern?: string;
+    tagSeparator?: string;
     changelogSections?: ChangelogSection[];
     changelogPath?: string;
     changelogType?: ChangelogNotesType;
@@ -54,6 +55,7 @@ interface ReleaserConfigJson {
     'include-component-in-tag'?: boolean;
     'changelog-type'?: ChangelogNotesType;
     'pull-request-title-pattern'?: string;
+    'tag-separator'?: string;
     'version-file'?: string;
     'extra-files'?: string[];
 }
@@ -196,6 +198,8 @@ export declare class Manifest {
      * @returns {ReleasePullRequest[]} The candidate pull requests to open or update.
      */
     buildPullRequests(): Promise<ReleasePullRequest[]>;
+    private backfillReleasesFromTags;
+    private getAllTags;
     /**
      * Opens/updates all candidate release pull requests for this repository.
      *

package/build/src/manifest.js

@@ -166,7 +166,6 @@ class Manifest {
         for await (const release of this.github.releaseIterator({
             maxResults: 400,
         })) {
-            // logger.debug(release);
             const tagName = tag_name_1.TagName.parse(release.tagName);
             if (!tagName) {
                 logger_1.logger.warn(`Unable to parse release name: ${release.name}`);
@@ -199,6 +198,18 @@ class Manifest {
             }
         }
         const needsBootstrap = releasesFound < expectedReleases;
+        if (releasesFound < expectedReleases) {
+            logger_1.logger.warn(`Expected ${expectedReleases} releases, only found ${releasesFound}`);
+            // Fall back to looking for missing releases using expected tags
+            const missingPaths = Object.keys(strategiesByPath).filter(path => !releasesByPath[path]);
+            logger_1.logger.warn(`Missing ${missingPaths.length} paths: ${missingPaths}`);
+            const missingReleases = await this.backfillReleasesFromTags(missingPaths, strategiesByPath);
+            for (const path in missingReleases) {
+                releaseShasByPath[path] = missingReleases[path].sha;
+                releasesByPath[path] = missingReleases[path];
+                releasesFound++;
+            }
+        }
         if (releasesFound < expectedReleases) {
             logger_1.logger.warn(`Expected ${expectedReleases} releases, only found ${releasesFound}`);
         }
@@ -246,6 +257,7 @@ class Manifest {
                 sha: commit.sha,
                 message: commit.message,
                 files: commit.files,
+                pullRequest: commit.pullRequest,
             });
         }
         if (releaseCommitsFound < expectedShas) {
@@ -322,6 +334,38 @@ class Manifest {
         }
         return newReleasePullRequests.map(pullRequestWithConfig => pullRequestWithConfig.pullRequest);
     }
+    async backfillReleasesFromTags(missingPaths, strategiesByPath) {
+        const releasesByPath = {};
+        const allTags = await this.getAllTags();
+        for (const path of missingPaths) {
+            const expectedVersion = this.releasedVersions[path];
+            if (!expectedVersion) {
+                logger_1.logger.warn(`No version for path ${path}`);
+                continue;
+            }
+            const component = await strategiesByPath[path].getComponent();
+            const expectedTag = new tag_name_1.TagName(expectedVersion, component, this.repositoryConfig[path].tagSeparator);
+            logger_1.logger.debug(`looking for tagName: ${expectedTag.toString()}`);
+            const foundTag = allTags[expectedTag.toString()];
+            if (foundTag) {
+                logger_1.logger.debug(`found: ${foundTag.name} ${foundTag.sha}`);
+                releasesByPath[path] = {
+                    name: foundTag.name,
+                    tag: expectedTag,
+                    sha: foundTag.sha,
+                    notes: '',
+                };
+            }
+        }
+        return releasesByPath;
+    }
+    async getAllTags() {
+        const allTags = {};
+        for await (const tag of this.github.tagIterator()) {
+            allTags[tag.name] = tag;
+        }
+        return allTags;
+    }
     /**
      * Opens/updates all candidate release pull requests for this repository.
      *
@@ -567,6 +611,7 @@ function extractReleaserConfig(config) {
         includeComponentInTag: config['include-component-in-tag'],
         changelogType: config['changelog-type'],
         pullRequestTitlePattern: config['pull-request-title-pattern'],
+        tagSeparator: config['tag-separator'],
     };
 }
 /**
@@ -628,6 +673,7 @@ async function latestReleaseVersion(github, targetBranch, prefix, pullRequestTit
     // collect set of recent commit SHAs seen to verify that the release
     // is in the current branch
     const commitShas = new Set();
+    const candidateReleaseVersions = [];
     // only look at the last 250 or so commits to find the latest tag - we
     // don't want to scan the entire repository history if this repo has never
     // been released
@@ -656,12 +702,15 @@ async function latestReleaseVersion(github, targetBranch, prefix, pullRequestTit
             // FIXME, don't hardcode this
             continue;
         }
-        return version;
+        if (version) {
+            logger_1.logger.debug(`Found latest release pull request: ${mergedPullRequest.number} version: ${version}`);
+            candidateReleaseVersions.push(version);
+            break;
+        }
     }
     // If not found from recent pull requests, look at releases. Iterate
     // through releases finding valid tags, then cross reference
     const releaseGenerator = github.releaseIterator();
-    const candidateReleaseVersions = [];
     for await (const release of releaseGenerator) {
         const tagName = tag_name_1.TagName.parse(release.tagName);
         if (!tagName) {
@@ -703,7 +752,7 @@ async function latestReleaseVersion(github, targetBranch, prefix, pullRequestTit
     return candidateTagVersion.sort((a, b) => b.compare(a))[0];
 }
 function mergeReleaserConfig(defaultConfig, pathConfig) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
     return {
         releaseType: (_b = (_a = pathConfig.releaseType) !== null && _a !== void 0 ? _a : defaultConfig.releaseType) !== null && _b !== void 0 ? _b : 'node',
         bumpMinorPreMajor: (_c = pathConfig.bumpMinorPreMajor) !== null && _c !== void 0 ? _c : defaultConfig.bumpMinorPreMajor,
@@ -718,7 +767,9 @@ function mergeReleaserConfig(defaultConfig, pathConfig) {
         packageName: (_m = pathConfig.packageName) !== null && _m !== void 0 ? _m : defaultConfig.packageName,
         versionFile: (_o = pathConfig.versionFile) !== null && _o !== void 0 ? _o : defaultConfig.versionFile,
         extraFiles: (_p = pathConfig.extraFiles) !== null && _p !== void 0 ? _p : defaultConfig.extraFiles,
-        pullRequestTitlePattern: (_q = pathConfig.pullRequestTitlePattern) !== null && _q !== void 0 ? _q : defaultConfig.pullRequestTitlePattern,
+        includeComponentInTag: (_q = pathConfig.includeComponentInTag) !== null && _q !== void 0 ? _q : defaultConfig.includeComponentInTag,
+        tagSeparator: (_r = pathConfig.tagSeparator) !== null && _r !== void 0 ? _r : defaultConfig.tagSeparator,
+        pullRequestTitlePattern: (_s = pathConfig.pullRequestTitlePattern) !== null && _s !== void 0 ? _s : defaultConfig.pullRequestTitlePattern,
     };
 }
 /**

package/build/src/strategies/base.js

@@ -239,14 +239,24 @@ class BaseStrategy {
             return;
         }
         const component = await this.getComponent();
-        logger_1.logger.info('component:', component);
-        const releaseData = pullRequestBody.releaseData.length === 1 &&
-            !pullRequestBody.releaseData[0].component
-            ? pullRequestBody.releaseData[0]
-            : pullRequestBody.releaseData.find(releaseData => {
+        let releaseData;
+        if (pullRequestBody.releaseData.length === 1 &&
+            !pullRequestBody.releaseData[0].component) {
+            // standalone release PR, ensure the components match
+            if (this.normalizeComponent(branchName.component) !==
+                this.normalizeComponent(component)) {
+                logger_1.logger.warn(`PR component: ${branchName.component} does not match configured component: ${component}`);
+                return;
+            }
+            releaseData = pullRequestBody.releaseData[0];
+        }
+        else {
+            // manifest release with multiple components
+            releaseData = pullRequestBody.releaseData.find(releaseData => {
                 return (this.normalizeComponent(releaseData.component) ===
                     this.normalizeComponent(component));
             });
+        }
         const notes = releaseData === null || releaseData === void 0 ? void 0 : releaseData.notes;
         if (notes === undefined) {
             logger_1.logger.warn('Failed to find release notes');

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

@@ -8,6 +8,7 @@ export declare class GoYoshi extends BaseStrategy {
     constructor(options: BaseStrategyOptions);
     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 initialReleaseVersion(): Version;
 }

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

@@ -19,19 +19,7 @@ const changelog_1 = require("../updaters/changelog");
 const version_1 = require("../version");
 const version_go_1 = require("../updaters/go/version-go");
 const logger_1 = require("../util/logger");
-// Commits containing a scope prefixed with an item in this array will be
-// ignored when generating a release PR for the parent module.
-const IGNORED_SUB_MODULES = new Set([
-    'bigtable',
-    'bigquery',
-    'datastore',
-    'firestore',
-    'logging',
-    'pubsub',
-    'pubsublite',
-    'spanner',
-    'storage',
-]);
+const path_1 = require("path");
 const REGEN_PR_REGEX = /.*auto-regenerate.*/;
 const REGEN_ISSUE_REGEX = /(?<prefix>.*)\(#(?<pr>.*)\)(\n|$)/;
 class GoYoshi extends base_1.BaseStrategy {
@@ -64,12 +52,9 @@ class GoYoshi extends base_1.BaseStrategy {
         let regenCommit;
         const component = await this.getComponent();
         logger_1.logger.debug('Filtering commits');
+        const ignoredSubmodules = await this.getIgnoredSubModules();
         return commits.filter(commit => {
             var _a, _b;
-            // ignore commits whose scope is in the list of ignored modules
-            if (IGNORED_SUB_MODULES.has(commit.scope || '')) {
-                return false;
-            }
             // Only have a single entry of the nightly regen listed in the changelog.
             // If there are more than one of these commits, append associated PR.
             if (this.repository.owner === 'googleapis' &&
@@ -123,7 +108,7 @@ class GoYoshi extends base_1.BaseStrategy {
                 else {
                     // This is the main module release, so ignore sub modules that
                     // are released independently
-                    for (const submodule of IGNORED_SUB_MODULES) {
+                    for (const submodule of ignoredSubmodules) {
                         if (commitMatchesScope(commit.scope, submodule)) {
                             logger_1.logger.debug(`Skipping ignored commit scope: ${commit.scope}`);
                             return false;
@@ -134,6 +119,22 @@ class GoYoshi extends base_1.BaseStrategy {
             return true;
         });
     }
+    async getIgnoredSubModules() {
+        // ignored submodules only applies to the root component of
+        // googleapis/google-cloud-go
+        if (this.repository.owner !== 'googleapis' ||
+            this.repository.repo !== 'google-cloud-go' ||
+            this.includeComponentInTag) {
+            return new Set();
+        }
+        logger_1.logger.info('Looking for go.mod files');
+        const paths = (await this.github.findFilesByFilenameAndRef('go.mod', this.targetBranch))
+            .filter(path => !path.includes('internal') && path !== 'go.mod')
+            .map(path => path_1.dirname(path));
+        logger_1.logger.info(`Found ${paths.length} submodules`);
+        logger_1.logger.debug(JSON.stringify(paths));
+        return new Set(paths);
+    }
     // "closes" is a little presumptuous, let's just indicate that the
     // PR references these other commits:
     async buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease) {

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

@@ -1,7 +1,7 @@
 import { Update } from '../update';
 import { Version, VersionsMap } from '../version';
 import { BaseStrategy, BuildUpdatesOptions, BaseStrategyOptions } from './base';
-import { GitHubFileContents } from '../github';
+import { GitHubFileContents } from '../util/file-cache';
 import { Commit, ConventionalCommit } from '../commit';
 import { Release } from '../release';
 import { ReleasePullRequest } from '../release-pull-request';

package/build/src/update.d.ts

@@ -1,4 +1,4 @@
-import { GitHubFileContents } from './github';
+import { GitHubFileContents } from './util/file-cache';
 /**
  * An update is a collection of data that represents changes to
  * a file in a repository.

package/build/src/util/file-cache.d.ts

@@ -0,0 +1,104 @@
+import { Octokit } from '@octokit/rest';
+import { Repository } from '../repository';
+export declare const DEFAULT_FILE_MODE = "100644";
+export interface GitHubFileContents {
+    sha: string;
+    content: string;
+    parsedContent: string;
+    mode: string;
+}
+/**
+ * This class is a read-through cache aimed at minimizing the
+ * number of API requests needed to fetch file data/contents.
+ * It lazy-caches data as it reads and will return cached data
+ * for resources already fetched.
+ */
+export declare class RepositoryFileCache {
+    private octokit;
+    private repository;
+    private cache;
+    /**
+     * Instantiate a new loading cache instance
+     *
+     * @param {Octokit} octokit An authenticated octokit instance
+     * @param {Repository} repository The repository we are fetching data for
+     */
+    constructor(octokit: Octokit, repository: Repository);
+    /**
+     * Fetch file contents for given path on a given branch. If the
+     * data has already been fetched, return a cached copy.
+     *
+     * @param {string} path Path to the file
+     * @param {string} branch Branch to fetch the file from
+     * @returns {GitHubFileContents} The file contents
+     */
+    getFileContents(path: string, branch: string): Promise<GitHubFileContents>;
+}
+/**
+ * This class is a read-through cache for a single branch aimed
+ * at minimizing the number of API requests needed to fetch file
+ * data/contents. It lazy-caches data as it reads and will return
+ * cached data for resources already fetched.
+ */
+export declare class BranchFileCache {
+    private octokit;
+    private repository;
+    private branch;
+    private cache;
+    private treeCache;
+    private treeEntries?;
+    /**
+     * Instantiate a new loading cache instance
+     *
+     * @param {Octokit} octokit An authenticated octokit instance
+     * @param {Repository} repository The repository we are fetching data for
+     * @param {string} branch The branch we are fetching data from
+     */
+    constructor(octokit: Octokit, repository: Repository, branch: string);
+    /**
+     * Fetch file contents for given path. If the data has already been
+     * fetched, return the cached copy.
+     *
+     * @param {string} path Path to the file
+     * @param {string} branch Branch to fetch the file from
+     * @returns {GitHubFileContents} The file contents
+     */
+    getFileContents(path: string): Promise<GitHubFileContents>;
+    /**
+     * Actually fetch the file contents. Uses the tree API to fetch file
+     * data.
+     *
+     * @param {string} path Path to the file
+     */
+    private fetchFileContents;
+    /**
+     * Return the full recursive git tree. If already fetched, return
+     * the cached version. If the tree is too big, return null.
+     *
+     * @returns {TreeEntry[]} The tree entries
+     */
+    private getFullTree;
+    /**
+     * Returns the git tree for a given SHA. If already fetched, return
+     * the cached version.
+     *
+     * @param {string} sha The tree SHA
+     * @returns {TreeEntry[]} The tree entries
+     */
+    private getTree;
+    /**
+     * Fetch the git tree via the GitHub API
+     *
+     * @param {string} sha The tree SHA
+     * @returns {TreeEntry[]} The tree entries
+     */
+    private fetchTree;
+    /**
+     * Fetch the git blob from the GitHub API and convert into a
+     * GitHubFileContents object.
+     *
+     * @param {string} blobSha The git blob SHA
+     * @param {TreeEntry} treeEntry The associated tree object
+     */
+    private fetchContents;
+}

package/build/src/util/file-cache.js

@@ -0,0 +1,206 @@
+"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.BranchFileCache = exports.RepositoryFileCache = exports.DEFAULT_FILE_MODE = void 0;
+const logger_1 = require("./logger");
+const errors_1 = require("../errors");
+exports.DEFAULT_FILE_MODE = '100644';
+/**
+ * This class is a read-through cache aimed at minimizing the
+ * number of API requests needed to fetch file data/contents.
+ * It lazy-caches data as it reads and will return cached data
+ * for resources already fetched.
+ */
+class RepositoryFileCache {
+    /**
+     * Instantiate a new loading cache instance
+     *
+     * @param {Octokit} octokit An authenticated octokit instance
+     * @param {Repository} repository The repository we are fetching data for
+     */
+    constructor(octokit, repository) {
+        this.octokit = octokit;
+        this.repository = repository;
+        this.cache = new Map();
+    }
+    /**
+     * Fetch file contents for given path on a given branch. If the
+     * data has already been fetched, return a cached copy.
+     *
+     * @param {string} path Path to the file
+     * @param {string} branch Branch to fetch the file from
+     * @returns {GitHubFileContents} The file contents
+     */
+    async getFileContents(path, branch) {
+        let fileCache = this.cache.get(branch);
+        if (!fileCache) {
+            fileCache = new BranchFileCache(this.octokit, this.repository, branch);
+            this.cache.set(branch, fileCache);
+        }
+        return await fileCache.getFileContents(path);
+    }
+}
+exports.RepositoryFileCache = RepositoryFileCache;
+/**
+ * This class is a read-through cache for a single branch aimed
+ * at minimizing the number of API requests needed to fetch file
+ * data/contents. It lazy-caches data as it reads and will return
+ * cached data for resources already fetched.
+ */
+class BranchFileCache {
+    /**
+     * Instantiate a new loading cache instance
+     *
+     * @param {Octokit} octokit An authenticated octokit instance
+     * @param {Repository} repository The repository we are fetching data for
+     * @param {string} branch The branch we are fetching data from
+     */
+    constructor(octokit, repository, branch) {
+        this.octokit = octokit;
+        this.repository = repository;
+        this.branch = branch;
+        this.cache = new Map();
+        this.treeCache = new Map();
+    }
+    /**
+     * Fetch file contents for given path. If the data has already been
+     * fetched, return the cached copy.
+     *
+     * @param {string} path Path to the file
+     * @param {string} branch Branch to fetch the file from
+     * @returns {GitHubFileContents} The file contents
+     */
+    async getFileContents(path) {
+        const cached = this.cache.get(path);
+        if (cached) {
+            return cached;
+        }
+        const fetched = await this.fetchFileContents(path);
+        this.cache.set(path, fetched);
+        return fetched;
+    }
+    /**
+     * Actually fetch the file contents. Uses the tree API to fetch file
+     * data.
+     *
+     * @param {string} path Path to the file
+     */
+    async fetchFileContents(path) {
+        // try to use the entire git tree if it's not too big
+        const treeEntries = await this.getFullTree();
+        if (treeEntries) {
+            logger_1.logger.debug(`Using full tree to find ${path}`);
+            const found = treeEntries.find(entry => entry.path === path);
+            if (found === null || found === void 0 ? void 0 : found.sha) {
+                return await this.fetchContents(found.sha, found);
+            }
+            throw new errors_1.FileNotFoundError(path);
+        }
+        // full tree is too big, use data API to fetch
+        const parts = path.split('/');
+        let treeSha = this.branch;
+        let found;
+        for (const part of parts) {
+            const tree = await this.getTree(treeSha);
+            found = tree.find(item => item.path === part);
+            if (!(found === null || found === void 0 ? void 0 : found.sha)) {
+                throw new errors_1.FileNotFoundError(path);
+            }
+            treeSha = found.sha;
+        }
+        if (found === null || found === void 0 ? void 0 : found.sha) {
+            return await this.fetchContents(found.sha, found);
+        }
+        throw new errors_1.FileNotFoundError(path);
+    }
+    /**
+     * Return the full recursive git tree. If already fetched, return
+     * the cached version. If the tree is too big, return null.
+     *
+     * @returns {TreeEntry[]} The tree entries
+     */
+    async getFullTree() {
+        if (this.treeEntries === undefined) {
+            // fetch all tree entries recursively
+            const { data: { tree, truncated }, } = await this.octokit.git.getTree({
+                owner: this.repository.owner,
+                repo: this.repository.repo,
+                tree_sha: this.branch,
+                recursive: 'true',
+            });
+            if (truncated) {
+                // the full tree is too big to use, mark it as unusable
+                this.treeEntries = null;
+            }
+            else {
+                this.treeEntries = tree;
+            }
+        }
+        return this.treeEntries;
+    }
+    /**
+     * Returns the git tree for a given SHA. If already fetched, return
+     * the cached version.
+     *
+     * @param {string} sha The tree SHA
+     * @returns {TreeEntry[]} The tree entries
+     */
+    async getTree(sha) {
+        const cached = this.treeCache.get(sha);
+        if (cached) {
+            return cached;
+        }
+        const fetched = await this.fetchTree(sha);
+        this.treeCache.set(sha, fetched);
+        return fetched;
+    }
+    /**
+     * Fetch the git tree via the GitHub API
+     *
+     * @param {string} sha The tree SHA
+     * @returns {TreeEntry[]} The tree entries
+     */
+    async fetchTree(sha) {
+        const { data: { tree }, } = await this.octokit.git.getTree({
+            owner: this.repository.owner,
+            repo: this.repository.repo,
+            tree_sha: sha,
+            recursive: 'false',
+        });
+        return tree;
+    }
+    /**
+     * Fetch the git blob from the GitHub API and convert into a
+     * GitHubFileContents object.
+     *
+     * @param {string} blobSha The git blob SHA
+     * @param {TreeEntry} treeEntry The associated tree object
+     */
+    async fetchContents(blobSha, treeEntry) {
+        const { data: { content }, } = await this.octokit.git.getBlob({
+            owner: this.repository.owner,
+            repo: this.repository.repo,
+            file_sha: blobSha,
+        });
+        return {
+            sha: blobSha,
+            mode: treeEntry.mode || exports.DEFAULT_FILE_MODE,
+            content,
+            parsedContent: Buffer.from(content, 'base64').toString('utf8'),
+        };
+    }
+}
+exports.BranchFileCache = BranchFileCache;
+//# sourceMappingURL=file-cache.js.map

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

@@ -52,7 +52,7 @@ class PullRequestBody {
             return this.releaseData
                 .map(release => {
                 var _a;
-                return `<details><summary>${release.component}: ${(_a = release.version) === null || _a === void 0 ? void 0 : _a.toString()}</summary>\n\n${release.notes}\n</details>`;
+                return `<details><summary>${release.component ? `${release.component}: ` : ''}${(_a = release.version) === null || _a === void 0 ? void 0 : _a.toString()}</summary>\n\n${release.notes}\n</details>`;
             })
                 .join('\n\n');
         }
@@ -91,6 +91,7 @@ function splitBody(body) {
     };
 }
 const SUMMARY_PATTERN = /^(?<component>.*[^:]):? (?<version>\d+\.\d+\.\d+.*)$/;
+const COMPONENTLESS_SUMMARY_PATTERN = /^(?<version>\d+\.\d+\.\d+.*)$/;
 function extractMultipleReleases(notes) {
     const data = [];
     const root = node_html_parser_1.parse(notes);
@@ -98,17 +99,28 @@ function extractMultipleReleases(notes) {
         const summaryNode = detail.getElementsByTagName('summary')[0];
         const summary = summaryNode === null || summaryNode === void 0 ? void 0 : summaryNode.textContent;
         const match = summary.match(SUMMARY_PATTERN);
-        if (!(match === null || match === void 0 ? void 0 : match.groups)) {
-            logger_1.logger.warn(`Summary: ${summary} did not match the expected pattern`);
-            continue;
+        if (match === null || match === void 0 ? void 0 : match.groups) {
+            detail.removeChild(summaryNode);
+            const notes = detail.textContent.trim();
+            data.push({
+                component: match.groups.component,
+                version: version_1.Version.parse(match.groups.version),
+                notes,
+            });
+        }
+        else {
+            const componentlessMatch = summary.match(COMPONENTLESS_SUMMARY_PATTERN);
+            if (!(componentlessMatch === null || componentlessMatch === void 0 ? void 0 : componentlessMatch.groups)) {
+                logger_1.logger.warn(`Summary: ${summary} did not match the expected pattern`);
+                continue;
+            }
+            detail.removeChild(summaryNode);
+            const notes = detail.textContent.trim();
+            data.push({
+                version: version_1.Version.parse(componentlessMatch.groups.version),
+                notes,
+            });
         }
-        detail.removeChild(summaryNode);
-        const notes = detail.textContent.trim();
-        data.push({
-            component: match.groups.component,
-            version: version_1.Version.parse(match.groups.version),
-            notes,
-        });
     }
     return data;
 }

package/package.json

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