parka/dist/core/parka-app.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
require("reflect-metadata");
const injection_js_1 = require("injection-js");
const YAML = require("yamljs");
const express = require("express");
const logger = require("morgan");
const bodyParser = require("body-parser");
const cookieParser = require("cookie-parser");
const http = require("http");
const Promise = require("bluebird");
const knex = require("knex");
const objection_1 = require("objection");
const lodash_1 = require("lodash");
const winston = require("winston");
const logger_1 = require("./logger");
class ParkaApp {
    constructor(ConfigConstructor) {
        this.ConfigConstructor = ConfigConstructor;
        this.configFile = process.env.PARKA_CONFIG_FILE;
        process.nextTick(() => {
            ParkaApp.appInstance = this;
            this.parseAppConfig().then(() => {
                this.configureDatabaseConneciton();
                this.configureExpressServer();
                lodash_1.forEach(this['__resourceClasses'], (ResourceClass) => {
                    this.registerResource(ResourceClass);
                });
                this.onBeforeApplicationStart();
                this.configureGlobalErrorHandling();
                this.configureInjector();
                this.start();
            });
        });
    }
    onBeforeApplicationStart() {
    }
    registerResource(ResourceClass) {
        this.registerGetRoutes(ResourceClass);
        this.registerPostRoutes(ResourceClass);
        this.registerPutRoutes(ResourceClass);
        this.registerDeleteRoutes(ResourceClass);
    }
    registerDeleteRoutes(ResourceClass) {
        let deleteMethods = ResourceClass.__delete;
        if (typeof deleteMethods !== 'undefined') {
            deleteMethods.forEach((deleteMethod) => {
                this.expressApp.delete(this.getPath(ResourceClass, deleteMethod), (req, res) => {
                    let resource = new ResourceClass(...this.getDiArgs(ResourceClass));
                    resource.req = req;
                    resource.res = res;
                    let paramList = this.getParamList(ResourceClass, deleteMethod.methodName, req);
                    Promise.resolve(resource[deleteMethod.methodName].apply(resource, paramList)).then((returnValue) => {
                        res.json(returnValue);
                    }).catch((err) => res.status(err.statusCode || 500).json(err));
                });
            });
        }
    }
    registerPutRoutes(ResourceClass) {
        let putMethods = ResourceClass.__put;
        if (typeof putMethods !== 'undefined') {
            putMethods.forEach((putMethod) => {
                this.expressApp.put(this.getPath(ResourceClass, putMethod), (req, res) => {
                    let resource = new ResourceClass(...this.getDiArgs(ResourceClass));
                    resource.req = req;
                    resource.res = res;
                    let paramList = this.getParamList(ResourceClass, putMethod.methodName, req);
                    Promise.resolve(resource[putMethod.methodName].apply(resource, paramList)).then((returnValue) => {
                        res.json(returnValue);
                    }).catch((err) => res.status(err.statusCode || 500).json(err));
                });
            });
        }
    }
    registerPostRoutes(ResourceClass) {
        let postMethods = ResourceClass.__post;
        if (typeof postMethods !== 'undefined') {
            postMethods.forEach((postMethod) => {
                this.expressApp.post(this.getPath(ResourceClass, postMethod), (req, res) => {
                    let resource = new ResourceClass(...this.getDiArgs(ResourceClass));
                    resource.req = req;
                    resource.res = res;
                    let paramList = this.getParamList(ResourceClass, postMethod.methodName, req);
                    Promise.resolve(resource[postMethod.methodName].apply(resource, paramList)).then((returnValue) => {
                        res.json(returnValue);
                    }).catch((err) => res.status(err.statusCode || 500).json(err));
                });
            });
        }
    }
    registerGetRoutes(ResourceClass) {
        let getMethods = ResourceClass.__get;
        if (typeof getMethods !== 'undefined') {
            getMethods.forEach((getMethod) => {
                this.expressApp.get(this.getPath(ResourceClass, getMethod), (req, res) => {
                    let resource = new ResourceClass(...this.getDiArgs(ResourceClass));
                    resource.req = req;
                    resource.res = res;
                    let paramList = this.getParamList(ResourceClass, getMethod.methodName, req);
                    Promise.resolve(resource[getMethod.methodName].apply(resource, paramList)).then((returnValue) => {
                        res.json(returnValue);
                    }).catch((err) => res.status(err.statusCode || 500).json(err));
                });
            });
        }
    }
    getDiArgs(injectable) {
        const paramTypes = Reflect.getMetadata('design:paramtypes', injectable);
        return lodash_1.map(paramTypes, (param) => ParkaApp.appInstance['__injector'].get(param));
    }
    getParamList(ResourceClass, methodName, req) {
        if (typeof ResourceClass.prototype[methodName].__params !== 'undefined') {
            return ResourceClass.prototype[methodName].__params.map((paramDef) => {
                if (paramDef.paramType === 'PATH_PARAM') {
                    return req.params[paramDef.paramName];
                }
                else if (paramDef.paramType === 'QUERY_PARAM') {
                    return req.query[paramDef.paramName];
                }
                else if (paramDef.paramType === 'REQUEST_BODY') {
                    let constructedModel = this.constructCorrectType(req, paramDef);
                    constructedModel.$validate();
                    return constructedModel;
                }
            });
        }
        else {
            return [];
        }
    }
    constructCorrectType(req, paramDef) {
        if (typeof paramDef.constructor !== 'undefined') {
            if (paramDef.isArray === true) {
                return req.body.map((item) => {
                    return paramDef.constructor.fromJson(item);
                });
            }
            else {
                return paramDef.constructor.fromJson(req.body);
            }
        }
        else {
            return req.body;
        }
    }
    getPath(ResourceClass, getMethod) {
        let path = [];
        if (this.config.routing && this.config.routing.prefix) {
            path.push(this.config.routing.prefix);
        }
        path.push(ResourceClass.__path);
        let methodPath = ResourceClass.prototype[getMethod.methodName].__path;
        if (typeof methodPath !== 'undefined') {
            path.push(methodPath);
        }
        return path.join('');
    }
    start() {
        let server = http.createServer(this.expressApp);
        server.listen(this.config.port, this.config.host, () => {
            console.log('server listening at ', server.address().address + ':' + server.address().port);
        });
    }
    parseAppConfig() {
        let configFileContents = YAML.load(this.configFile);
        this.config = new this.ConfigConstructor(configFileContents);
        return Promise.resolve(this.config.configureApplication)
            .then(() => {
            this['__providers'].push({
                provide: this.ConfigConstructor,
                useValue: this.config
            });
        });
    }
    configureExpressServer() {
        let app = express();
        const winstonLogger = this.configureLogger();
        this['__providers'].push({ provide: logger_1.Logger, useValue: winstonLogger });
        app.use(logger('combined', { immediate: true, stream: { write: (message) => winstonLogger.info(message) } }));
        app.use(bodyParser.json());
        app.use(bodyParser.urlencoded({ extended: false }));
        app.use(cookieParser());
        app.get('/', (req, res) => {
            res.send('it worked');
        });
        this.expressApp = app;
    }
    configureLogger() {
        const logger = new winston.Logger({
            exitOnError: false
        });
        if (this.config.logger && this.config.logger.transports) {
            lodash_1.forEach(this.config.logger.transports, (options, transportName) => {
                logger.add(winston.transports[transportName], options);
            });
        }
        else {
            logger.add(winston.transports.Console, {
                level: 'debug',
                handleExceptions: true,
                json: false,
                colorize: true,
                timestamp: true
            });
        }
        return logger;
    }
    configureInjector() {
        this.__injector = injection_js_1.ReflectiveInjector.resolveAndCreate(this['__providers']);
    }
    configureGlobalErrorHandling() {
        // Handle non matched routes
        this.expressApp.use('*', (req, res, next) => {
            res.status(404)
                .json({
                status: 404,
                message: 'Not Found',
                stacktrace: this.getStacktrace()
            });
        });
        this.expressApp.use((err, req, res, next) => {
            if (err) {
                console.error(err.stack);
            }
            // if (err instanceof ValidationError === true) {
            if (typeof err.statusCode === 'number' && typeof err.data !== 'undefined') {
                res.status(err.statusCode).json(err);
            }
            else {
                res.status(500)
                    .json({
                    status: 500,
                    message: err.message,
                    stacktrace: this.getStacktrace(err)
                });
            }
        });
    }
    getStacktrace(err) {
        if (typeof err !== 'undefined') {
            return (this.config.includeStacktraceInResponse) ? err.stack : null;
        }
        else {
            return (this.config.includeStacktraceInResponse) ? new Error().stack : null;
        }
    }
    configureDatabaseConneciton() {
        const conn = knex(this.config.db);
        objection_1.Model.knex(conn);
    }
}
exports.ParkaApp = ParkaApp;
//# sourceMappingURL=parka-app.js.map