@plumjs/plumier/lib/application.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const cors_1 = tslib_1.__importDefault(require("@koa/cors"));
const core_1 = require("@plumjs/core");
const validator_1 = require("@plumjs/validator");
const debug_1 = tslib_1.__importDefault(require("debug"));
const fs_1 = require("fs");
const koa_1 = tslib_1.__importDefault(require("koa"));
const koa_bodyparser_1 = tslib_1.__importDefault(require("koa-bodyparser"));
const path_1 = require("path");
const binder_1 = require("./binder");
const router_1 = require("./router");
const log = debug_1.default("plum:app");
/* ------------------------------------------------------------------------------- */
/* ----------------------------------- HELPERS ----------------------------------- */
/* ------------------------------------------------------------------------------- */
function extractDecorators(route) {
    const classDecorator = route.controller.decorators.filter(x => x.name == "Middleware");
    const methodDecorator = route.action.decorators.filter(x => x.name == "Middleware");
    const extract = (d) => d.map(x => x.value).flatten();
    return extract(classDecorator)
        .concat(extract(methodDecorator))
        .reverse();
}
exports.extractDecorators = extractDecorators;
/* ------------------------------------------------------------------------------- */
/* ------------------------------- INVOCATIONS ----------------------------------- */
/* ------------------------------------------------------------------------------- */
class MiddlewareInvocation {
    constructor(middleware, context, next) {
        this.middleware = middleware;
        this.context = context;
        this.next = next;
    }
    proceed() {
        return this.middleware.execute(this.next);
    }
}
exports.MiddlewareInvocation = MiddlewareInvocation;
class ActionInvocation {
    constructor(context) {
        this.context = context;
    }
    async proceed() {
        const { request, route, config } = this.context;
        const controller = config.dependencyResolver.resolve(route.controller.object);
        //bind parameters
        const parameters = binder_1.bindParameter(request, route.action, config.converters);
        //check validation
        if (config.validator) {
            const param = (i) => route.action.parameters[i];
            const validate = (value, i) => config.validator(value, param(i));
            const result = await Promise.all(parameters.map((value, index) => validate(value, index)));
            const issues = result.flatten();
            log(`[Action Invocation] Validation result ${core_1.b(issues)}`);
            if (issues.length > 0)
                throw new core_1.ValidationError(issues);
        }
        const result = controller[route.action.name].apply(controller, parameters);
        const awaitedResult = await Promise.resolve(result);
        const status = config.responseStatus && config.responseStatus[route.method] || 200;
        if (awaitedResult instanceof core_1.ActionResult) {
            awaitedResult.status = awaitedResult.status || status;
            log(`[Action Invocation] ActionResult value - Method: ${core_1.b(route.method)} Status config: ${core_1.b(config.responseStatus)} Status: ${core_1.b(result.status)} `);
            return awaitedResult;
        }
        else {
            log(`[Action Invocation] Raw value - Method: ${route.method} Status config: ${core_1.b(config.responseStatus)} Status: ${core_1.b(status)} `);
            return new core_1.ActionResult(awaitedResult, status);
        }
    }
}
exports.ActionInvocation = ActionInvocation;
function pipe(middleware, context, invocation) {
    return middleware.reverse().reduce((prev, cur) => new MiddlewareInvocation(cur, context, prev), invocation);
}
exports.pipe = pipe;
/* ------------------------------------------------------------------------------- */
/* -------------------------------- FACITLITIES ---------------------------------- */
/* ------------------------------------------------------------------------------- */
class ValidationMiddleware {
    async execute(invocation) {
        try {
            return await invocation.proceed();
        }
        catch (e) {
            if (e instanceof core_1.ValidationError) {
                return new core_1.ActionResult(e.issues, e.status);
            }
            else
                throw e;
        }
    }
}
/**
 * Preset configuration for building web api. This facility contains:
 *
 * body parser: koa-bodyparser
 *
 * cors: @koa/cors
 */
