release-please 12.3.0 → 13.0.0-candidate.0

package/build/src/bootstrapper.js

@@ -0,0 +1,60 @@
+"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.Bootstrapper = void 0;
+const manifest_1 = require("./manifest");
+const version_1 = require("./version");
+const release_please_manifest_1 = require("./updaters/release-please-manifest");
+const release_please_config_1 = require("./updaters/release-please-config");
+class Bootstrapper {
+    constructor(github, targetBranch, manifestFile = manifest_1.DEFAULT_RELEASE_PLEASE_MANIFEST, configFile = manifest_1.DEFAULT_RELEASE_PLEASE_CONFIG, initialVersionString = '0.0.0') {
+        this.github = github;
+        this.targetBranch = targetBranch;
+        this.manifestFile = manifestFile;
+        this.configFile = configFile;
+        this.initialVersion = version_1.Version.parse(initialVersionString);
+    }
+    async bootstrap(path, config) {
+        const message = `chore: bootstrap releases for path: ${path}`;
+        const branchName = path === manifest_1.ROOT_PROJECT_PATH ? 'default' : path;
+        const pullRequest = {
+            headBranchName: `release-please/bootstrap/${branchName}`,
+            baseBranchName: this.targetBranch,
+            number: -1,
+            title: message,
+            body: `Configuring release-please for path: ${path}`,
+            labels: [],
+            files: [],
+        };
+        const version = this.initialVersion;
+        const versionsMap = new Map();
+        versionsMap.set(path, version);
+        const updates = [
+            {
+                path: this.manifestFile,
+                createIfMissing: true,
+                updater: new release_please_manifest_1.ReleasePleaseManifest({ version, versionsMap }),
+            },
+            {
+                path: this.configFile,
+                createIfMissing: true,
+                updater: new release_please_config_1.ReleasePleaseConfig(path, config),
+            },
+        ];
+        return await this.github.createPullRequest(pullRequest, this.targetBranch, message, updates, {});
+    }
+}
+exports.Bootstrapper = Bootstrapper;
+//# sourceMappingURL=bootstrapper.js.map

package/build/src/commit.d.ts

@@ -0,0 +1,26 @@
+import { PullRequest } from './pull-request';
+import * as parser from '@conventional-commits/parser';
+export interface Commit {
+    sha: string;
+    message: string;
+    files: string[];
+    pullRequest?: PullRequest;
+}
+export interface ConventionalCommit extends Commit {
+    type: string;
+    scope: string | null;
+    notes: parser.Note[];
+    references: parser.Reference[];
+    bareMessage: string;
+    breaking: boolean;
+}
+/**
+ * Given a list of raw commits, parse and expand into conventional commits.
+ *
+ * @param commits {Commit[]} The input commits
+ *
+ * @returns {ConventionalCommit[]} Parsed and expanded commits. There may be
+ *   more commits returned as a single raw commit may contain multiple release
+ *   messages.
+ */
+export declare function parseConventionalCommits(commits: Commit[]): ConventionalCommit[];

package/build/src/{util/to-conventional-changelog-format.js → commit.js}

@@ -13,12 +13,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseConventionalCommits = void 0;
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const visit = require('unist-util-visit');
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const visitWithAncestors = require('unist-util-visit-parents');
 const NUMBER_REGEX = /^[0-9]+$/;
