release-please 12.4.0 → 13.0.0-candidate.1

package/build/src/bin/release-please.js

@@ -15,219 +15,480 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleError = exports.parser = void 0;
-const chalk = require("chalk");
 const coerce_option_1 = require("../util/coerce-option");
-const factory_1 = require("../factory");
-const releasers_1 = require("../releasers");
 const yargs = require("yargs");
-const constants_1 = require("../constants");
-function releaserCommon(ya) {
+const github_1 = require("../github");
+const manifest_1 = require("../manifest");
+const logger_1 = require("../util/logger");
+const factory_1 = require("../factory");
+const bootstrapper_1 = require("../bootstrapper");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const parseGithubRepoUrl = require('parse-github-repo-url');
+function gitHubOptions(yargs) {
+    return yargs
+        .option('token', { describe: 'GitHub token with repo write permissions' })
+        .option('api-url', {
+        describe: 'URL to use when making API requests',
+        default: github_1.GH_API_URL,
+        type: 'string',
+    })
+        .option('graphql-url', {
+        describe: 'URL to use when making GraphQL requests',
+        default: github_1.GH_GRAPHQL_URL,
+        type: 'string',
+    })
+        .option('default-branch', {
+        describe: 'The branch to open release PRs against and tag releases on',
+        type: 'string',
+        deprecated: 'use --target-branch instead',
+    })
+        .option('target-branch', {
+        describe: 'The branch to open release PRs against and tag releases on',
+        type: 'string',
+    })
+        .option('repo-url', {
+        describe: 'GitHub URL to generate release for',
+        demand: true,
+    })
+        .option('dry-run', {
+        describe: 'Prepare but do not take action',
+        type: 'boolean',
+        default: false,
+    })
+        .middleware(_argv => {
+        const argv = _argv;
+        // allow secrets to be loaded from file path
+        // rather than being passed directly to the bin.
+        if (argv.token)
+            argv.token = coerce_option_1.coerceOption(argv.token);
+        if (argv.apiUrl)
+            argv.apiUrl = coerce_option_1.coerceOption(argv.apiUrl);
+        if (argv.graphqlUrl)
+            argv.graphqlUrl = coerce_option_1.coerceOption(argv.graphqlUrl);
+    });
+}
+function releaseOptions(yargs) {
+    return yargs
+        .option('draft', {
+        describe: 'mark release as a draft. no tag is created but tag_name and ' +
+            'target_commitish are associated with the release for future ' +
+            'tag creation upon "un-drafting" the release.',
+        type: 'boolean',
+        default: false,
+    })
+        .option('label', {
+        default: 'autorelease: pending',
+        describe: 'comma-separated list of labels to remove to from release PR',
+    })
+        .option('release-label', {
+        describe: 'set a pull request label other than "autorelease: tagged"',
+        default: 'autorelease: tagged',
+        type: 'string',
+    });
+}
+function pullRequestOptions(yargs) {
     // common to ReleasePR and GitHubRelease
-    ya.option('label', {
+    return yargs
+        .option('label', {
         default: 'autorelease: pending',
-        describe: 'label to remove from release PR',
+        describe: 'comma-separated list of labels to add to from release PR',
+    })
+        .option('fork', {
+        describe: 'should the PR be created from a fork',
+        type: 'boolean',
+        default: false,
+    })
+        .option('draft-pull-request', {
+        describe: 'mark pull request as a draft',
+        type: 'boolean',
+        default: false,
+    })
+        .option('signoff', {
+        describe: 'Add Signed-off-by line at the end of the commit log message using the user and email provided. (format "Name <email@example.com>").',
+        type: 'string',
     });
-    ya.option('release-as', {
+}
+function pullRequestStrategyOptions(yargs) {
+    return yargs
+        .option('release-as', {
         describe: 'override the semantically determined release version',
         type: 'string',
-    });
-    ya.option('bump-minor-pre-major', {
+    })
+        .option('bump-minor-pre-major', {
         describe: 'should we bump the semver minor prior to the first major release',
         default: false,
         type: 'boolean',
-    });
-    ya.option('bump-patch-for-minor-pre-major', {
+    })
+        .option('bump-patch-for-minor-pre-major', {
         describe: 'should we bump the semver patch instead of the minor for non-breaking' +
             ' changes prior to the first major release',
         default: false,
         type: 'boolean',
-    });
-    ya.option('path', {
-        describe: 'release from path other than root directory',
-        type: 'string',
-    });
-    ya.option('package-name', {
-        describe: 'name of package release is being minted for',
-    });
-    ya.option('monorepo-tags', {
+    })
+        .option('monorepo-tags', {
         describe: 'include library name in tags and release branches',
         type: 'boolean',
         default: false,
-    });
-    ya.option('version-file', {
+    })
+        .option('extra-files', {
+        describe: 'extra files for the strategy to consider',
+        type: 'string',
+        coerce(arg) {
+            if (arg) {
+                return arg.split(',');
+            }
+            return arg;
+        },
+    })
+        .option('version-file', {
         describe: 'path to version file to update, e.g., version.rb',
-    });
-    ya.option('last-package-version', {
-        describe: 'last version # that package was released as',
-    });
-    ya.option('snapshot', {
+        type: 'string',
+    })
+        .option('snapshot', {
         describe: 'is it a snapshot (or pre-release) being generated?',
         type: 'boolean',
         default: false,
-    });
-    ya.option('pull-request-title-pattern', {
+    })
+        .option('versioning-strategy', {
+        describe: 'strategy used for bumping versions',
+        choices: factory_1.getVersioningStrategyTypes(),
+        default: 'default',
+    })
+        .option('pull-request-title-pattern', {
         describe: 'Title pattern to make release PR',
         type: 'string',
-    });
-    ya.option('signoff', {
-        describe: 'Add Signed-off-by line at the end of the commit log message using the user and email provided. (format "Name <email@example.com>").',
-        type: 'string',
-    });
-    ya.option('changelog-path', {
+    })
+        .option('changelog-path', {
         default: 'CHANGELOG.md',
         describe: 'where can the CHANGELOG be found in the project?',
-    });
-    ya.option('latest-tag-version', {
+        type: 'string',
+    })
+        .option('last-package-version', {
+        describe: 'last version # that package was released as',
+        type: 'string',
+        deprecated: 'use --latest-tag-version instead',
+    })
+        .option('latest-tag-version', {
         describe: 'Override the detected latest tag version',
         type: 'string',
-    });
-    ya.option('latest-tag-sha', {
+    })
+        .option('latest-tag-sha', {
         describe: 'Override the detected latest tag SHA',
         type: 'string',
-    });
-    ya.option('latest-tag-name', {
+    })
+        .option('latest-tag-name', {
         describe: 'Override the detected latest tag name',
         type: 'string',
+    })
+        .middleware(_argv => {
+        const argv = _argv;
+        if (argv.defaultBranch) {
+            logger_1.logger.warn('--default-branch is deprecated. Please use --target-branch instead.');
+            argv.targetBranch = argv.targetBranch || argv.defaultBranch;
+        }
+        if (argv.lastPackageVersion) {
+            logger_1.logger.warn('--latest-package-version is deprecated. Please use --latest-tag-version instead.');
+            argv.latestTagVersion =
+                argv.latestTagVersion || argv.lastPackageVersion;
+        }
     });
 }
-function releaseType(ya, defaultType) {
-    const relTypeOptions = {
+function manifestConfigOptions(yargs, defaultType) {
+    return yargs
+        .option('path', {
+        describe: 'release from path other than root directory',
+        type: 'string',
+    })
+        .option('component', {
+        describe: 'name of component release is being minted for',
+        type: 'string',
+    })
+        .option('package-name', {
+        describe: 'name of package release is being minted for',
+        type: 'string',
+    })
+        .option('release-type', {
         describe: 'what type of repo is a release being created for?',
-        choices: releasers_1.getReleaserTypes(),
-    };
-    if (defaultType) {
-        relTypeOptions.default = defaultType;
-    }
-    ya.option('release-type', relTypeOptions);
+        choices: factory_1.getReleaserTypes(),
+        default: defaultType,
+    });
 }
-function manifestOptions(ya) {
-    ya.option('config-file', {
+function manifestOptions(yargs) {
+    return yargs
+        .option('config-file', {
         default: 'release-please-config.json',
         describe: 'where can the config file be found in the project?',
-    });
-    ya.option('manifest-file', {
+    })
+        .option('manifest-file', {
         default: '.release-please-manifest.json',
         describe: 'where can the manifest file be found in the project?',
     });
 }
-exports.parser = yargs
-    .command('manifest-pr', 'create a release-PR using a manifest file', (yargs) => {
-    manifestOptions(yargs);
-}, (argv) => {
-    factory_1.factory.runCommand('manifest-pr', argv).catch(exports.handleError);
-})
-    .command('manifest-release', 'create releases/tags from last release-PR using a manifest file', (yargs) => {
-    manifestOptions(yargs);
-}, (argv) => {
-    factory_1.factory.runCommand('manifest-release', argv).catch(exports.handleError);
-})
-    .command('release-pr', 'create or update a PR representing the next release', 
-// options unique to ReleasePR
-(yargs) => {
-    releaseType(yargs, 'node');
-    releaserCommon(yargs);
-}, (argv) => {
-    factory_1.factory.runCommand('release-pr', argv).catch(exports.handleError);
-})
-    .command('latest-tag', 'find the sha of the latest release', 
-// options unique to ReleasePR
-(yargs) => {
-    releaseType(yargs, 'node');
-    releaserCommon(yargs);
-}, (argv) => {
-    factory_1.factory
-        .runCommand('latest-tag', argv)
-        .catch(exports.handleError)
-        .then(latestTag => {
-        if (latestTag) {
-            console.log(latestTag);
+const createReleasePullRequestCommand = {
+    command: 'release-pr',
+    describe: 'create or update a PR representing the next release',
+    builder(yargs) {
+        return manifestOptions(manifestConfigOptions(pullRequestOptions(pullRequestStrategyOptions(gitHubOptions(yargs)))));
+    },
+    async handler(argv) {
+        const github = await buildGitHub(argv);
+        const targetBranch = argv.targetBranch || github.repository.defaultBranch;
+        let manifest;
+        if (argv.releaseType) {
+            manifest = await manifest_1.Manifest.fromConfig(github, targetBranch, {
+                releaseType: argv.releaseType,
+                component: argv.component,
+                packageName: argv.packageName,
+                draftPullRequest: argv.draftPullRequest,
+                bumpMinorPreMajor: argv.bumpMinorPreMajor,
+                bumpPatchForMinorPreMajor: argv.bumpPatchForMinorPreMajor,
+                changelogPath: argv.changelogPath,
+                changelogSections: argv.changelogSections,
+                releaseAs: argv.releaseAs,
+                versioning: argv.versioningStrategy,
+                extraFiles: argv.extraFiles,
+                versionFile: argv.versionFile,
+            }, extractManifestOptions(argv), argv.path);
         }
         else {
-            console.log('No latest tag found.');
-            process.exitCode = 1;
+            const manifestOptions = extractManifestOptions(argv);
+            manifest = await manifest_1.Manifest.fromManifest(github, targetBranch, argv.configFile, argv.manifestFile, manifestOptions);
         }
+        if (argv.dryRun) {
+            const pullRequests = await manifest.buildPullRequests();
+            console.log(`Would open ${pullRequests.length} pull requests`);
+            console.log('fork:', manifest.fork);
+            for (const pullRequest of pullRequests) {
+                console.log('title:', pullRequest.title.toString());
+                console.log('branch:', pullRequest.headRefName);
+                console.log('draft:', pullRequest.draft);
+                console.log('body:', pullRequest.body.toString());
+                console.log('updates:', pullRequest.updates.length);
+                for (const update of pullRequest.updates) {
+                    console.log(`  ${update.path}: `, 
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    update.updater.constructor);
+                }
+            }
+        }
+        else {
+            const pullRequestNumbers = await manifest.createPullRequests();
+            console.log(pullRequestNumbers);
+        }
+    },
+};
+const createReleaseCommand = {
+    command: 'github-release',
+    describe: 'create a GitHub release from a release PR',
+    builder(yargs) {
+        return releaseOptions(manifestOptions(manifestConfigOptions(gitHubOptions(yargs))));
+    },
+    async handler(argv) {
+        const github = await buildGitHub(argv);
+        const targetBranch = argv.targetBranch ||
+            argv.defaultBranch ||
+            github.repository.defaultBranch;
+        let manifest;
+        if (argv.releaseType) {
+            manifest = await manifest_1.Manifest.fromConfig(github, targetBranch, {
+                releaseType: argv.releaseType,
+                component: argv.component,
+                packageName: argv.packageName,
+                draft: argv.draft,
+            }, extractManifestOptions(argv), argv.path);
+        }
+        else {
+            const manifestOptions = extractManifestOptions(argv);
+            manifest = await manifest_1.Manifest.fromManifest(github, targetBranch, argv.configFile, argv.manifestFile, manifestOptions);
+        }
+        if (argv.dryRun) {
+            const releases = await manifest.buildReleases();
+            logger_1.logger.info(releases);
+        }
+        else {
+            const releaseNumbers = await manifest.createReleases();
+            console.log(releaseNumbers);
+        }
+    },
+};
+const createManifestPullRequestCommand = {
+    command: 'manifest-pr',
+    describe: 'create a release-PR using a manifest file',
+    deprecated: 'use release-pr instead.',
+    builder(yargs) {
+        return manifestOptions(pullRequestOptions(gitHubOptions(yargs)));
+    },
+    async handler(argv) {
+        logger_1.logger.warn('manifest-pr is deprecated. Please use release-pr instead.');
+        const github = await buildGitHub(argv);
+        const targetBranch = argv.targetBranch ||
+            argv.defaultBranch ||
+            github.repository.defaultBranch;
+        const manifestOptions = extractManifestOptions(argv);
+        const manifest = await manifest_1.Manifest.fromManifest(github, targetBranch, argv.configFile, argv.manifestFile, manifestOptions);
+        if (argv.dryRun) {
+            const pullRequests = await manifest.buildPullRequests();
+            console.log(`Would open ${pullRequests.length} pull requests`);
+            console.log('fork:', manifest.fork);
+            for (const pullRequest of pullRequests) {
+                console.log('title:', pullRequest.title.toString());
+                console.log('branch:', pullRequest.headRefName);
+                console.log('draft:', pullRequest.draft);
+                console.log('body:', pullRequest.body.toString());
+                console.log('updates:', pullRequest.updates.length);
+                for (const update of pullRequest.updates) {
+                    console.log(`  ${update.path}: `, 
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    update.updater.constructor);
+                }
+            }
+        }
+        else {
+            const pullRequestNumbers = await manifest.createPullRequests();
+            console.log(pullRequestNumbers);
+        }
+    },
+};
+const createManifestReleaseCommand = {
+    command: 'manifest-release',
+    describe: 'create releases/tags from last release-PR using a manifest file',
+    deprecated: 'use github-release instead',
+    builder(yargs) {
+        return manifestOptions(releaseOptions(gitHubOptions(yargs)));
+    },
+    async handler(argv) {
+        logger_1.logger.warn('manifest-release is deprecated. Please use github-release instead.');
+        const github = await buildGitHub(argv);
+        const targetBranch = argv.targetBranch ||
+            argv.defaultBranch ||
+            github.repository.defaultBranch;
+        const manifestOptions = extractManifestOptions(argv);
+        const manifest = await manifest_1.Manifest.fromManifest(github, targetBranch, argv.configFile, argv.manifestFile, manifestOptions);
+        if (argv.dryRun) {
+            const releases = await manifest.buildReleases();
+            logger_1.logger.info(releases);
+        }
+        else {
+            const releaseNumbers = await manifest.createReleases();
+            console.log(releaseNumbers);
+        }
+    },
+};
+const bootstrapCommand = {
+    command: 'bootstrap',
+    describe: 'configure release manifest',
+    builder(yargs) {
+        return manifestOptions(releaseOptions(pullRequestStrategyOptions(gitHubOptions(yargs))))
+            .option('initial-version', {
+            description: 'current version',
+        })
+            .coerce('path', arg => {
+            return arg || manifest_1.ROOT_PROJECT_PATH;
+        });
+    },
+    async handler(argv) {
+        const github = await buildGitHub(argv);
+        const targetBranch = argv.targetBranch ||
+            argv.defaultBranch ||
+            github.repository.defaultBranch;
+        const bootstrapper = new bootstrapper_1.Bootstrapper(github, targetBranch, argv.manifestFile, argv.configFile, argv.initialVersion);
+        const pullRequest = await bootstrapper.bootstrap(argv.path, {
+            releaseType: argv.releaseType,
+            component: argv.component,
+            packageName: argv.packageName,
+            draft: argv.draft,
+            draftPullRequest: argv.draftPullRequest,
+            bumpMinorPreMajor: argv.bumpMinorPreMajor,
+            bumpPatchForMinorPreMajor: argv.bumpPatchForMinorPreMajor,
+            changelogPath: argv.changelogPath,
+            changelogSections: argv.changelogSections,
+            releaseAs: argv.releaseAs,
+            versioning: argv.versioningStrategy,
+            extraFiles: argv.extraFiles,
+            versionFile: argv.versionFile,
+        });
+        console.log(pullRequest);
+    },
+};
+async function buildGitHub(argv) {
+    const [owner, repo] = parseGithubRepoUrl(argv.repoUrl);
+    const github = await github_1.GitHub.create({
+        owner,
+        repo,
+        token: argv.token,
     });
-})
-    .command('github-release', 'create a GitHub release from a release PR', 
-// options unique to GitHubRelease
-(yargs) => {
-    releaseType(yargs);
-    releaserCommon(yargs);
-    yargs.option('draft', {
-        describe: 'mark release as a draft. no tag is created but tag_name and ' +
-            'target_commitish are associated with the release for future ' +
-            'tag creation upon "un-drafting" the release.',
-        type: 'boolean',
-        default: false,
-    });
-    yargs.option('release-label', {
-        describe: 'set a pull request label other than "autorelease: tagged"',
-        type: 'string',
-    });
-}, (argv) => {
-    factory_1.factory.runCommand('github-release', argv).catch(exports.handleError);
-})
-    .middleware(_argv => {
-    const argv = _argv;
-    // allow secrets to be loaded from file path
-    // rather than being passed directly to the bin.
-    if (argv.token)
-        argv.token = coerce_option_1.coerceOption(argv.token);
-    if (argv.apiUrl)
-        argv.apiUrl = coerce_option_1.coerceOption(argv.apiUrl);
-})
+    return github;
+}
+exports.parser = yargs
+    .command(createReleasePullRequestCommand)
+    .command(createReleaseCommand)
+    .command(createManifestPullRequestCommand)
+    .command(createManifestReleaseCommand)
+    .command(bootstrapCommand)
     .option('debug', {
     describe: 'print verbose errors (use only for local debugging).',
     default: false,
     type: 'boolean',
 })
-    // See base GitHub options (e.g. GitHubFactoryOptions)
-    .option('token', { describe: 'GitHub token with repo write permissions' })
-    .option('api-url', {
-    describe: 'URL to use when making API requests',
-    default: constants_1.GH_API_URL,
-    type: 'string',
-})
-    .option('default-branch', {
-    describe: 'The branch to open release PRs against and tag releases on',
-    type: 'string',
-})
-    .option('fork', {
-    describe: 'should the PR be created from a fork',
-    type: 'boolean',
+    .option('trace', {
+    describe: 'print extra verbose errors (use only for local debugging).',
     default: false,
+    type: 'boolean',
 })
-    .option('repo-url', {
-    describe: 'GitHub URL to generate release for',
-    demand: true,
+    .middleware(argv => {
+    if (argv.trace) {
+        logger_1.setLogger(new logger_1.CheckpointLogger(true, true));
+    }
+    else if (argv.debug) {
+        logger_1.setLogger(new logger_1.CheckpointLogger(true));
+    }
 })
     .demandCommand(1)
     .strict(true)
     .scriptName('release-please');
+function extractManifestOptions(argv) {
+    const manifestOptions = {};
+    if ('fork' in argv && argv.fork !== undefined) {
+        manifestOptions.fork = argv.fork;
+    }
+    if (argv.label) {
+        manifestOptions.labels = argv.label.split(',');
+    }
+    if ('releaseLabel' in argv && argv.releaseLabel) {
+        manifestOptions.releaseLabels = argv.releaseLabel.split(',');
+    }
+    if ('signoff' in argv && argv.signoff) {
+        manifestOptions.signoff = argv.signoff;
+    }
+    if ('draft' in argv && argv.draft !== undefined) {
+        manifestOptions.draft = argv.draft;
+    }
+    if ('draftPullRequest' in argv && argv.draftPullRequest !== undefined) {
+        manifestOptions.draftPullRequest = argv.draftPullRequest;
+    }
+    return manifestOptions;
+}
 // The errors returned by octokit currently contain the
 // request object, this contains information we don't want to
 // leak. For this reason, we capture exceptions and print
 // a less verbose error message (run with --debug to output
 // the request object, don't do this in CI/CD).
 exports.handleError = (err) => {
-    var _a;
+    var _a, _b;
     let status = '';
     if (exports.handleError.yargsArgs === undefined) {
         throw new Error('Set handleError.yargsArgs with a yargs.Arguments instance.');
     }
-    if (!exports.handleError.logger) {
-        exports.handleError.logger = console;
-    }
     const ya = exports.handleError.yargsArgs;
-    const logger = exports.handleError.logger;
-    const command = ((_a = ya === null || ya === void 0 ? void 0 : ya._) === null || _a === void 0 ? void 0 : _a.length) ? ya._[0] : '';
+    const errorLogger = (_a = exports.handleError.logger) !== null && _a !== void 0 ? _a : logger_1.logger;
+    const command = ((_b = ya === null || ya === void 0 ? void 0 : ya._) === null || _b === void 0 ? void 0 : _b.length) ? ya._[0] : '';
     if (err.status) {
         status = '' + err.status;
     }
-    logger.error(chalk.red(`command ${command} failed${status ? ` with status ${status}` : ''}`));
+    errorLogger.error(`command ${command} failed${status ? ` with status ${status}` : ''}`);
     if (ya === null || ya === void 0 ? void 0 : ya.debug) {
-        logger.error('---------');
-        logger.error(err.stack);
+        logger_1.logger.error('---------');
+        logger_1.logger.error(err.stack);
     }
     process.exitCode = 1;
 };
@@ -235,13 +496,15 @@ exports.handleError = (err) => {
 // for the parser to be easily tested:
 let argv;
 if (require.main === module) {
-    argv = exports.parser.parse();
-    exports.handleError.yargsArgs = argv;
-    process.on('unhandledRejection', err => {
-        exports.handleError(err);
-    });
-    process.on('uncaughtException', err => {
-        exports.handleError(err);
-    });
+    (async () => {
+        argv = await exports.parser.parseAsync();
+        exports.handleError.yargsArgs = argv;
+        process.on('unhandledRejection', err => {
+            exports.handleError(err);
+        });
+        process.on('uncaughtException', err => {
+            exports.handleError(err);
+        });
+    })();
 }
 //# sourceMappingURL=release-please.js.map

package/build/src/bootstrapper.d.ts

@@ -0,0 +1,12 @@
+import { GitHub } from './github';
+import { ReleaserConfig } from './manifest';
+import { PullRequest } from './pull-request';
+export declare class Bootstrapper {
+    private github;
+    private targetBranch;
+    private manifestFile;
+    private configFile;
+    private initialVersion;
+    constructor(github: GitHub, targetBranch: string, manifestFile?: string, configFile?: string, initialVersionString?: string);
+    bootstrap(path: string, config: ReleaserConfig): Promise<PullRequest>;
+}