probot/lib/application.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Application = void 0;
const express_1 = require("express");
const lru_cache_1 = __importDefault(require("lru-cache"));
const deprecation_1 = require("deprecation");
const probot_octokit_1 = require("./octokit/probot-octokit");
const get_log_1 = require("./helpers/get-log");
const get_probot_octokit_with_defaults_1 = require("./octokit/get-probot-octokit-with-defaults");
const webhook_event_check_1 = require("./helpers/webhook-event-check");
const alias_log_1 = require("./helpers/alias-log");
const get_webhooks_1 = require("./octokit/get-webhooks");
const load_1 = require("./load");
const get_router_1 = require("./get-router");
const auth_1 = require("./auth");
/**
 * The `app` parameter available to `ApplicationFunction`s
 *
 * @property {logger} log - A logger
 */
class Application {
    constructor(options) {
        this.log = alias_log_1.aliasLog(options.log || get_log_1.getLog({ level: process.env.LOG_LEVEL }));
        this.log.warn(`[probot] "import { Application } from 'probot'" is deprecated. Use "import { Probot } from 'probot'" instead, the APIs are the same.`);
        const cache = options.cache ||
            new lru_cache_1.default({
                // cache max. 15000 tokens, that will use less than 10mb memory
                max: 15000,
                // Cache for 1 minute less than GitHub expiry
                maxAge: 1000 * 60 * 59,
            });
        const Octokit = get_probot_octokit_with_defaults_1.getProbotOctokitWithDefaults({
            githubToken: options.githubToken,
            Octokit: options.Octokit || probot_octokit_1.ProbotOctokit,
            appId: options.id,
            privateKey: options.privateKey,
            cache,
            log: this.log,
            redisConfig: options.redisConfig,
            throttleOptions: options.throttleOptions,
        });
        if (options.throttleOptions) {
            this.log.warn(`[probot] "new Application({ throttleOptions })" is deprecated. Use "new Application({Octokit: ProbotOctokit.defaults({ throttle }) })" instead`);
        }
        this.state = {
            cache,
            githubToken: options.githubToken,
            log: this.log,
            Octokit,
            octokit: options.octokit || new Octokit(),
            webhooks: {
                path: options.webhookPath,
                secret: options.secret,
            },
        };
        this.webhooks = options.webhooks || get_webhooks_1.getWebhooks(this.state);
        this.on = (eventNameOrNames, callback) => {
            // when an app subscribes to an event using `app.on(event, callback)`, Probot sends a request to `GET /app` and
            // verifies if the app is subscribed to the event and logs a warning if it is not.
            //
            // This feature will be moved out of Probot core as it has side effects and does not work in a stateless environment.
            webhook_event_check_1.webhookEventCheck(this.state, eventNameOrNames);
            if (eventNameOrNames === "*") {
                // @ts-ignore this workaround is only to surpress a warning. The `.on()` method will be deprecated soon anyway.
                return this.webhooks.onAny(callback);
            }
            return this.webhooks.on(eventNameOrNames, callback);
        };
        this.receive = this.webhooks.receive;
        const router = options.router || express_1.Router();
        // @ts-ignore
        this.load = load_1.load.bind(null, this, router);
        this.auth = auth_1.auth.bind(null, this.state);
        this.internalRouter = router;
    }
    /**
     * @deprecated "app.router" is deprecated, use "getRouter()" from the app function instead: "({ app, getRouter }) => { ... }"
     */
    get router() {
        this.log.warn(new deprecation_1.Deprecation(`[probot] "app.router" is deprecated, use "getRouter()" from the app function instead: "({ app, getRouter }) => { ... }"`));
        return this.internalRouter;
    }
    /**
     * Get an {@link http://expressjs.com|express} router that can be used to
     * expose HTTP endpoints
     *
     * ```
     * module.exports = ({ app, getRouter }) => {
     *   // Get an express router to expose new HTTP endpoints
     *   const router = getRouter('/my-app');
     *
     *   // Use any middleware
     *   router.use(require('express').static(__dirname + '/public'));
     *
     *   // Add a new route
     *   router.get('/hello-world', (req, res) => {
     *     res.end('Hello World');
     *   });
     * };
     * ```
     *
     * @param path - the prefix for the routes* @param path
     *
     * @deprecated "app.route()" is deprecated, use the "getRouter()" argument from the app function instead: "({ app, getRouter }) => { ... }"
     */
    route(path) {
        this.log.warn(new deprecation_1.Deprecation(`[probot] "app.route()" is deprecated, use the "getRouter()" argument from the app function instead: "({ app, getRouter }) => { ... }"`));
        return get_router_1.getRouter(this.internalRouter, path);
    }
}
exports.Application = Application;
//# sourceMappingURL=application.js.map