release-please 12.3.0 → 13.0.0-candidate.0

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

@@ -0,0 +1,102 @@
+import { ManifestPlugin } from '../plugin';
+import { CandidateReleasePullRequest, RepositoryConfig } from '../manifest';
+import { VersionsMap, Version } from '../version';
+import { GitHub } from '../github';
+export declare type DependencyGraph<T> = Map<string, DependencyNode<T>>;
+export interface DependencyNode<T> {
+    deps: string[];
+    value: T;
+}
+export interface WorkspacePluginOptions {
+    updateAllPackages?: boolean;
+}
+interface AllPackages<T> {
+    allPackages: T[];
+    candidatesByPackage: Record<string, CandidateReleasePullRequest>;
+}
+/**
+ * The plugin generalizes the logic for handling a workspace and
+ * will bump dependencies of managed packages if those dependencies
+ * are being updated.
+ *
+ * If multiple in-scope packages are being updated, it will merge them
+ * into a single package.
+ *
+ * This class is templatized with `T` which should be information about
+ * the package including the name and current version.
+ */
+export declare abstract class WorkspacePlugin<T> extends ManifestPlugin {
+    private updateAllPackages;
+    constructor(github: GitHub, targetBranch: string, repositoryConfig: RepositoryConfig, options?: WorkspacePluginOptions);
+    run(candidates: CandidateReleasePullRequest[]): Promise<CandidateReleasePullRequest[]>;
+    /**
+     * Given a package, return the new bumped version after updating
+     * the dependency.
+     * @param {T} pkg The package being updated
+     */
+    protected abstract bumpVersion(pkg: T): Version;
+    /**
+     * Update an existing candidate pull request to append new
+     * dependency updates into the versions and changelog.
+     * @param {CandidateReleasePullRequest} existingCandidate The existing
+     *   candidate pull request.
+     * @param {T} pkg The package being updated
+     * @param {VersionsMap} updatedVersions Map of package name => version to
+     *   update.
+     * @returns {CandidateReleasePullRequest} The updated pull request
+     */
+    protected abstract updateCandidate(existingCandidate: CandidateReleasePullRequest, pkg: T, updatedVersions: VersionsMap): CandidateReleasePullRequest;
+    /**
+     * Create a new candidate pull request to update dependencies and force
+     * a version bump.
+     * @param {T} pkg The package being updated
+     * @param {VersionsMap} updatedVersions Map of package name => version to
+     *   update.
+     * @returns {CandidateReleasePullRequest} A new pull request
+     */
+    protected abstract newCandidate(pkg: T, updatedVersions: VersionsMap): CandidateReleasePullRequest;
+    /**
+     * Collect all packages being managed in this workspace.
+     * @param {CanididateReleasePullRequest[]} candidates Existing candidate pull
+     *   requests
+     * @returns {AllPackages<T>} The list of packages and candidates grouped by package name
+     */
+    protected abstract buildAllPackages(candidates: CandidateReleasePullRequest[]): Promise<AllPackages<T>>;
+    /**
+     * Builds a graph of dependencies that have been touched
+     * @param {T[]} allPackages All the packages in the workspace
+     * @returns {DependencyGraph<T>} A map of package name to other workspace packages
+     *   it depends on.
+     */
+    protected abstract buildGraph(allPackages: T[]): Promise<DependencyGraph<T>>;
+    /**
+     * Filter to determine whether or not the candidate pull request is
+     * in scope of this workspace.
+     * @param {CandidateReleasePullRequest} candidate The candidate pull request
+     * @returns {boolean} Whether or not this candidate should be handled by this
+     *   workspace.
+     */
+    protected abstract inScope(candidate: CandidateReleasePullRequest): boolean;
+    /**
+     * Given a package, return the package name of the package.
+     * @param {T} pkg The package definition.
+     * @returns {string} The package name.
+     */
+    protected abstract packageNameFromPackage(pkg: T): string;
+    /**
+     * Helper to invert the graph from package => packages that it depends on
+     * to package => packages that depend on it.
+     * @param {DependencyGraph<T>} graph
+     * @returns {DependencyGraph<T>}
+     */
+    private invertGraph;
+    /**
+     * Determine all the packages which need to be updated and sort them.
+     * @param {DependencyGraph<T>} graph The graph of package => packages it depends on
+     * @param {string} packageNamesToUpdate Names of the packages which are already
+     *   being updated.
+     */
+    protected buildGraphOrder(graph: DependencyGraph<T>, packageNamesToUpdate: string[]): T[];
+    private visitPostOrder;
+}
+export {};

