@nodeswork/kiws/dist/providers/koa.service.js

Koa-based Injectable Web Service

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
Object.defineProperty(exports, "__esModule", { value: true });
const _ = require("underscore");
const Koa = require("koa");
const Router = require("koa-router");
const logger = require("@nodeswork/logger");
const service_1 = require("../service");
const module_service_1 = require("./module.service");
const injection_1 = require("../injection");
const middleware_1 = require("../middleware");
const handler_1 = require("../handler");
const input_1 = require("../input");
const LOG = logger.getLogger();
let KoaService = class KoaService {
    constructor(modules, middlewareProviders, handlers, inputProviders) {
        this.modules = modules;
        this.middlewareProviders = middlewareProviders;
        this.handlers = handlers;
        this.inputProviders = inputProviders;
        this.app = new Koa();
        this.router = new Router();
        const data = _.map(this.middlewareProviders, (provider) => {
            return {
                provider,
                middlewares: provider.$getMiddlewares(),
            };
        });
        this.registerPreMiddlewares(data);
        this.registerHandlers();
        this.app
            .use(this.router.routes())
            .use(this.router.allowedMethods());
        this.registerPostMiddlewares(data);
    }
    registerHandlers() {
        const self = this;
        function register(handlerName, endpoint) {
            _.defaults(endpoint, { method: 'GET' });
            self.router.register(endpoint.path, _.flatten([endpoint.method]), async (ctx) => {
                const rawInputs = _.flatten(_.map(self.inputProviders, (provider) => provider.$generateInputs(ctx)));
                const inputs = _.map(rawInputs, (rawInput) => {
                    const input = injection_1.beanProvider.getBean(rawInput.type);
                    _.extend(input, rawInput.data);
                    return input;
                });
                const handler = injection_1.beanProvider.getBean(handlerName, inputs);
                ctx.body = await handler[endpoint.name](ctx);
            });
            LOG.info('Register router path', endpoint);
        }
        for (const handler of this.handlers) {
            const endpoints = handler.$getEndpoints();
            for (const endpoint of endpoints) {
                register(handler.constructor.name, endpoint);
            }
        }
    }
    registerPreMiddlewares(data) {
        for (const { provider, middlewares } of data) {
            for (const middleware of middlewares) {
                if (middleware.target === middleware_1.MIDDLEWARE_TARGET_APP && !middleware.later) {
                    this.app.use(middleware.fn.bind(provider));
                    LOG.info('Use App middleware', _.pick(middleware, 'provider', 'name'));
                }
            }
        }
        for (const { provider, middlewares } of data) {
            for (const middleware of middlewares) {
                if (middleware.target === middleware_1.MIDDLEWARE_TARGET_ROUTER && !middleware.later) {
                    this.router.use(middleware.fn.bind(provider));
                    LOG.info('Use Router middleware', _.pick(middleware, 'provider', 'name'));
                }
            }
        }
    }
    registerPostMiddlewares(data) {
        for (const { provider, middlewares } of data) {
            for (const middleware of middlewares) {
                if (middleware.target === middleware_1.MIDDLEWARE_TARGET_ROUTER && middleware.later) {
                    this.router.use(middleware.fn.bind(provider));
                    LOG.info('Use Router middleware', _.pick(middleware, 'provider', 'name'));
                }
            }
        }
        for (const { provider, middlewares } of data) {
            for (const middleware of middlewares) {
                if (middleware.target === middleware_1.MIDDLEWARE_TARGET_APP && middleware.later) {
                    this.app.use(middleware.fn.bind(provider));
                    LOG.info('Use App middleware', _.pick(middleware, 'provider', 'name'));
                }
            }
        }
    }
};
KoaService = __decorate([
    service_1.Service(),
    __param(1, injection_1.Token(middleware_1.MIDDLEWARE)),
    __param(2, injection_1.Token(handler_1.HANDLER)),
    __param(3, injection_1.Token(input_1.INPUT)),
    __metadata("design:paramtypes", [module_service_1.ModuleService, Array, Array, Array])
], KoaService);
exports.KoaService = KoaService;

//# sourceMappingURL=koa.service.js.map