expresser/lib/app.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.App = void 0;
const utils_1 = require("./utils");
const EventEmitter = require("eventemitter3");
const express = require("express");
const fs = require("fs");
const http = require("http");
const https = require("https");
const jaul = require("jaul");
const logger = require("anyhow");
const path = require("path");
const setmeup = require("setmeup");
let settings;
class App {
    constructor() {
        this.events = new EventEmitter();
        this.on = (eventName, callback) => {
            this.events.on(eventName, callback);
        };
        this.once = (eventName, callback) => {
            this.events.on(eventName, callback);
        };
        this.off = (eventName, callback) => {
            this.events.off(eventName, callback);
        };
        this.init = (middlewares) => {
            let mw;
            if (settings.general.debug && logger.levels.indexOf("debug") < 0) {
                logger.levels.push("debug");
            }
            if (!logger.preprocessor) {
                logger.preprocessor = require("./logger").clean;
            }
            logger.errorStack = settings.logger.errorStack;
            this.expressApp = express();
            middlewares = middlewares || { append: [], prepend: [] };
            if (middlewares.prepend && !utils_1.isArray(middlewares.prepend)) {
                middlewares.prepend = [middlewares.prepend];
            }
            if (middlewares.append && !utils_1.isArray(middlewares.append)) {
                middlewares.append = [middlewares.append];
            }
            if (middlewares.prepend && middlewares.prepend.length > 0) {
                for (mw of middlewares.prepend) {
                    if (mw) {
                        this.expressApp.use(mw);
                        logger.debug("App.init", "Prepended middleware");
                    }
                }
            }
            this.expressApp.set("trust proxy", settings.app.trustProxy);
            this.expressApp.set("views", settings.app.viewPath);
            if (settings.app.viewEngine) {
                this.expressApp.set("view engine", settings.app.viewEngine);
                this.expressApp.set("view options", settings.app.viewOptions);
            }
            if (settings.app.bodyParser && settings.app.bodyParser.enabled) {
                try {
                    const midBodyParser = require("body-parser");
                    this.expressApp.use(midBodyParser.raw({ limit: settings.app.bodyParser.rawLimit, type: settings.app.bodyParser.rawTypes }));
                    this.expressApp.use(midBodyParser.json({ limit: settings.app.bodyParser.limit }));
                    this.expressApp.use(midBodyParser.text({ limit: settings.app.bodyParser.limit }));
                    this.expressApp.use(midBodyParser.urlencoded({ limit: settings.app.bodyParser.limit, extended: settings.app.bodyParser.extended }));
                }
                catch (ex) {
                    logger.warn("App.init", "Can't load 'body-parser' module.");
                }
            }
            if (settings.app.cookie && settings.app.cookie.enabled) {
                try {
                    const midCookieParser = require("cookie-parser");
                    this.expressApp.use(midCookieParser(settings.app.secret));
                }
                catch (ex) {
                    ex.friendlyMessage = "Can't load 'cookie-parser' module.";
                    logger.error("App.init", ex);
                }
            }
            if (settings.app.session && settings.app.session.enabled) {
                try {
                    const midSession = require("express-session");
                    const memoryStore = require("memorystore")(midSession);
                    this.expressApp.use(midSession({
                        store: new memoryStore({ checkPeriod: settings.app.session.checkPeriod }),
                        proxy: settings.app.session.proxy,
                        resave: settings.app.session.resave,
                        saveUninitialized: settings.app.session.saveUninitialized,
                        secret: settings.app.secret,
                        ttl: settings.app.session.maxAge * 1000,
                        cookie: {
                            secure: settings.app.session.secure,
                            httpOnly: settings.app.session.httpOnly,
                            maxAge: settings.app.session.maxAge * 1000
                        }
                    }));
                }
                catch (ex) {
                    ex.friendlyMessage = "Can't load 'express-session' and 'memorystore' modules.";
                    logger.error("App.init", ex);
                }
            }
            if (settings.app.compression && settings.app.compression.enabled) {
                try {
                    const midCompression = require("compression");
                    this.expressApp.use(midCompression());
                }
                catch (ex) {
                    ex.friendlyMessage = "Can't load 'compression' module.";
                    logger.error("App.init", ex);
                }
            }
            if (settings.app.publicPath) {
                this.expressApp.use(express.static(settings.app.publicPath));
            }
            if (middlewares.append && middlewares.append.length > 0) {
                for (mw of middlewares.append) {
                    if (mw) {
                        this.expressApp.use(mw);
                        logger.debug("App.init", "Appended middleware");
                    }
                }
            }
            if (settings.general.debug) {
                this.expressApp.use(function (req, res, next) {
                    const { method } = req;
                    const { url } = req;
                    const ip = jaul.network.getClientIP(req);
                    const msg = `Request from ${ip}`;
                    if (res) {
                        logger.debug("App", msg, method, url);
                    }
                    if (next) {
                        next();
                    }
                    return url;
                });
            }
            this.events.emit("init");
            this.start();
        };
        this.start = () => {
            if (this.server) {
                logger.warn("App.start", "Server is already running, abort start.");
                return this.server;
            }
            let serverRef;
            if (settings.app.ssl && settings.app.ssl.enabled && settings.app.ssl.keyFile && settings.app.ssl.certFile) {
                const sslKeyFile = jaul.io.getFilePath(settings.app.ssl.keyFile);
                const sslCertFile = jaul.io.getFilePath(settings.app.ssl.certFile);
                if (sslKeyFile && sslCertFile) {
                    const sslKey = fs.readFileSync(sslKeyFile, { encoding: settings.general.encoding });
                    const sslCert = fs.readFileSync(sslCertFile, { encoding: settings.general.encoding });
                    const sslOptions = { key: sslKey, cert: sslCert };
                    serverRef = https.createServer(sslOptions, this.expressApp);
                }
                else {
                    throw new Error("Invalid certificate filename, please check paths defined on settings.app.ssl.");
                }
            }
            else {
                serverRef = http.createServer(this.expressApp);
            }
            this.server = serverRef;
            let listenCb = () => {
                if (settings.app.ip) {
                    logger.info("App.start", settings.app.title, `Listening on ${settings.app.ip} port ${settings.app.port}`, `URL ${settings.app.url}`);
                }
                else {
                    logger.info("App.start", settings.app.title, `Listening on port ${settings.app.port}`, `URL ${settings.app.url}`);
                }
            };
            let listenError = (err) => {
                logger.error("App.start", "Can't start", err);
            };
            if (settings.app.ip) {
                serverRef.listen(settings.app.port, settings.app.ip, listenCb).on("error", listenError);
            }
            else {
                serverRef.listen(settings.app.port, listenCb).on("error", listenError);
            }
            serverRef.timeout = settings.app.timeout;
            this.events.emit("start");
            return this.server;
        };
        this.kill = () => {
            if (!this.server) {
                logger.warn("App.kill", "Server was not running");
                return;
            }
            try {
                this.server.close();
                this.server = null;
                this.events.emit("kill");
            }
            catch (ex) {
                logger.error("App.kill", ex);
            }
        };
        this.all = (...args) => {
            logger.debug("App.all", args[1], args[2]);
            return this.expressApp.all.apply(this.expressApp, args);
        };
        this.get = (...args) => {
            logger.debug("App.get", args[1], args[2]);
            return this.expressApp.get.apply(this.expressApp, args);
        };
        this.post = (...args) => {
            logger.debug("App.post", args[1], args[2]);
            return this.expressApp.post.apply(this.expressApp, args);
        };
        this.put = (...args) => {
            logger.debug("App.put", args[1], args[2]);
            return this.expressApp.put.apply(this.expressApp, args);
        };
        this.patch = (...args) => {
            logger.debug("App.patch", args[1], args[2]);
            return this.expressApp.patch.apply(this.expressApp, args);
        };
        this.delete = (...args) => {
            logger.debug("App.delete", args[1], args[2]);
            return this.expressApp.delete.apply(this.expressApp, args);
        };
        this.use = (...args) => {
            logger.debug("App.use", args[1], args[2]);
            return this.expressApp.use.apply(this.expressApp, args);
        };
        this.set = (...args) => {
            logger.debug("App.set", args[1], args[2]);
            return this.expressApp.set.apply(this.expressApp, args);
        };
        this.route = (reqPath) => {
            logger.debug("App.route", reqPath);
            return this.expressApp.route.apply(this.expressApp, reqPath);
        };
        this.renderView = (req, res, view, options, status) => {
            logger.debug("App.renderView", req.originalUrl, view, options);
            try {
                if (!options) {
                    options = {};
                }
                if (options.title == null) {
                    options.title = settings.app.title;
                }
                if (status) {
                    res.status(status);
                }
                res.render(view, options);
            }
            catch (ex) {
                logger.error("App.renderView", view, ex);
                this.renderError(req, res, ex);
            }
            if (settings.app.events.render) {
                this.events.emit("renderView", req, res, view, options, status);
            }
        };
        this.renderText = (req, res, text, status) => {
            logger.debug("App.renderText", req.originalUrl, text);
            try {
                if (text == null) {
                    logger.debug("App.renderText", "Called with empty text parameter");
                    text = "";
                }
                else if (!utils_1.isString(text)) {
                    text = text.toString();
                }
                if (status) {
                    res.status(status);
                }
                res.setHeader("content-type", "text/plain");
                res.send(text);
            }
            catch (ex) {
                logger.error("App.renderText", text, ex);
                this.renderError(req, res, ex);
            }
            if (settings.app.events.render) {
                this.events.emit("renderText", req, res, text, status);
            }
        };
        this.renderJson = (req, res, data, status) => {
            logger.debug("App.renderJson", req.originalUrl, data);
            if (utils_1.isString(data)) {
                try {
                    data = JSON.parse(data);
                }
                catch (ex) {
                    logger.error("App.renderJson", ex);
                    return this.renderError(req, res, ex, 500);
                }
            }
            var cleanJson = function (obj, depth) {
                if (depth >= settings.logger.maxDepth) {
                    return;
                }
                if (utils_1.isArray(obj)) {
                    return Array.from(obj).map((i) => cleanJson(i, depth + 1));
                }
                else if (utils_1.isObject(obj)) {
                    return (() => {
                        const result = [];
                        for (let k in obj) {
                            const v = obj[k];
                            if (utils_1.isFunction(v)) {
                                result.push(delete obj[k]);
                            }
                            else {
                                result.push(cleanJson(v, depth + 1));
                            }
                        }
                        return result;
                    })();
                }
            };
            cleanJson(data, 0);
            if (status) {
                res.status(status);
            }
            if (settings.app.allowOriginHeader) {
                res.setHeader("Access-Control-Allow-Origin", settings.app.allowOriginHeader);
            }
            res.json(data);
            if (settings.app.events.render) {
                this.events.emit("renderJson", req, res, data, status);
            }
        };
        this.renderImage = (req, res, filename, options) => {
            logger.debug("App.renderImage", req.originalUrl, filename, options);
            let mimetype = options ? options.mimetype : null;
            if (!mimetype) {
                let extname = path.extname(filename).toLowerCase().replace(".", "");
                if (extname == "jpg") {
                    extname = "jpeg";
                }
                mimetype = `image/${extname}`;
            }
            res.type(mimetype);
            res.sendFile(filename);
            if (settings.app.events.render) {
                this.events.emit("renderImage", req, res, filename, options);
            }
        };
        this.renderError = (req, res, error, status) => {
            let message;
            logger.debug("App.renderError", req.originalUrl, status, error);
            if (typeof error == "undefined" || error == null) {
                error = "Unknown error";
                logger.warn("App.renderError", "Called with null error");
            }
            if (status == null) {
                status = error.statusCode || error.status || error.code;
            }
            if (status == "ETIMEDOUT") {
                status = 408;
            }
            if (isNaN(status)) {
                status = 500;
            }
            else {
                status = parseInt(status);
            }
            try {
                if (error.error && !error.message && !error.error_description && !error.reason) {
                    error = error.error;
                }
                if (utils_1.isString(error)) {
                    message = { message: error };
                }
                else {
                    message = {};
                    message.message = error.message || error.error_description || error.description;
                    if (!message.message) {
                        message.message = error.toString();
                    }
                    if (error.friendlyMessage) {
                        message.friendlyMessage = error.friendlyMessage;
                    }
                    if (error.reason) {
                        message.reason = error.reason;
                    }
                    if (error.code) {
                        message.code = error.code;
                    }
                    else if (error.status) {
                        message.code = error.status;
                    }
                }
            }
            catch (ex) {
                logger.error("App.renderError", ex);
            }
            res.status(status).json(message);
            if (settings.app.events.render) {
                this.events.emit("renderError", req, res, error, status);
            }
        };
        if (!logger.isReady) {
            logger.setup();
        }
        setmeup.load(__dirname + "/../settings.default.json", { overwrite: false });
        settings = setmeup.settings;
    }
    static get Instance() {
        return this._instance || (this._instance = new this());
    }
    newInstance() {
        return new App();
    }
}
exports.App = App;
exports.default = App.Instance;