package/build/src/plugins/workspace.js

@@ -0,0 +1,170 @@
+"use strict";
+// Copyright 2021 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.WorkspacePlugin = void 0;
+const plugin_1 = require("../plugin");
+const logger_1 = require("../util/logger");
+const merge_1 = require("./merge");
+/**
+ * The plugin generalizes the logic for handling a workspace and
+ * will bump dependencies of managed packages if those dependencies
+ * are being updated.
+ *
+ * If multiple in-scope packages are being updated, it will merge them
+ * into a single package.
+ *
+ * This class is templatized with `T` which should be information about
+ * the package including the name and current version.
+ */
+class WorkspacePlugin extends plugin_1.ManifestPlugin {
+    constructor(github, targetBranch, repositoryConfig, options = {}) {
+        var _a;
+        super(github, targetBranch, repositoryConfig);
+        this.updateAllPackages = (_a = options.updateAllPackages) !== null && _a !== void 0 ? _a : false;
+    }
+    async run(candidates) {
+        logger_1.logger.info('Running workspace plugin');
+        const [inScopeCandidates, outOfScopeCandidates] = candidates.reduce((collection, candidate) => {
+            if (!candidate.pullRequest.version) {
+                logger_1.logger.warn('pull request missing version', candidate);
+                return collection;
+            }
+            if (this.inScope(candidate)) {
+                collection[0].push(candidate);
+            }
+            else {
+                collection[1].push(candidate);
+            }
+            return collection;
+        }, [[], []]);
+        logger_1.logger.info(`Found ${inScopeCandidates.length} in-scope releases`);
+        if (inScopeCandidates.length === 0) {
+            return outOfScopeCandidates;
+        }
+        logger_1.logger.info('Building list of all packages');
+        const { allPackages, candidatesByPackage } = await this.buildAllPackages(inScopeCandidates);
+        logger_1.logger.info(`Building dependency graph for ${allPackages.length} packages`);
+        const graph = await this.buildGraph(allPackages);
+        const packageNamesToUpdate = this.updateAllPackages
+            ? allPackages.map(this.packageNameFromPackage)
+            : Object.keys(candidatesByPackage);
+        const orderedPackages = this.buildGraphOrder(graph, packageNamesToUpdate);
+        logger_1.logger.info(`Updating ${orderedPackages.length} packages`);
+        const updatedVersions = new Map();
+        for (const pkg of orderedPackages) {
+            const packageName = this.packageNameFromPackage(pkg);
+            logger_1.logger.debug(`package: ${packageName}`);
+            const existingCandidate = candidatesByPackage[packageName];
+            if (existingCandidate) {
+                const version = existingCandidate.pullRequest.version;
+                logger_1.logger.debug(`version: ${version} from release-please`);
+                updatedVersions.set(packageName, version);
+            }
+            else {
+                const version = this.bumpVersion(pkg);
+                logger_1.logger.debug(`version: ${version} forced bump`);
+                updatedVersions.set(packageName, version);
+            }
+        }
+        let newCandidates = [];
+        for (const pkg of orderedPackages) {
+            const packageName = this.packageNameFromPackage(pkg);
+            const existingCandidate = candidatesByPackage[packageName];
+            if (existingCandidate) {
+                // if already has an pull request, update the changelog and update
+                logger_1.logger.info(`Updating exising candidate pull request for ${this.packageNameFromPackage(pkg)}`);
+                const newCandidate = this.updateCandidate(existingCandidate, pkg, updatedVersions);
+                newCandidates.push(newCandidate);
+            }
+            else {
+                // otherwise, build a new pull request with changelog and entry update
+                logger_1.logger.info(`Creating new candidate pull request for ${this.packageNameFromPackage(pkg)}`);
+                const newCandidate = this.newCandidate(pkg, updatedVersions);
+                newCandidates.push(newCandidate);
+            }
+        }
+        logger_1.logger.info(`Merging ${newCandidates.length} in-scope candidates`);
+        const mergePlugin = new merge_1.Merge(this.github, this.targetBranch, this.repositoryConfig);
+        newCandidates = await mergePlugin.run(newCandidates);
+        return [...outOfScopeCandidates, ...newCandidates];
+    }
+    /**
+     * Helper to invert the graph from package => packages that it depends on
+     * to package => packages that depend on it.
+     * @param {DependencyGraph<T>} graph
+     * @returns {DependencyGraph<T>}
+     */
+    invertGraph(graph) {
+        const dependentGraph = new Map();
+        for (const [packageName, node] of graph) {
+            dependentGraph.set(packageName, {
+                deps: [],
+                value: node.value,
+            });
+        }
+        for (const [packageName, node] of graph) {
+            for (const depName of node.deps) {
+                if (dependentGraph.has(depName)) {
+                    dependentGraph.get(depName).deps.push(packageName);
+                }
+            }
+        }
+        return dependentGraph;
+    }
+    /**
+     * Determine all the packages which need to be updated and sort them.
+     * @param {DependencyGraph<T>} graph The graph of package => packages it depends on
+     * @param {string} packageNamesToUpdate Names of the packages which are already
+     *   being updated.
+     */
+    buildGraphOrder(graph, packageNamesToUpdate) {
+        // invert the graph so it's dependency name => packages that depend on it
+        const dependentGraph = this.invertGraph(graph);
+        const visited = new Set();
+        // we're iterating the `Map` in insertion order (as per ECMA262), but
+        // that does not reflect any particular traversal of the graph, so we
+        // visit all nodes, opportunistically short-circuiting leafs when we've
+        // already visited them.
+        for (const name of packageNamesToUpdate) {
+            this.visitPostOrder(dependentGraph, name, visited, []);
+        }
+        return Array.from(visited).sort((a, b) => this.packageNameFromPackage(a).localeCompare(this.packageNameFromPackage(b)));
+    }
+    visitPostOrder(graph, name, visited, path) {
+        if (path.indexOf(name) !== -1) {
+            throw new Error(`found cycle in dependency graph: ${path.join(' -> ')} -> ${name}`);
+        }
+        const node = graph.get(name);
+        if (!node) {
+            logger_1.logger.warn(`Didn't find node: ${name} in graph`);
+            return;
+        }
+        const nextPath = [...path, name];
+        for (const depName of node.deps) {
+            const dep = graph.get(depName);
+            if (!dep) {
+                logger_1.logger.warn(`dependency not found in graph: ${depName}`);
+                return;
+            }
+            this.visitPostOrder(graph, depName, visited, nextPath);
+        }
+        if (!visited.has(node.value)) {
+            logger_1.logger.debug(`marking ${name} as visited and adding ${this.packageNameFromPackage(node.value)} to order`);
+            visited.add(node.value);
+        }
+    }
+}
+exports.WorkspacePlugin = WorkspacePlugin;
+//# sourceMappingURL=workspace.js.map