+const logger_1 = require("./util/logger");
 const parser = require("@conventional-commits/parser");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const conventionalCommitsFilter = require('conventional-commits-filter');
 function getBlankConventionalCommit() {
     return {
         body: '',
@@ -200,6 +204,15 @@ function toConventionalChangelogFormat(ast) {
             // Any footers that carry semantic meaning, e.g., Release-As, should
             // be added to the footer field, for the benefits of post-processing:
             if (semanticFooter) {
+                let releaseAs = '';
+                visit(parent, ['text'], (node) => {
+                    releaseAs = node.value;
+                });
+                // record Release-As footer as a note
+                headerCommit.notes.push({
+                    title: 'RELEASE AS',
+                    text: releaseAs,
+                });
                 if (!headerCommit.footer)
                     headerCommit.footer = '';
                 headerCommit.footer += `\n${footerText.toLowerCase()}`.trimStart();
@@ -217,5 +230,87 @@ function toConventionalChangelogFormat(ast) {
     commits.push(headerCommit);
     return commits;
 }
-exports.default = toConventionalChangelogFormat;
-//# sourceMappingURL=to-conventional-changelog-format.js.map
+// TODO(@bcoe): now that we walk the actual AST of conventional commits
+// we should be able to move post processing into
+// to-conventional-changelog.ts.
+function postProcessCommits(commit) {
+    commit.notes.forEach(note => {
+        let text = '';
+        let i = 0;
+        let extendedContext = false;
+        for (const chunk of note.text.split(/\r?\n/)) {
+            if (i > 0 && hasExtendedContext(chunk) && !extendedContext) {
+                text = `${text.trim()}\n`;
+                extendedContext = true;
+            }
+            if (chunk === '')
+                break;
+            else if (extendedContext) {
+                text += `    ${chunk}\n`;
+            }
+            else {
+                text += `${chunk} `;
+            }
+            i++;
+        }
+        note.text = text.trim();
+    });
+    return commit;
+}
+// If someone wishes to include additional contextual information for a
+// BREAKING CHANGE using markdown, they can do so by starting the line after the initial
+// breaking change description with either:
+//
+// 1. a fourth-level header.
+// 2. a bulleted list (using either '*' or '-').
+//
+// BREAKING CHANGE: there were breaking changes
+// #### Deleted Endpoints
+// - endpoint 1
+// - endpoint 2
+function hasExtendedContext(line) {
+    if (line.match(/^#### |^[*-] /))
+        return true;
+    return false;
+}
+function parseCommits(message) {
+    return conventionalCommitsFilter(toConventionalChangelogFormat(parser.parser(message))).map(postProcessCommits);
+}
+/**
+ * Given a list of raw commits, parse and expand into conventional commits.
+ *
+ * @param commits {Commit[]} The input commits
+ *
+ * @returns {ConventionalCommit[]} Parsed and expanded commits. There may be
+ *   more commits returned as a single raw commit may contain multiple release
+ *   messages.
+ */
+function parseConventionalCommits(commits) {
+    const conventionalCommits = [];
+    for (const commit of commits) {
+        try {
+            for (const parsedCommit of parseCommits(commit.message)) {
+                const breaking = parsedCommit.notes.filter(note => note.title === 'BREAKING CHANGE')
+                    .length > 0;
+                conventionalCommits.push({
+                    sha: commit.sha,
+                    message: parsedCommit.header,
+                    files: commit.files,
+                    pullRequest: commit.pullRequest,
+                    type: parsedCommit.type,
+                    scope: parsedCommit.scope,
+                    bareMessage: parsedCommit.subject,
+                    notes: parsedCommit.notes,
+                    references: parsedCommit.references,
+                    breaking,
+                });
+            }
+        }
+        catch (_err) {
+            logger_1.logger.debug(`commit could not be parsed: ${commit.sha} ${commit.message.split('\n')[0]}`);
+        }
+    }
+    return conventionalCommits;
+}
+exports.parseConventionalCommits = parseConventionalCommits;
+//# sourceMappingURL=commit.js.map

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

@@ -29,9 +29,4 @@ export declare class DuplicateReleaseError extends GitHubAPIError {
     tag: string;
     constructor(requestError: RequestError, tag: string);
 }
-export declare class MissingReleaseNotesError extends Error {
-    changelogContents: string;
-    version: string;
-    constructor(changelogContents: string, version: 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.MissingReleaseNotesError = exports.DuplicateReleaseError = exports.AuthError = exports.GitHubAPIError = exports.MissingRequiredFileError = exports.ConfigurationError = void 0;
+exports.DuplicateReleaseError = exports.AuthError = exports.GitHubAPIError = exports.MissingRequiredFileError = exports.ConfigurationError = void 0;
 class ConfigurationError extends Error {
     constructor(message, releaserName, repository) {
         super(`${releaserName} (${repository}): ${message}`);
@@ -65,13 +65,4 @@ class DuplicateReleaseError extends GitHubAPIError {
     }
 }
 exports.DuplicateReleaseError = DuplicateReleaseError;
-class MissingReleaseNotesError extends Error {
-    constructor(changelogContents, version) {
-        super(`could not find changelog entry corresponding to release ${version}`);
-        this.changelogContents = changelogContents;
-        this.version = version;
-        this.name = MissingReleaseNotesError.name;
-    }
-}
-exports.MissingReleaseNotesError = MissingReleaseNotesError;
 //# sourceMappingURL=index.js.map

package/build/src/factory.d.ts

@@ -1,38 +1,26 @@
-import { ReleasePR } from './release-pr';
-import { GitHubRelease, GitHubReleaseResponse } from './github-release';
-import { ReleaseType } from './releasers';
-import { GitHub, GitHubTag } from './github';
-import { ManifestFactoryOptions, ReleasePRFactoryOptions, GitHubReleaseFactoryOptions, GitHubFactoryOptions } from '.';
-import { ManifestGitHubReleaseResult, Manifest } from './manifest';
-export declare type ManifestMethod = 'pullRequest' | 'githubRelease';
-export declare type ReleasePRMethod = 'run' | 'latestTag';
-export declare type GitHubReleaseMethod = 'run';
-export declare type Method = ManifestMethod | ReleasePRMethod | GitHubReleaseMethod;
-export declare type ManifestCommand = 'manifest-pr' | 'manifest-release';
-export declare type ReleasePRCommand = 'release-pr' | 'latest-tag';
-export declare type GitHubReleaseCommand = 'github-release';
-export declare type ManifestCallResult = Promise<number | undefined | ManifestGitHubReleaseResult>;
-export declare type ReleasePRCallResult = Promise<number | GitHubTag | undefined>;
-export declare type GitHubReleaseCallResult = Promise<GitHubReleaseResponse | undefined>;
-export declare type CallResult = ManifestCallResult | ReleasePRCallResult | GitHubReleaseCallResult;
-declare function runCommand(command: ManifestCommand, options: ManifestFactoryOptions): ManifestCallResult;
-declare function runCommand(command: ReleasePRCommand, options: ReleasePRFactoryOptions): ReleasePRCallResult;
-declare function runCommand(command: GitHubReleaseCommand, options: GitHubReleaseFactoryOptions): GitHubReleaseCallResult;
-declare function call(instance: Manifest, method: ManifestMethod): ManifestCallResult;
-declare function call(instance: ReleasePR, method: ReleasePRMethod): ReleasePRCallResult;
-declare function call(instance: GitHubRelease, method: GitHubReleaseMethod): GitHubReleaseCallResult;
-declare function manifest(options: ManifestFactoryOptions): Manifest;
-declare function githubRelease(options: GitHubReleaseFactoryOptions): GitHubRelease;
-declare function releasePR(options: ReleasePRFactoryOptions): ReleasePR;
-declare function gitHubInstance(options: GitHubFactoryOptions): GitHub;
-declare function releasePRClass(releaseType?: ReleaseType): typeof ReleasePR;
-export declare const factory: {
-    gitHubInstance: typeof gitHubInstance;
-    githubRelease: typeof githubRelease;
-    manifest: typeof manifest;
-    releasePR: typeof releasePR;
-    releasePRClass: typeof releasePRClass;
-    call: typeof call;
-    runCommand: typeof runCommand;
-};
+import { Strategy } from './strategy';
+import { GitHub } from './github';
+import { ReleaserConfig, PluginType, RepositoryConfig } from './manifest';
+import { ManifestPlugin } from './plugin';
+declare const allReleaseTypes: readonly ["dart", "elixir", "go", "go-yoshi", "helm", "java-backport", "java-bom", "java-lts", "java-yoshi", "krm-blueprint", "node", "ocaml", "php", "php-yoshi", "python", "ruby", "ruby-yoshi", "rust", "simple", "terraform-module"];
+export declare type ReleaseType = typeof allReleaseTypes[number];
+export declare function getReleaserTypes(): readonly ReleaseType[];
+export declare function getVersioningStrategyTypes(): readonly VersioningStrategyType[];
+export interface StrategyFactoryOptions extends ReleaserConfig {
+    github: GitHub;
+    path?: string;
+    targetBranch?: string;
+}
+export declare function buildStrategy(options: StrategyFactoryOptions): Promise<Strategy>;
+declare const allVersioningTypes: readonly ["default", "always-bump-patch", "service-pack"];
+export declare type VersioningStrategyType = typeof allVersioningTypes[number];
+interface PluginFactoryOptions {
+    type: PluginType;
+    github: GitHub;
+    targetBranch: string;
+    repositoryConfig: RepositoryConfig;
+    alwaysLinkLocal?: boolean;
+    updateAllPackages?: boolean;
+}
+export declare function buildPlugin(options: PluginFactoryOptions): ManifestPlugin;
 export {};

package/build/src/factory.js

@@ -13,170 +13,179 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.factory = void 0;
+exports.buildPlugin = exports.buildStrategy = exports.getVersioningStrategyTypes = exports.getReleaserTypes = void 0;
+const go_1 = require("./strategies/go");
+const go_yoshi_1 = require("./strategies/go-yoshi");
+const java_yoshi_1 = require("./strategies/java-yoshi");
+const krm_blueprint_1 = require("./strategies/krm-blueprint");
+const ocaml_1 = require("./strategies/ocaml");
+const php_1 = require("./strategies/php");
+const php_yoshi_1 = require("./strategies/php-yoshi");
+const python_1 = require("./strategies/python");
+const ruby_1 = require("./strategies/ruby");
+const ruby_yoshi_1 = require("./strategies/ruby-yoshi");
+const rust_1 = require("./strategies/rust");
+const simple_1 = require("./strategies/simple");
+const terraform_module_1 = require("./strategies/terraform-module");
+const helm_1 = require("./strategies/helm");
+const elixir_1 = require("./strategies/elixir");
+const dart_1 = require("./strategies/dart");
+const node_1 = require("./strategies/node");
+const default_1 = require("./versioning-strategies/default");
+const always_bump_patch_1 = require("./versioning-strategies/always-bump-patch");
+const service_pack_1 = require("./versioning-strategies/service-pack");
+const dependency_manifest_1 = require("./versioning-strategies/dependency-manifest");
+const node_workspace_1 = require("./plugins/node-workspace");
+const cargo_workspace_1 = require("./plugins/cargo-workspace");
 // Factory shared by GitHub Action and CLI for creating Release PRs
 // and GitHub Releases:
-const release_pr_1 = require("./release-pr");
-const github_release_1 = require("./github-release");
-const releasers_1 = require("./releasers");
-const github_1 = require("./github");
-const constants_1 = require("./constants");
-const manifest_1 = require("./manifest");
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const parseGithubRepoUrl = require('parse-github-repo-url');
-function isManifestCmd(cmdOpts) {
-    const { command, options } = cmdOpts;
-    return ((command === 'manifest-pr' || command === 'manifest-release') &&
-        typeof options === 'object');
-}
-function isGitHubReleaseCmd(cmdOpts) {
-    const { command, options } = cmdOpts;
-    return command === 'github-release' && typeof options === 'object';
+// add any new releasers you create to this type as well as the `releasers`
+// object below.
+const allReleaseTypes = [
+    'dart',
+    'elixir',
+    'go',
+    'go-yoshi',
+    'helm',
+    'java-backport',
+    'java-bom',
+    'java-lts',
+    'java-yoshi',
+    'krm-blueprint',
+    'node',
+    'ocaml',
+    'php',
+    'php-yoshi',
+    'python',
+    'ruby',
+    'ruby-yoshi',
+    'rust',
+    'simple',
+    'terraform-module',
+];
+const releasers = {
+    go: options => new go_1.Go(options),
+    'go-yoshi': options => new go_yoshi_1.GoYoshi(options),
+    'krm-blueprint': options => new krm_blueprint_1.KRMBlueprint(options),
+    node: options => new node_1.Node(options),
+    ocaml: options => new ocaml_1.OCaml(options),
+    php: options => new php_1.PHP(options),
+    'php-yoshi': options => new php_yoshi_1.PHPYoshi(options),
+    python: options => new python_1.Python(options),
+    rust: options => new rust_1.Rust(options),
+    simple: options => new simple_1.Simple(options),
+    'terraform-module': options => new terraform_module_1.TerraformModule(options),
+    helm: options => new helm_1.Helm(options),
+    elixir: options => new elixir_1.Elixir(options),
+    dart: options => new dart_1.Dart(options),
+};
+function getReleaserTypes() {
+    return allReleaseTypes;
 }
-function isReleasePRCmd(cmdOpts) {
-    const { command, options } = cmdOpts;
-    return ((command === 'release-pr' || command === 'latest-tag') &&
-        typeof options === 'object');
+exports.getReleaserTypes = getReleaserTypes;
+function getVersioningStrategyTypes() {
+    return allVersioningTypes;
 }
-function runCommand(command, options) {
-    const errMsg = `Invalid command(${command}) with options(${JSON.stringify(options)})`;
-    let result;
-    const cmdOpts = { command, options };
-    if (isManifestCmd(cmdOpts)) {
-        const m = manifest(cmdOpts.options);
-        if (cmdOpts.command === 'manifest-pr') {
-            result = exports.factory.call(m, 'pullRequest');
+exports.getVersioningStrategyTypes = getVersioningStrategyTypes;
+async function buildStrategy(options) {
+    var _a;
+    const targetBranch = (_a = options.targetBranch) !== null && _a !== void 0 ? _a : options.github.repository.defaultBranch;
+    const versioningStrategy = buildVersioningStrategy({
+        type: options.versioning,
+        bumpMinorPreMajor: options.bumpMinorPreMajor,
+        bumpPatchForMinorPreMajor: options.bumpPatchForMinorPreMajor,
+    });
+    const strategyOptions = {
+        github: options.github,
+        targetBranch,
+        path: options.path,
+        bumpMinorPreMajor: options.bumpMinorPreMajor,
+        bumpPatchForMinorPreMajor: options.bumpPatchForMinorPreMajor,
+        component: options.component,
+        packageName: options.packageName,
+        changelogPath: options.changelogPath,
+        changelogSections: options.changelogSections,
+        versioningStrategy,
+        skipGitHubRelease: options.skipGithubRelease,
+        releaseAs: options.releaseAs,
+    };
+    switch (options.releaseType) {
+        case 'ruby': {
+            return new ruby_1.Ruby({
+                ...strategyOptions,
+                versionFile: options.versionFile,
+            });
         }
-        else if (cmdOpts.command === 'manifest-release') {
-            result = exports.factory.call(m, 'githubRelease');
+        case 'ruby-yoshi': {
+            return new ruby_yoshi_1.RubyYoshi({
+                ...strategyOptions,
+                versionFile: options.versionFile,
+            });
         }
-        else {
-            throw new Error(errMsg);
+        case 'java-yoshi': {
+            return new java_yoshi_1.JavaYoshi({
+                ...strategyOptions,
+                extraFiles: options.extraFiles,
+            });
         }
-    }
-    else if (isGitHubReleaseCmd(cmdOpts)) {
-        result = exports.factory.call(githubRelease(cmdOpts.options), 'run');
-    }
-    else if (isReleasePRCmd(cmdOpts)) {
-        const releasePr = releasePR(cmdOpts.options);
-        if (cmdOpts.command === 'release-pr') {
-            result = exports.factory.call(releasePr, 'run');
+        case 'java-backport': {
+            return new java_yoshi_1.JavaYoshi({
+                ...strategyOptions,
+                extraFiles: options.extraFiles,
+                versioningStrategy: new always_bump_patch_1.AlwaysBumpPatch(),
+            });
         }
-        else if (cmdOpts.command === 'latest-tag') {
-            result = exports.factory.call(releasePr, 'latestTag');
+        case 'java-bom': {
+            return new java_yoshi_1.JavaYoshi({
+                ...strategyOptions,
+                extraFiles: options.extraFiles,
+                versioningStrategy: new dependency_manifest_1.DependencyManifest({
+                    bumpMinorPreMajor: options.bumpMinorPreMajor,
+                    bumpPatchForMinorPreMajor: options.bumpPatchForMinorPreMajor,
+                }),
+            });
         }
-        else {
-            throw new Error(errMsg);
+        case 'java-lts': {
+            return new java_yoshi_1.JavaYoshi({
+                ...strategyOptions,
+                extraFiles: options.extraFiles,
+                versioningStrategy: new service_pack_1.ServicePackVersioningStrategy(),
+            });
+        }
+        default: {
+            const builder = releasers[options.releaseType];
+            if (builder) {
+                return builder(strategyOptions);
+            }
+            throw new Error(`Unknown release type: ${options.releaseType}`);
         }
     }
-    else {
-        throw new Error(errMsg);
-    }
-    return result;
 }
-function call(instance, method) {
-    if (!(method in instance)) {
-        throw new Error(`No such method(${method}) on ${instance.constructor.name}`);
-    }
-    let result;
-    if (instance instanceof manifest_1.Manifest) {
-        result = instance[method]();
-    }
-    else if (instance instanceof release_pr_1.ReleasePR) {
-        result = instance[method]();
-    }
-    else if (instance instanceof github_release_1.GitHubRelease) {
-        result = instance[method]();
-    }
-    else {
-        throw new Error('Unknown instance.');
+exports.buildStrategy = buildStrategy;
+const allVersioningTypes = [
+    'default',
+    'always-bump-patch',
+    'service-pack',
+];
+function buildVersioningStrategy(options) {
+    switch (options.type) {
+        case 'always-bump-patch':
+            return new always_bump_patch_1.AlwaysBumpPatch(options);
+        case 'service-pack':
+            return new service_pack_1.ServicePackVersioningStrategy(options);
+        default:
+            return new default_1.DefaultVersioningStrategy(options);
     }
-    return result;
 }
-function getLabels(label) {
-    return label ? label.split(',') : constants_1.DEFAULT_LABELS;
-}
-function getGitHubFactoryOpts(options) {
-    const { repoUrl, defaultBranch, fork, token, apiUrl, octokitAPIs, ...remaining } = options;
-    return [
-        {
-            repoUrl,
-            defaultBranch,
-            fork,
-            token,
-            apiUrl,
-            octokitAPIs,
-        },
-        remaining,
-    ];
-}
-function manifest(options) {
-    const [GHFactoryOptions, ManifestFactoryOptions] = getGitHubFactoryOpts(options);
-    const github = gitHubInstance(GHFactoryOptions);
-    return new manifest_1.Manifest({ github, ...ManifestFactoryOptions });
-}
-function githubRelease(options) {
-    const [GHFactoryOptions, GHRAndRPFactoryOptions] = getGitHubFactoryOpts(options);
-    const github = gitHubInstance(GHFactoryOptions);
-    const { releaseType, label, path, packageName, bumpMinorPreMajor, releaseAs, snapshot, monorepoTags, changelogSections, changelogPath, lastPackageVersion, versionFile, ...GHRFactoryOptions } = GHRAndRPFactoryOptions;
-    const labels = getLabels(label);
-    const releasePR = new (releasePRClass(releaseType))({
-        github,
-        labels,
-        path,
-        packageName,
-        bumpMinorPreMajor,
-        releaseAs,
-        snapshot,
-        monorepoTags,
-        changelogSections,
-        changelogPath,
-        lastPackageVersion,
-        versionFile,
-    });
-    return new github_release_1.GitHubRelease({ github, releasePR, ...GHRFactoryOptions });
-}
-function releasePR(options) {
-    const [GHFactoryOptions, RPFactoryOptions] = getGitHubFactoryOpts(options);
-    const github = gitHubInstance(GHFactoryOptions);
-    const { releaseType, label, latestTagName, latestTagSha, latestTagVersion, ...RPConstructorOptions } = RPFactoryOptions;
-    let latestTag = undefined;
-    if (latestTagName && latestTagSha && latestTagVersion) {
-        latestTag = {
-            name: latestTagName,
-            sha: latestTagSha,
-            version: latestTagVersion,
-        };
+function buildPlugin(options) {
+    switch (options.type) {
+        case 'cargo-workspace':
+            return new cargo_workspace_1.CargoWorkspace(options.github, options.targetBranch, options.repositoryConfig, options);
+        case 'node-workspace':
+            return new node_workspace_1.NodeWorkspace(options.github, options.targetBranch, options.repositoryConfig, options);
+        default:
+            throw new Error(`Unknown plugin type: ${options.type}`);
     }
-    const labels = getLabels(label);
-    return new (exports.factory.releasePRClass(releaseType))({
-        github,
-        labels,
-        latestTag,
-        ...RPConstructorOptions,
-    });
-}
-function gitHubInstance(options) {
-    const { repoUrl, ...remaining } = options;
-    const [owner, repo] = parseGithubRepoUrl(repoUrl);
-    return new github_1.GitHub({
-        owner,
-        repo,
-        ...remaining,
-    });
 }
-function releasePRClass(releaseType) {
-    const releasers = releasers_1.getReleasers();
-    const releaser = releaseType ? releasers[releaseType] : release_pr_1.ReleasePR;
-    return releaser;
-}
-exports.factory = {
-    gitHubInstance,
-    githubRelease,
-    manifest,
-    releasePR,
-    releasePRClass,
-    call,
-    runCommand,
-};
+exports.buildPlugin = buildPlugin;
 //# sourceMappingURL=factory.js.map