mirror of
https://github.com/zhigang1992/probot.github.io.git
synced 2026-01-12 22:49:53 +08:00
320 lines
14 KiB
HTML
320 lines
14 KiB
HTML
<!DOCTYPE html>
|
|
<html lang="en">
|
|
<head>
|
|
<meta charset="utf-8">
|
|
<meta name="viewport" content="width=device-width,initial-scale=1">
|
|
<title>application.js - Documentation</title>
|
|
|
|
<script src="scripts/prettify/prettify.js"></script>
|
|
<script src="scripts/prettify/lang-css.js"></script>
|
|
<!--[if lt IE 9]>
|
|
<script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>
|
|
<![endif]-->
|
|
<link type="text/css" rel="stylesheet" href="https://code.ionicframework.com/ionicons/2.0.1/css/ionicons.min.css">
|
|
<link type="text/css" rel="stylesheet" href="styles/prettify-tomorrow.css">
|
|
<link type="text/css" rel="stylesheet" href="styles/jsdoc-default.css">
|
|
</head>
|
|
<body>
|
|
|
|
<input type="checkbox" id="nav-trigger" class="nav-trigger" />
|
|
<label for="nav-trigger" class="navicon-button x">
|
|
<div class="navicon"></div>
|
|
</label>
|
|
|
|
<label for="nav-trigger" class="overlay"></label>
|
|
|
|
<nav>
|
|
<li class="nav-link nav-home-link"><a href="index.html">Home</a></li><li class="nav-heading"><a href="global.html">Globals</a></li><li class="nav-item"><span class="nav-item-type type-member">M</span><span class="nav-item-name"><a href="global.html#Application">Application</a></span></li><li class="nav-item"><span class="nav-item-type type-member">M</span><span class="nav-item-name"><a href="global.html#Context">Context</a></span></li><li class="nav-item"><span class="nav-item-type type-function">F</span><span class="nav-item-name"><a href="global.html#get">get</a></span></li>
|
|
</nav>
|
|
|
|
<div id="main">
|
|
|
|
<h1 class="page-title">application.js</h1>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<section>
|
|
<article>
|
|
<pre class="prettyprint source linenums"><code>"use strict";
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};
|
|
var __generator = (this && this.__generator) || function (thisArg, body) {
|
|
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
|
|
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
|
function verb(n) { return function (v) { return step([n, v]); }; }
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while (_) try {
|
|
if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [0, t.value];
|
|
switch (op[0]) {
|
|
case 0: case 1: t = op; break;
|
|
case 4: _.label++; return { value: op[1], done: false };
|
|
case 5: _.label++; y = op[1]; op = [0]; continue;
|
|
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
|
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
|
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
|
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop(); continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
|
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var express = require("express");
|
|
var promise_events_1 = require("promise-events");
|
|
var context_1 = require("./context");
|
|
var github_1 = require("./github");
|
|
var logger_1 = require("./logger");
|
|
var wrap_logger_1 = require("./wrap-logger");
|
|
// Some events can't get an authenticated client (#382):
|
|
function isUnauthenticatedEvent(context) {
|
|
return !context.payload.installation ||
|
|
(context.event === 'installation' && context.payload.action === 'deleted');
|
|
}
|
|
/**
|
|
* The `app` parameter available to apps
|
|
*
|
|
* @property {logger} log - A logger
|
|
*/
|
|
var Application = /** @class */ (function () {
|
|
function Application(options) {
|
|
var opts = options || {};
|
|
this.events = new promise_events_1.EventEmitter();
|
|
this.log = wrap_logger_1.wrapLogger(logger_1.logger, logger_1.logger);
|
|
this.app = opts.app;
|
|
this.cache = opts.cache;
|
|
this.catchErrors = opts.catchErrors;
|
|
this.router = opts.router || express.Router(); // you can do this?
|
|
}
|
|
Application.prototype.receive = function (event) {
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
return __generator(this, function (_a) {
|
|
return [2 /*return*/, Promise.all([
|
|
this.events.emit('*', event),
|
|
this.events.emit(event.event, event),
|
|
this.events.emit(event.event + "." + event.payload.action, event),
|
|
])];
|
|
});
|
|
});
|
|
};
|
|
/**
|
|
* Get an {@link http://expressjs.com|express} router that can be used to
|
|
* expose HTTP endpoints
|
|
*
|
|
* @example
|
|
* module.exports = app => {
|
|
* // Get an express router to expose new HTTP endpoints
|
|
* const route = app.route('/my-app');
|
|
*
|
|
* // Use any middleware
|
|
* route.use(require('express').static(__dirname + '/public'));
|
|
*
|
|
* // Add a new route
|
|
* route.get('/hello-world', (req, res) => {
|
|
* res.end('Hello World');
|
|
* });
|
|
* };
|
|
*
|
|
* @param {string} path - the prefix for the routes
|
|
* @returns {@link http://expressjs.com/en/4x/api.html#router|express.Router}
|
|
*/
|
|
Application.prototype.route = function (path) {
|
|
if (path) {
|
|
var router = express.Router();
|
|
this.router.use(path, router);
|
|
return router;
|
|
}
|
|
else {
|
|
return this.router;
|
|
}
|
|
};
|
|
/**
|
|
* Listen for [GitHub webhooks](https://developer.github.com/webhooks/),
|
|
* which are fired for almost every significant action that users take on
|
|
* GitHub.
|
|
*
|
|
* @param {string} event - the name of the [GitHub webhook
|
|
* event](https://developer.github.com/webhooks/#events). Most events also
|
|
* include an "action". For example, the * [`issues`](
|
|
* https://developer.github.com/v3/activity/events/types/#issuesevent)
|
|
* event has actions of `assigned`, `unassigned`, `labeled`, `unlabeled`,
|
|
* `opened`, `edited`, `milestoned`, `demilestoned`, `closed`, and `reopened`.
|
|
* Often, your bot will only care about one type of action, so you can append
|
|
* it to the event name with a `.`, like `issues.closed`.
|
|
*
|
|
* @param {Application~webhookCallback} callback - a function to call when the
|
|
* webhook is received.
|
|
*
|
|
* @example
|
|
*
|
|
* app.on('push', context => {
|
|
* // Code was just pushed.
|
|
* });
|
|
*
|
|
* app.on('issues.opened', context => {
|
|
* // An issue was just opened.
|
|
* });
|
|
*/
|
|
Application.prototype.on = function (eventName, callback) {
|
|
var _this = this;
|
|
if (typeof eventName === 'string') {
|
|
return this.events.on(eventName, function (event) { return __awaiter(_this, void 0, void 0, function () {
|
|
var log, github, context, err_1;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
log = this.log.child({ name: 'event', id: event.id });
|
|
_a.label = 1;
|
|
case 1:
|
|
_a.trys.push([1, 7, , 8]);
|
|
github = void 0;
|
|
if (!isUnauthenticatedEvent(event)) return [3 /*break*/, 3];
|
|
return [4 /*yield*/, this.auth()];
|
|
case 2:
|
|
github = _a.sent();
|
|
log.debug('`context.github` is unauthenticated. See https://probot.github.io/docs/github-api/#unauthenticated-events');
|
|
return [3 /*break*/, 5];
|
|
case 3: return [4 /*yield*/, this.auth(event.payload.installation.id, log)];
|
|
case 4:
|
|
github = _a.sent();
|
|
_a.label = 5;
|
|
case 5:
|
|
context = new context_1.Context(event, github, log);
|
|
return [4 /*yield*/, callback(context)];
|
|
case 6:
|
|
_a.sent();
|
|
return [3 /*break*/, 8];
|
|
case 7:
|
|
err_1 = _a.sent();
|
|
log.error({ err: err_1, event: event });
|
|
if (!this.catchErrors) {
|
|
throw err_1;
|
|
}
|
|
return [3 /*break*/, 8];
|
|
case 8: return [2 /*return*/];
|
|
}
|
|
});
|
|
}); });
|
|
}
|
|
else {
|
|
eventName.forEach(function (e) { return _this.on(e, callback); });
|
|
}
|
|
};
|
|
/**
|
|
* Authenticate and get a GitHub client that can be used to make API calls.
|
|
*
|
|
* You'll probably want to use `context.github` instead.
|
|
*
|
|
* **Note**: `app.auth` is asynchronous, so it needs to be prefixed with a
|
|
* [`await`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await)
|
|
* to wait for the magic to happen.
|
|
*
|
|
* @example
|
|
*
|
|
* module.exports = (app) => {
|
|
* app.on('issues.opened', async context => {
|
|
* const github = await app.auth();
|
|
* });
|
|
* };
|
|
*
|
|
* @param {number} [id] - ID of the installation, which can be extracted from
|
|
* `context.payload.installation.id`. If called without this parameter, the
|
|
* client wil authenticate [as the app](https://developer.github.com/apps/building-integrations/setting-up-and-registering-github-apps/about-authentication-options-for-github-apps/#authenticating-as-a-github-app)
|
|
* instead of as a specific installation, which means it can only be used for
|
|
* [app APIs](https://developer.github.com/v3/apps/).
|
|
*
|
|
* @returns {Promise<github>} - An authenticated GitHub API client
|
|
* @private
|
|
*/
|
|
Application.prototype.auth = function (id, log) {
|
|
if (log === void 0) { log = this.log; }
|
|
return __awaiter(this, void 0, void 0, function () {
|
|
var _this = this;
|
|
var github, res;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
github = github_1.GitHubAPI({
|
|
baseUrl: process.env.GHE_HOST && "https://" + process.env.GHE_HOST + "/api/v3",
|
|
debug: process.env.LOG_LEVEL === 'trace',
|
|
logger: log.child({ name: 'github', installation: String(id) })
|
|
});
|
|
if (!id) return [3 /*break*/, 2];
|
|
return [4 /*yield*/, this.cache.wrap("app:" + id + ":token", function () {
|
|
log.trace("creating token for installation");
|
|
github.authenticate({ type: 'app', token: _this.app() });
|
|
return github.apps.createInstallationToken({ installation_id: String(id) });
|
|
}, { ttl: 60 * 59 })]; // Cache for 1 minute less than GitHub expiry
|
|
case 1:
|
|
res = _a.sent() // Cache for 1 minute less than GitHub expiry
|
|
;
|
|
github.authenticate({ type: 'token', token: res.data.token });
|
|
return [3 /*break*/, 3];
|
|
case 2:
|
|
github.authenticate({ type: 'app', token: this.app() });
|
|
_a.label = 3;
|
|
case 3: return [2 /*return*/, github];
|
|
}
|
|
});
|
|
});
|
|
};
|
|
return Application;
|
|
}());
|
|
exports.Application = Application;
|
|
/**
|
|
* Do the thing
|
|
* @callback Application~webhookCallback
|
|
* @param {Context} context - the context of the event that was triggered,
|
|
* including `context.payload`, and helpers for extracting information from
|
|
* the payload, which can be passed to GitHub API calls.
|
|
*
|
|
* ```js
|
|
* module.exports = app => {
|
|
* app.on('push', context => {
|
|
* // Code was pushed to the repo, what should we do with it?
|
|
* app.log(context);
|
|
* });
|
|
* };
|
|
* ```
|
|
*/
|
|
/**
|
|
* A [GitHub webhook event](https://developer.github.com/webhooks/#events) payload
|
|
*
|
|
* @typedef payload
|
|
*/
|
|
//# sourceMappingURL=application.js.map</code></pre>
|
|
</article>
|
|
</section>
|
|
|
|
|
|
|
|
|
|
</div>
|
|
|
|
<br class="clear">
|
|
|
|
<footer>
|
|
Generated by <a href="https://github.com/jsdoc3/jsdoc">JSDoc 3.5.5</a> on Thu Jun 07 2018 21:35:41 GMT-0400 (EDT) using the Minami theme.
|
|
</footer>
|
|
|
|
<script>prettyPrint();</script>
|
|
<script src="scripts/linenumber.js"></script>
|
|
</body>
|
|
</html>
|