package/build/src/pull-request.d.ts

@@ -0,0 +1,10 @@
+export interface PullRequest {
+    headBranchName: string;
+    baseBranchName: string;
+    number: number;
+    title: string;
+    body: string;
+    labels: string[];
+    files: string[];
+    sha?: string;
+}

package/build/src/{updaters/java/readme.js → pull-request.js}

@@ -1,5 +1,5 @@
 "use strict";
-// Copyright 2019 Google LLC
+// Copyright 2021 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -13,9 +13,4 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Readme = void 0;
-const java_update_1 = require("./java_update");
-class Readme extends java_update_1.JavaUpdate {
-}
-exports.Readme = Readme;
-//# sourceMappingURL=readme.js.map
+//# sourceMappingURL=pull-request.js.map

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

@@ -0,0 +1,29 @@
+import { ConventionalCommit } from './commit';
+export interface ChangelogSection {
+    type: string;
+    section: string;
+    hidden?: boolean;
+}
+interface ReleaseNotesOptions {
+    changelogSections?: ChangelogSection[];
+    commitPartial?: string;
+    headerPartial?: string;
+    mainTemplate?: string;
+}
+interface BuildNotesOptions {
+    host?: string;
+    owner: string;
+    repository: string;
+    version: string;
+    previousTag?: string;
+    currentTag: string;
+}
+export declare class ReleaseNotes {
+    private changelogSections?;
+    private commitPartial?;
+    private headerPartial?;
+    private mainTemplate?;
+    constructor(options?: ReleaseNotesOptions);
+    buildNotes(commits: ConventionalCommit[], options: BuildNotesOptions): Promise<string>;
+}
+export {};

