probot

constructor

constructor(event: WebhookEvent<Event>, octokit: any, log: Logger);

property id

id: string;

property isBot

readonly isBot: boolean;

• Returns a boolean if the actor on the event was a bot. {boolean}

property log

log: Logger;

• A logger with context about the event.

property name

name: WebhookEvents;

property octokit

octokit: any;

• An authenticated Octokit instance that can be used to make GitHub API requests in the context of the webhook event.

property payload

payload: WebhookEvent<K>;

method config

config: <T>(
    fileName: string,
    defaultConfig?: T,
    deepMergeOptions?: merge.Options
) => Promise<T | null>;

• Reads the app configuration from the given YAML file in the .github directory of the repository.

  For example, given a file named .github/config.yml:

  close: true
  comment: Check the specs on the rotary girder.

  Your app can read that file from the target repository:

  // Load config from .github/config.yml in the repository
  const config = await context.config('config.yml')
  
  if (config.close) {
    context.octokit.rest.issues.comment(context.issue({body: config.comment}))
    context.octokit.rest.issues.edit(context.issue({state: 'closed'}))
  }

  You can also use a defaultConfig object:

  // Load config from .github/config.yml in the repository and combine with default config
  const config = await context.config('config.yml', {comment: 'Make sure to check all the specs.'})
  
  if (config.close) {
    context.octokit.rest.issues.comment(context.issue({body: config.comment}));
    context.octokit.rest.issues.edit(context.issue({state: 'closed'}))
  }

  Config files can also specify a base that they extend. deepMergeOptions can be used to configure how the target config, extended base, and default configs are merged.

  For security reasons, configuration is only loaded from the repository's default branch, changes made in pull requests from different branches or forks are ignored.

  If you need more lower-level control over reading and merging configuration files, you can context.octokit.config.get(options), see https://github.com/probot/octokit-plugin-config.

  Parameter fileName

  Name of the YAML file in the .github directory

  Parameter defaultConfig

  An object of default config options

  Parameter deepMergeOptions

  Controls merging configs (from the [deepmerge](https://github.com/TehShrike/deepmerge) module) Configuration object read from the file

method issue

issue: <T>(
    object?: T
) => RepoResultType<Event> & { issue_number: RepoIssueNumberType<Event> } & T;

• Return the owner, repo, and issue_number params for making API requests against an issue. The object passed in will be merged with the repo params.

  const params = context.issue({body: 'Hello World!'})
  // Returns: {owner: 'username', repo: 'reponame', issue_number: 123, body: 'Hello World!'}

  Parameter object

  Params to be merged with the issue params.

method pullRequest

pullRequest: <T>(
    object?: T
) => RepoResultType<Event> & { pull_number: RepoIssueNumberType<Event> } & T;

• Return the owner, repo, and pull_number params for making API requests against a pull request. The object passed in will be merged with the repo params.

  const params = context.pullRequest({body: 'Hello World!'})
  // Returns: {owner: 'username', repo: 'reponame', pull_number: 123, body: 'Hello World!'}

  Parameter object

  Params to be merged with the pull request params.

method repo

repo: <T>(object?: T) => RepoResultType<Event> & T;

• Return the owner and repo params for making API requests against a repository.

  const params = context.repo({path: '.github/config.yml'})
  // Returns: {owner: 'username', repo: 'reponame', path: '.github/config.yml'}

  Parameter object

  Params to be merged with the repo params.

constructor

constructor(options?: Options);

property log

readonly log: Logger;

property on

on: Webhooks<SimplifiedObject>;

property onAny

onAny: Webhooks<SimplifiedObject>;

property onError

onError: Webhooks<SimplifiedObject>;

property version

static readonly version: string;

property version

readonly version: string;

property webhookPath

readonly webhookPath: string;

property webhooks

readonly webhooks: Webhooks<SimplifiedObject>;

method auth

auth: (installationId?: number | undefined) => Promise<ProbotOctokit>;

method defaults

static defaults: <S extends Constructor<any>>(
    this: S,
    defaults: Options
) => (new (...args: any[]) => { [x: string]: any }) & S;

method getNodeMiddleware

getNodeMiddleware: ({
    log,
    path,
}?: {
    log?: Logger | undefined;
    path?: string | undefined;
}) => Promise<ReturnType<typeof createNodeMiddleware>>;

method load

load: (
    appFn: ApplicationFunction | ApplicationFunction[],
    options?: ApplicationFunctionOptions
) => Promise<void>;

method ready

ready: () => Promise<this>;

method receive

receive: (event: WebhookEvent) => Promise<void>;

constructor

constructor(options?: ServerOptions);

property host

readonly host: string;

property port

readonly port: number;

property version

static readonly version: string;

property version

readonly version: string;

method addHandler

addHandler: (handler: Handler) => void;

method load

load: (appFn: ApplicationFunction) => Promise<void>;

method loadHandlerFactory

loadHandlerFactory: (appFn: HandlerFactory) => Promise<void>;

method start

start: () => Promise<HttpServer>;

method stop

stop: () => Promise<void>;

property appId

appId?: number | string | undefined;

property baseUrl

baseUrl?: string | undefined;

property githubToken

githubToken?: string | undefined;

property host

host?: string | undefined;

property log

log?: Logger | undefined;

property logFormat

logFormat?: 'json' | 'pretty' | undefined;

property logLevel

logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal' | undefined;

property logLevelInString

logLevelInString?: boolean | undefined;

property logMessageKey

logMessageKey?: string | undefined;

property Octokit

Octokit?: typeof ProbotOctokit | undefined;

property port

port?: number | undefined;

property privateKey

privateKey?: string | undefined;

property redisConfig

redisConfig?: RedisOptions | string | undefined;

property request

request?: RequestRequestOptions | undefined;

property secret

secret?: string | undefined;

property sentryDsn

sentryDsn?: string | undefined;

property server

server?: Server | undefined;

property webhookPath

webhookPath?: string | undefined;

property webhookProxy

webhookProxy?: string | undefined;