@fangcha/backend-kit/lib/router/RouterPlugin.js

Backend Kit.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.RouterPlugin = void 0;
const tslib_1 = require("tslib");
const Koa = require("koa");
const koa_1 = require("@fangcha/logger/lib/koa");
const app_error_1 = require("@fangcha/app-error");
const logger_1 = require("@fangcha/logger");
const assert_1 = require("@fangcha/assert");
const session_1 = require("@fangcha/session");
const main_1 = require("../main");
const _RouterState_1 = require("./_RouterState");
const compose = require('koa-compose');
const bodyParser = require('koa-body');
class RouterPlugin {
    constructor(options) {
        assert_1.default.ok(!_RouterState_1._RouterState.locked, '_RouterState.locked must be false', 500);
        _RouterState_1._RouterState.locked = true;
        _RouterState_1._RouterState.routerApp = options.routerApp;
        this.options = options;
        this.updateOptions(options);
    }
    updateOptions(options) {
        options = Object.assign({}, options);
        delete options.routerApp;
        if (options.baseURL) {
            session_1._SessionApp.setBaseURL(options.baseURL);
        }
        assert_1.default.ok(!(options.jwtProtocol && options.basicAuthProtocol), 'jwtProtocol and basicAuthProtocol can only pass one', 500);
        if (options.jwtProtocol) {
            session_1._SessionApp.setJWTProtocol(options.jwtProtocol);
        }
        if (options.basicAuthProtocol) {
            _RouterState_1._RouterState.routerApp.updateParams({
                useBasicAuth: true,
            });
            session_1._SessionApp.basicAuthProtocol = options.basicAuthProtocol;
        }
        Object.assign(this.options, options);
    }
    appDidLoad(app) {
        const options = this.options;
        const koaApp = new Koa();
        const onRequestError = options.onRequestError ||
            ((err, ctx) => {
                console.error(err);
                if (ctx.status >= 500) {
                    const session = ctx.session;
                    main_1._FangchaState.botProxy.notifyApiError({
                        api: ctx.path || '',
                        errorMsg: err.message,
                        method: (ctx.method || '').toUpperCase(),
                        statusCode: ctx.status,
                        user: session.curUserStr(),
                        ipAddress: session.realIP,
                        duration: ctx.duration,
                        reqid: session.reqid || '-',
                        referer: ctx.headers.referer || '-',
                    });
                }
            });
        koaApp.on('error', onRequestError);
        const routerApp = options.routerApp;
        for (const plugin of app.plugins) {
            const specDocItems = plugin.specDocItems || [];
            specDocItems.forEach((item) => {
                routerApp.addDocItem(item);
            });
        }
        const codeVersion = process.env.CODE_VERSION || 'Unknown';
        const writeLogMiddlewareBuilder = options.customWriteLogMiddlewareBuilder || new koa_1.WriteLogMiddlewareBuilder();
        if (options.jwtProtocol && !options.Session) {
            options.Session = session_1.FangchaAdminSession;
        }
        if (options.basicAuthProtocol && !options.Session) {
            options.Session = session_1.FangchaOpenSession;
        }
        const sessionClazz = options.Session || session_1.FangchaSession;
        koaApp.use(compose([
            ...routerApp.getMiddlewaresBeforeInit(),
            (ctx, next) => tslib_1.__awaiter(this, void 0, void 0, function* () {
                ctx.set('x-code-version', codeVersion);
                ctx.session = new sessionClazz(ctx);
                ctx.logger = ctx.session.logger;
                yield next();
            }),
            writeLogMiddlewareBuilder.build(),
            (ctx, next) => tslib_1.__awaiter(this, void 0, void 0, function* () {
                const bodyParserOptions = options.bodyParserOptions || {};
                const parser = bodyParser(Object.assign({ multipart: true }, bodyParserOptions));
                try {
                    yield parser(ctx, () => { });
                }
                catch (e) {
                    console.error(e);
                    throw new app_error_1.default(`JSON parse error. ${e.message}`, 400);
                }
                yield next();
            }),
            ...routerApp.getPreHandleMiddlewares(),
            // 暴露公开 api
            routerApp.makePublicRouterMiddleware(),
            (ctx, next) => tslib_1.__awaiter(this, void 0, void 0, function* () {
                const handleAuth = options.handleAuth ||
                    ((ctx) => tslib_1.__awaiter(this, void 0, void 0, function* () {
                        const session = ctx.session;
                        yield session.auth();
                    }));
                yield handleAuth(ctx);
                yield next();
            }),
            routerApp.makePrivateRouterMiddleware(),
        ]));
        const onKoaAppLaunched = options.onKoaAppLaunched ||
            (() => {
                // _FangchaState.botProxy.notify(`[${_FangchaState.tags.join(', ')}] App launched.`)
                logger_1.logger.info(`[${main_1._FangchaState.env}] Backend service listening on port ${options.backendPort}!`);
            });
        const server = koaApp.listen(options.backendPort, () => {
            onKoaAppLaunched();
        });
        if (options.serverTimeout) {
            server.setTimeout(options.serverTimeout);
        }
    }
}
exports.RouterPlugin = RouterPlugin;
//# sourceMappingURL=RouterPlugin.js.map