package/build/src/release-notes.js

@@ -0,0 +1,71 @@
+"use strict";
+// Copyright 2021 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.ReleaseNotes = void 0;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const conventionalChangelogWriter = require('conventional-changelog-writer');
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const presetFactory = require('conventional-changelog-conventionalcommits');
+class ReleaseNotes {
+    constructor(options = {}) {
+        this.changelogSections = options.changelogSections;
+        this.commitPartial = options.commitPartial;
+        this.headerPartial = options.headerPartial;
+        this.mainTemplate = options.mainTemplate;
+    }
+    async buildNotes(commits, options) {
+        const context = {
+            host: options.host || 'https://github.com',
+            owner: options.owner,
+            repository: options.repository,
+            version: options.version,
+            previousTag: options.previousTag,
+            currentTag: options.currentTag,
+            linkCompare: !!options.previousTag,
+        };
+        const config = {};
+        if (this.changelogSections) {
+            config.types = this.changelogSections;
+        }
+        const preset = await presetFactory(config);
+        preset.writerOpts.commitPartial =
+            this.commitPartial || preset.writerOpts.commitPartial;
+        preset.writerOpts.headerPartial =
+            this.headerPartial || preset.writerOpts.headerPartial;
+        preset.writerOpts.mainTemplate =
+            this.mainTemplate || preset.writerOpts.mainTemplate;
+        const changelogCommits = commits.map(commit => {
+            return {
+                body: '',
+                subject: commit.bareMessage,
+                type: commit.type,
+                scope: commit.scope,
+                notes: commit.notes,
+                references: commit.references,
+                mentions: [],
+                merge: null,
+                revert: null,
+                header: commit.message,
+                footer: null,
+                hash: commit.sha,
+            };
+        });
+        return conventionalChangelogWriter
+            .parseArray(changelogCommits, context, preset.writerOpts)
+            .trim();
+    }
+}
+exports.ReleaseNotes = ReleaseNotes;
+//# sourceMappingURL=release-notes.js.map

package/build/src/release-pull-request.d.ts

@@ -0,0 +1,13 @@
+import { Update } from './update';
+import { Version } from './version';
+import { PullRequestBody } from './util/pull-request-body';
+import { PullRequestTitle } from './util/pull-request-title';
+export interface ReleasePullRequest {
+    title: PullRequestTitle;
+    body: PullRequestBody;
+    updates: Update[];
+    labels: string[];
+    headRefName: string;
+    version?: Version;
+    draft: boolean;
+}

package/build/src/{updaters/java/pom-xml.js → release-pull-request.js}

@@ -1,5 +1,5 @@
 "use strict";
-// Copyright 2019 Google LLC
+// Copyright 2021 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -13,9 +13,4 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PomXML = void 0;
-const java_update_1 = require("./java_update");
-class PomXML extends java_update_1.JavaUpdate {
-}
-exports.PomXML = PomXML;
-//# sourceMappingURL=pom-xml.js.map
+//# sourceMappingURL=release-pull-request.js.map

package/build/src/release.d.ts

@@ -0,0 +1,6 @@
+import { TagName } from './util/tag-name';
+export interface Release {
+    readonly tag: TagName;
+    readonly sha: string;
+    readonly notes: string;
+}

package/build/src/release.js

@@ -0,0 +1,16 @@
+"use strict";
+// Copyright 2021 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 });
+//# sourceMappingURL=release.js.map

package/build/src/repository.d.ts

@@ -0,0 +1,5 @@
+export interface Repository {
+    readonly owner: string;
+    readonly repo: string;
+    readonly defaultBranch: string;
+}

package/build/src/repository.js

@@ -0,0 +1,16 @@
+"use strict";
+// Copyright 2021 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 });
+//# sourceMappingURL=repository.js.map

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