class WebApiFacility {
    constructor(opt) {
        this.opt = opt;
    }
    async setup(app) {
        app.koa.use(koa_bodyparser_1.default(this.opt && this.opt.bodyParser));
        app.koa.use(cors_1.default(this.opt && this.opt.cors));
        if (this.opt && this.opt.controller)
            app.set({ controller: this.opt.controller });
        app.set({
            validator: (value, meta) => validator_1.validate(value, meta.decorators, [meta.name])
        });
        app.use(new ValidationMiddleware());
    }
}
exports.WebApiFacility = WebApiFacility;
/**
 * Preset configuration for building restful style api. This facility contains:
 *
 * body parser: koa-bodyparser
 *
 * cors: @koa/cors
 *
 * default response status: { get: 200, post: 201, put: 204, delete: 204 }
 */
class RestfulApiFacility extends WebApiFacility {
    async setup(app) {
        super.setup(app);
        app.set({ responseStatus: { post: 201, put: 204, delete: 204 } });
    }
}
exports.RestfulApiFacility = RestfulApiFacility;
/* ------------------------------------------------------------------------------- */
/* --------------------------- MAIN APPLICATION ---------------------------------- */
/* ------------------------------------------------------------------------------- */
async function requestHandler(ctx) {
    const controllerMiddleware = extractDecorators(ctx.route);
    const pipeline = pipe(controllerMiddleware, ctx, new ActionInvocation(ctx));
    const result = await pipeline.proceed();
    result.execute(ctx);
    log(`[Request Handler] ${core_1.b(ctx.path)} -> ${core_1.b(ctx.route.controller.name)}.${core_1.b(ctx.route.action.name)}`);
    log(`[Request Handler] Request Query: ${core_1.b(ctx.query)}`);
    log(`[Request Handler] Request Header: ${core_1.b(ctx.headers)}`);
    log(`[Request Handler] Request Body: ${core_1.b(result.body)}`);
}
class Plumier {
    constructor() {
        this.koa = new koa_1.default();
        this.config = Object.assign({}, core_1.DefaultConfiguration, { middleware: [], facilities: [] });
    }
    use(option) {
        if (typeof option === "function") {
            this.koa.use(option);
        }
        else {
            this.koa.use(core_1.MiddlewareUtil.toKoa(option));
        }
        return this;
    }
    set(config) {
        if (core_1.hasKeyOf(config, "setup"))
            this.config.facilities.push(config);
        else
            Object.assign(this.config, config);
        return this;
    }
    async initialize() {
        try {
            let routes = [];
            await Promise.all(this.config.facilities.map(x => x.setup(this)));
            const executionPath = path_1.dirname(module.parent.parent.filename);
            log(`[Initialize] execution path ${executionPath}`);
            if (typeof this.config.controller === "string") {
                const path = path_1.isAbsolute(this.config.controller) ? this.config.controller :
                    path_1.join(executionPath, this.config.controller);
                if (!fs_1.existsSync(path))
                    throw new Error(core_1.errorMessage.ControllerPathNotFound.format(path));
                routes = router_1.transformModule(path, [this.config.fileExtension]);
            }
            else if (Array.isArray(this.config.controller)) {
                log(`[Initialize] Controller ${core_1.b(this.config.controller)}`);
                routes = this.config.controller.map(x => router_1.transformController(x))
                    .flatten();
            }
            else {
                log(`[Initialize] Controller ${core_1.b(this.config.controller)}`);
                routes = router_1.transformController(this.config.controller);
            }
            log(`[Initialize] Routes ${core_1.b(routes)}`);
            if (this.config.mode === "debug")
                router_1.printAnalysis(router_1.analyzeRoutes(routes));
            this.koa.use(async (ctx, next) => {
                try {
                    await next();
                }
                catch (e) {
                    if (e instanceof core_1.HttpStatusError)
                        ctx.throw(e.status, e);
                    else
                        ctx.throw(500, e);
                }
            });
            this.koa.use(router_1.router(routes, this.config, requestHandler));
            return this.koa;
        }
        catch (e) {
            throw e;
        }
    }
}
exports.Plumier = Plumier;