release-please 17.4.0 → 17.5.0

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

@@ -18,12 +18,14 @@ exports.handleError = exports.parser = void 0;
 const coerce_option_1 = require("../util/coerce-option");
 const yargs = require("yargs");
 const github_1 = require("../github");
+const github_api_1 = require("../github-api");
 const manifest_1 = require("../manifest");
 const changelog_notes_1 = require("../changelog-notes");
 const logger_1 = require("../util/logger");
 const factory_1 = require("../factory");
 const bootstrapper_1 = require("../bootstrapper");
 const diff_1 = require("diff");
+const local_github_1 = require("../local-github");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const parseGithubRepoUrl = require('parse-github-repo-url');
 function gitHubOptions(yargs) {
@@ -31,12 +33,12 @@ function gitHubOptions(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,
+        default: github_api_1.GH_API_URL,
         type: 'string',
     })
         .option('graphql-url', {
         describe: 'URL to use when making GraphQL requests',
-        default: github_1.GH_GRAPHQL_URL,
+        default: github_api_1.GH_GRAPHQL_URL,
         type: 'string',
     })
         .option('default-branch', {
@@ -56,6 +58,19 @@ function gitHubOptions(yargs) {
         describe: 'Prepare but do not take action',
         type: 'boolean',
         default: false,
+    })
+        .option('local', {
+        describe: 'Whether to use local clone',
+        type: 'boolean',
+        default: false,
+    })
+        .option('local-path', {
+        describe: 'Path to local clone directory. If not set, uses a temporary directory.',
+        type: 'string',
+    })
+        .option('local-clone-depth', {
+        describe: 'Depth of local clone. Defaults to the entire repo.',
+        type: 'number',
     })
         .middleware(_argv => {
         const argv = _argv;
@@ -565,14 +580,28 @@ const debugConfigCommand = {
 };
 async function buildGitHub(argv) {
     const [owner, repo] = parseGithubRepoUrl(argv.repoUrl);
-    const github = await github_1.GitHub.create({
-        owner,
-        repo,
-        token: argv.token,
-        apiUrl: argv.apiUrl,
-        graphqlUrl: argv.graphqlUrl,
-    });
-    return github;
+    if (argv.local) {
+        const localGitHub = await local_github_1.LocalGitHub.create({
+            owner,
+            repo,
+            token: argv.token,
+            apiUrl: argv.apiUrl,
+            graphqlUrl: argv.graphqlUrl,
+            localRepoPath: argv.localPath,
+            cloneDepth: argv.localCloneDepth,
+        });
+        return localGitHub;
+    }
+    else {
+        const github = await github_1.GitHub.create({
+            owner,
+            repo,
+            token: argv.token,
+            apiUrl: argv.apiUrl,
+            graphqlUrl: argv.graphqlUrl,
+        });
+        return github;
+    }
 }
 exports.parser = yargs
     .command(createReleasePullRequestCommand)

package/build/src/bootstrapper.d.ts

@@ -1,4 +1,4 @@
-import { GitHub } from './github';
+import { Scm } from './scm';
 import { ReleaserConfig } from './manifest';
 import { PullRequest } from './pull-request';
 import { Update } from './update';
@@ -11,7 +11,7 @@ export declare class Bootstrapper {
     private manifestFile;
     private configFile;
     private initialVersion;
-    constructor(github: GitHub, targetBranch: string, manifestFile?: string, configFile?: string, initialVersionString?: string);
+    constructor(github: Scm, targetBranch: string, manifestFile?: string, configFile?: string, initialVersionString?: string);
     bootstrap(path: string, config: ReleaserConfig): Promise<PullRequest>;
     buildPullRequest(path: string, config: ReleaserConfig): Promise<BootstrapPullRequest>;
 }

package/build/src/changelog-notes/default.js

@@ -50,9 +50,17 @@ class DefaultChangelogNotes {
             const notes = commit.notes
                 .filter(note => note.title === 'BREAKING CHANGE')
                 .map(note => replaceIssueLink(note, context.host, context.owner, context.repository));
+            let subject = htmlEscape(commit.bareMessage);
+            // Append author info if enabled and author is available
+            if (options.includeCommitAuthors && commit.author) {
+                const authorDisplay = commit.author.username
+                    ? `@${commit.author.username}`
+                    : commit.author.name;
+                subject = `${subject} (${authorDisplay})`;
+            }
             return {
                 body: '',
-                subject: htmlEscape(commit.bareMessage),
+                subject,
                 type: commit.type,
                 scope: commit.scope,
                 notes,

package/build/src/changelog-notes/github.d.ts

@@ -1,8 +1,8 @@
 import { ChangelogNotes, BuildNotesOptions } from '../changelog-notes';
 import { ConventionalCommit } from '../commit';
-import { GitHub } from '../github';
+import { Scm } from '../scm';
 export declare class GitHubChangelogNotes implements ChangelogNotes {
     private github;
-    constructor(github: GitHub);
+    constructor(github: Scm);
     buildNotes(_commits: ConventionalCommit[], options: BuildNotesOptions): Promise<string>;
 }

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

@@ -9,6 +9,7 @@ export interface BuildNotesOptions {
     targetBranch: string;
     changelogSections?: ChangelogSection[];
     commits?: Commit[];
+    includeCommitAuthors?: boolean;
 }
 export interface ChangelogNotes {
     buildNotes(commits: ConventionalCommit[], options: BuildNotesOptions): Promise<string>;

package/build/src/commit.d.ts

@@ -1,11 +1,17 @@
 import { PullRequest } from './pull-request';
 import { Logger } from './util/logger';
 import * as parser from '@conventional-commits/parser';
+export interface CommitAuthor {
+    name: string;
+    email?: string;
+    username?: string;
+}
 export interface Commit {
     sha: string;
     message: string;
     files?: string[];
     pullRequest?: PullRequest;
+    author?: CommitAuthor;
 }
 export interface ConventionalCommit extends Commit {
     type: string;

package/build/src/factories/changelog-notes-factory.d.ts

@@ -1,9 +1,9 @@
-import { GitHub } from '../github';
+import { Scm } from '../scm';
 import { ChangelogNotes, ChangelogSection } from '../changelog-notes';
 export type ChangelogNotesType = string;
 export interface ChangelogNotesFactoryOptions {
     type: ChangelogNotesType;
-    github: GitHub;
+    github: Scm;
     changelogSections?: ChangelogSection[];
     commitPartial?: string;
     headerPartial?: string;

package/build/src/factories/plugin-factory.d.ts

@@ -1,11 +1,11 @@
 import { PluginType, RepositoryConfig } from '../manifest';
-import { GitHub } from '../github';
+import { Scm } from '../scm';
 import { ManifestPlugin } from '../plugin';
 import { VersioningStrategyType } from './versioning-strategy-factory';
 import { Logger } from '../util/logger';
 export interface PluginFactoryOptions {
     type: PluginType;
-    github: GitHub;
+    github: Scm;
     targetBranch: string;
     repositoryConfig: RepositoryConfig;
     manifestPath: string;

package/build/src/factories/versioning-strategy-factory.d.ts

@@ -1,5 +1,5 @@
 import { VersioningStrategy } from '../versioning-strategy';
-import { GitHub } from '../github';
+import { Scm } from '../scm';
 export type VersioningStrategyType = string;
 export interface VersioningStrategyFactoryOptions {
     type?: VersioningStrategyType;
@@ -7,7 +7,7 @@ export interface VersioningStrategyFactoryOptions {
     bumpPatchForMinorPreMajor?: boolean;
     prereleaseType?: string;
     prerelease?: boolean;
-    github: GitHub;
+    github: Scm;
 }
 export type VersioningStrategyBuilder = (options: VersioningStrategyFactoryOptions) => VersioningStrategy;
 export declare function buildVersioningStrategy(options: VersioningStrategyFactoryOptions): VersioningStrategy;

package/build/src/factory.d.ts

@@ -1,4 +1,4 @@
-import { GitHub } from './github';
+import { Scm } from './scm';
 import { ReleaserConfig } from './manifest';
 import { BaseStrategyOptions } from './strategies/base';
 import { Strategy } from './strategy';
@@ -8,7 +8,7 @@ export * from './factories/versioning-strategy-factory';
 export type ReleaseType = string;
 export type ReleaseBuilder = (options: BaseStrategyOptions) => Strategy;
 export interface StrategyFactoryOptions extends ReleaserConfig {
-    github: GitHub;
+    github: Scm;
     path?: string;
     targetBranch?: string;
 }

package/build/src/github-api.d.ts

@@ -0,0 +1,260 @@
+import { Octokit } from '@octokit/rest';
+import { request } from '@octokit/request';
+import { Logger } from 'code-suggester/build/src/types';
+import { PullRequest } from './pull-request';
+import { Repository } from './repository';
+import { Release } from './release';
+import { ScmRelease, ScmReleaseIteratorOptions, ScmReleaseOptions, ScmCommitIteratorOptions } from './scm';
+import { HttpsProxyAgent } from 'https-proxy-agent';
+import { HttpProxyAgent } from 'http-proxy-agent';
+export declare const GH_API_URL = "https://api.github.com";
+export declare const GH_GRAPHQL_URL = "https://api.github.com";
+export type OctokitType = InstanceType<typeof Octokit>;
+type RequestBuilderType = typeof request;
+type DefaultFunctionType = RequestBuilderType['defaults'];
+type RequestFunctionType = ReturnType<DefaultFunctionType>;
+export interface OctokitAPIs {
+    graphql: Function;
+    request: RequestFunctionType;
+    octokit: OctokitType;
+}
+export interface ProxyOption {
+    host: string;
+    port: number;
+}
+export interface GitHubCreateOptions {
+    owner: string;
+    repo: string;
+    defaultBranch?: string;
+    apiUrl?: string;
+    graphqlUrl?: string;
+    octokitAPIs?: OctokitAPIs;
+    token?: string;
+    logger?: Logger;
+    proxy?: ProxyOption;
+    fetch?: any;
+}
+export interface GitHubApiOptions {
+    repository: Repository;
+    octokitAPIs: OctokitAPIs;
+    logger?: Logger;
+}
+export interface GraphQLCommit {
+    sha: string;
+    message: string;
+    associatedPullRequests: {
+        nodes: GraphQLPullRequest[];
+    };
+}
+export interface GraphQLPullRequest {
+    number: number;
+    title: string;
+    body: string;
+    baseRefName: string;
+    headRefName: string;
+    labels: {
+        nodes: {
+            name: string;
+        }[];
+    };
+    mergeCommit?: {
+        oid: string;
+    };
+    files: {
+        nodes: {
+            path: string;
+        }[];
+        pageInfo: {
+            hasNextPage: boolean;
+        };
+    };
+}
+export interface PullRequestHistory {
+    pageInfo: {
+        hasNextPage: boolean;
+        endCursor: string | undefined;
+    };
+    data: PullRequest[];
+}
+export interface CommitHistory {
+    pageInfo: {
+        hasNextPage: boolean;
+        endCursor: string | undefined;
+    };
+    data: ScmRelease[];
+}
+export type CommitIteratorOptions = ScmCommitIteratorOptions;
+export interface GraphQLRelease {
+    name: string;
+    tag: {
+        name: string;
+    };
+    tagCommit: {
+        oid: string;
+    };
+    url: string;
+    description: string;
+    isDraft: boolean;
+}
+export interface ReleaseHistory {
+    pageInfo: {
+        hasNextPage: boolean;
+        endCursor: string | undefined;
+    };
+    data: ScmRelease[];
+}
+export type ReleaseIteratorOptions = ScmReleaseIteratorOptions;
+export declare const MAX_SLEEP_SECONDS = 20;
+export declare const MAX_ISSUE_BODY_SIZE = 65536;
+export declare class GitHubApi {
+    readonly repository: Repository;
+    readonly octokitAPIs: OctokitAPIs;
+    octokit: OctokitType;
+    private graphql;
+    private logger;
+    constructor(options: GitHubApiOptions);
+    static createDefaultAgent(baseUrl: string, defaultProxy?: ProxyOption): HttpProxyAgent<`http://${string}:${number}`> | HttpsProxyAgent<`https://${string}:${number}`> | undefined;
+    static create(options: GitHubCreateOptions): Promise<GitHubApi>;
+    static defaultBranch(owner: string, repo: string, octokit: OctokitType): Promise<string>;
+    private graphqlRequest;
+    /**
+     * Iterate through merged pull requests with a max number of results scanned.
+     *
+     * @param {string} targetBranch Target branch of commit.
+     * @param {string} status The status of the pull request. Defaults to 'MERGED'.
+     * @param {number} maxResults Limit the number of results searched. Defaults to
+     *   unlimited.
+     * @param {boolean} includeFiles Whether to fetch the list of files included in
+     *   the pull request. Defaults to `true`.
+     * @yields {PullRequest}
+     * @throws {GitHubAPIError} on an API error
+     */
+    pullRequestIterator(targetBranch: string, status?: 'OPEN' | 'CLOSED' | 'MERGED', maxResults?: number, includeFiles?: boolean): AsyncGenerator<PullRequest, void, void>;
+    /**
+     * Helper implementation of pullRequestIterator that includes files via
+     * the graphQL API.
+     *
+     * @param {string} targetBranch The base branch of the pull request
+     * @param {string} status The status of the pull request
+     * @param {number} maxResults Limit the number of results searched
+     */
+    private pullRequestIteratorWithFiles;
+    /**
+     * Helper implementation of pullRequestIterator that excludes files
+     * via the REST API.
+     *
+     * @param {string} targetBranch The base branch of the pull request
+     * @param {string} status The status of the pull request
+     * @param {number} maxResults Limit the number of results searched
+     */
+    private pullRequestIteratorWithoutFiles;
+    /**
+     * Return a list of merged pull requests. The list is not guaranteed to be sorted
+     * by merged_at, but is generally most recent first.
+     *
+     * @param {string} targetBranch - Base branch of the pull request. Defaults to
+     *   the configured default branch.
+     * @param {number} page - Page of results. Defaults to 1.
+     * @param {number} perPage - Number of results per page. Defaults to 100.
+     * @returns {PullRequestHistory | null} - List of merged pull requests
+     * @throws {GitHubAPIError} on an API error
+     */
+    private pullRequestsGraphQL;
+    /**
+     * Iterate through releases with a max number of results scanned.
+     *
+     * @param {ReleaseIteratorOptions} options Query options
+     * @param {number} options.maxResults Limit the number of results scanned.
+     *   Defaults to unlimited.
+     * @yields {ScmRelease}
+     * @throws {GitHubAPIError} on an API error
+     */
+    releaseIterator(options?: ReleaseIteratorOptions): AsyncGenerator<ScmRelease, void, unknown>;
+    private releaseGraphQL;
+    createPullRequest: (pullRequest: PullRequest, targetBranch: string, options?: {
+        draft?: boolean | undefined;
+    } | undefined) => Promise<PullRequest>;
+    /**
+     * Fetch a pull request given the pull number
+     * @param {number} number The pull request number
+     * @returns {PullRequest}
+     */
+    getPullRequest: (number: number) => Promise<PullRequest>;
+    updatePullRequest: (number: number, title: string, body: string) => Promise<{
+        headBranchName: string;
+        baseBranchName: string;
+        number: number;
+        title: string;
+        body: string;
+        files: never[];
+        labels: string[];
+    }>;
+    /**
+     * Create a GitHub release
+     *
+     * @param {Release} release Release parameters
+     * @param {ScmReleaseOptions} options Release option parameters
+     * @throws {DuplicateReleaseError} if the release tag already exists
+     * @throws {GitHubAPIError} on other API errors
+     */
+    createRelease: (release: Release, options?: ScmReleaseOptions | undefined) => Promise<ScmRelease>;
+    /**
+     * Makes a comment on a issue/pull request.
+     *
+     * @param {string} comment - The body of the comment to post.
+     * @param {number} number - The issue or pull request number.
+     * @throws {GitHubAPIError} on an API error
+     */
+    commentOnIssue: (comment: string, number: number) => Promise<string>;
+    /**
+     * Removes labels from an issue/pull request.
+     *
+     * @param {string[]} labels The labels to remove.
+     * @param {number} number The issue/pull request number.
+     */
+    removeIssueLabels: (labels: string[], number: number) => Promise<void>;
+    /**
+     * Adds label to an issue/pull request.
+     *
+     * @param {string[]} labels The labels to add.
+     * @param {number} number The issue/pull request number.
+     */
+    addIssueLabels: (labels: string[], number: number) => Promise<void>;
+    /**
+     * Generate release notes from GitHub at tag
+     * @param {string} tagName Name of new release tag
+     * @param {string} targetCommitish Target commitish for new tag
+     * @param {string} previousTag Optional. Name of previous tag to analyze commits since
+     */
+    generateReleaseNotes(tagName: string, targetCommitish: string, previousTag?: string): Promise<string>;
+    /**
+     * Create a single file on a new branch based on an existing
+     * branch. This will force-push to that branch.
+     * @param {string} filename Filename with path in the repository
+     * @param {string} contents Contents of the file
+     * @param {string} newBranchName Name of the new branch
+     * @param {string} baseBranchName Name of the base branch (where
+     *   new branch is forked from)
+     * @returns {string} HTML URL of the new file
+     */
+    createFileOnNewBranch(filename: string, contents: string, newBranchName: string, baseBranchName: string): Promise<string>;
+    /**
+     * Fork a branch from a base branch.
+     */
+    private forkBranch;
+    /**
+     * Helper to fetch the SHA of a branch
+     */
+    private getBranchSha;
+    /**
+     * Helper to create a new branch from a given SHA.
+     */
+    private createNewBranch;
+    /**
+     * Helper to update branch SHA.
+     */
+    private updateBranchSha;
+}
+export declare const wrapAsync: <T extends any[], V>(fn: (...args: T) => Promise<V>, errorHandler?: ((e: Error) => void) | undefined) => (...args: T) => Promise<V>;
+export declare const sleepInMs: (ms: number) => Promise<unknown>;
+export {};