@@ -0,0 +1,8 @@
+import { Strategy, BuildUpdatesOptions } from '../strategy';
+import { Update } from '../update';
+export declare class Dart extends Strategy {
+    private pubspecYmlContents?;
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    getDefaultPackageName(): Promise<string | undefined>;
+    private getPubspecYmlContents;
+}

package/build/src/strategies/dart.js

@@ -0,0 +1,63 @@
+"use strict";
+// Copyright 2021 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.Dart = void 0;
+// Generic
+const changelog_1 = require("../updaters/changelog");
+const yaml = require("js-yaml");
+// pubspec
+const pubspec_yaml_1 = require("../updaters/dart/pubspec-yaml");
+const strategy_1 = require("../strategy");
+class Dart extends strategy_1.Strategy {
+    async buildUpdates(options) {
+        const updates = [];
+        const version = options.newVersion;
+        updates.push({
+            path: this.addPath(this.changelogPath),
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        updates.push({
+            path: this.addPath('pubspec.yaml'),
+            createIfMissing: false,
+            cachedFileContents: this.pubspecYmlContents,
+            updater: new pubspec_yaml_1.PubspecYaml({
+                version,
+            }),
+        });
+        return updates;
+    }
+    async getDefaultPackageName() {
+        const pubspecYmlContents = await this.getPubspecYmlContents();
+        const pubspec = yaml.load(pubspecYmlContents.parsedContent, { json: true });
+        if (typeof pubspec === 'object') {
+            return pubspec.name;
+        }
+        else {
+            return undefined;
+        }
+    }
+    async getPubspecYmlContents() {
+        if (!this.pubspecYmlContents) {
+            this.pubspecYmlContents = await this.github.getFileContentsOnBranch(this.addPath('pubspec.yaml'), this.targetBranch);
+        }
+        return this.pubspecYmlContents;
+    }
+}
+exports.Dart = Dart;
+//# sourceMappingURL=dart.js.map

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

@@ -0,0 +1,5 @@
+import { Strategy, BuildUpdatesOptions } from '../strategy';
+import { Update } from '../update';
+export declare class Elixir extends Strategy {
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+}

package/build/src/{releasers → strategies}/elixir.js

@@ -14,26 +14,30 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Elixir = void 0;
-const release_pr_1 = require("../release-pr");
 // Generic
 const changelog_1 = require("../updaters/changelog");
 // mix.exs support
-const elixir_mix_exs_1 = require("../updaters/elixir-mix-exs");
-class Elixir extends release_pr_1.ReleasePR {
-    async buildUpdates(changelogEntry, candidate, packageName) {
+const elixir_mix_exs_1 = require("../updaters/elixir/elixir-mix-exs");
+const strategy_1 = require("../strategy");
+class Elixir extends strategy_1.Strategy {
+    async buildUpdates(options) {
         const updates = [];
-        updates.push(new changelog_1.Changelog({
+        const version = options.newVersion;
+        updates.push({
             path: this.addPath(this.changelogPath),
-            changelogEntry,
-            version: candidate.version,
-            packageName: packageName.name,
-        }));
-        updates.push(new elixir_mix_exs_1.ElixirMixExs({
+            createIfMissing: true,
+            updater: new changelog_1.Changelog({
+                version,
+                changelogEntry: options.changelogEntry,
+            }),
+        });
+        updates.push({
             path: this.addPath('mix.exs'),
-            changelogEntry,
-            version: candidate.version,
-            packageName: packageName.name,
-        }));
+            createIfMissing: false,
+            updater: new elixir_mix_exs_1.ElixirMixExs({
+                version,
+            }),
+        });
         return updates;
     }
 }

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

@@ -0,0 +1,13 @@
+import { Strategy, BuildUpdatesOptions, StrategyOptions } from '../strategy';
+import { Update } from '../update';
+import { ConventionalCommit } from '../commit';
+import { Version } from '../version';
+import { TagName } from '../util/tag-name';
+import { Release } from '../release';
+export declare class GoYoshi extends Strategy {
+    constructor(options: StrategyOptions);
+    protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
+    protected postProcessCommits(commits: ConventionalCommit[]): ConventionalCommit[];
+    protected buildReleaseNotes(conventionalCommits: ConventionalCommit[], newVersion: Version, newVersionTag: TagName, latestRelease?: Release): Promise<string>;
+    protected initialReleaseVersion(): Version;
+}