lynx-framework/dist/app.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.app = exports.getLanguageFromRequest = exports.isProduction = void 0;
var express = require("express");
var http = require("http");
var nunjucks = require("nunjucks");
var fs = require("fs");
require("reflect-metadata");
var typeorm_1 = require("typeorm");
var session = require("express-session");
var bodyParser = require("body-parser");
var multer = require("multer");
var cors = require("cors");
var moment = require("moment");
var flash = require("express-flash");
var apollo_server_express_1 = require("apollo-server-express");
var migration_entity_1 = require("./entities/migration.entity");
var error_controller_1 = require("./error.controller");
var expressGenerator = require("./express-generator");
var graphqlGenerator = require("./graphql/generator");
var setup_1 = require("./entities/setup");
var jsonwebtoken_1 = require("jsonwebtoken");
var translations = {};
var routes = {};
var logger_1 = require("./logger");
var api_response_wrapper_1 = require("./api-response-wrapper");
/**
 * Utility function to check if we are in the production environment.
 * @return true if the NODE_ENV is set to "production", false otherwise
 */
function isProduction() {
    return process.env.NODE_ENV === "production";
}
exports.isProduction = isProduction;
/**
 * Retrieve the preferred language from an express request, using the accepts-languages
 * header value.
 * @param req the express request
 * @return the two letter lower-cased language, or "*" (wildcard), or null
 */
function getLanguageFromRequest(req) {
    var lang = req.acceptsLanguages()[0];
    if (lang.indexOf("-") !== -1) {
        lang = lang.split("-")[0];
    }
    if (lang) {
        lang = lang.trim().toLowerCase();
    }
    return lang;
}
exports.getLanguageFromRequest = getLanguageFromRequest;
/**
 * This function shall be called with the nunjucks environment as self parameter!
 * It retrieve the language of the current request, using the default
 * language set in the app as fallback.
 */
function retrieveLanguage(self) {
    var lang = null;
    try {
        var req = self.ctx.req;
        lang = getLanguageFromRequest(req);
        if (lang === "*") {
            lang = null;
        }
    }
    catch (e) { }
    if (!lang) {
        lang = self.getVariables()["lang"];
    }
    if (!lang) {
        var app_1 = self.ctx.req.app.get("app");
        lang = app_1.config.defaultLanguage;
    }
    return lang;
}
/**
 * Implementation of the tr filer for the nunjucks engine.
 * It trying to understand the current language from the request. The fallback
 * uses the defaultLanguage set on the app.
 */
function translate(str) {
    try {
        var lang = retrieveLanguage(this);
        return performTranslation(str, translations[lang]);
    }
    catch (e) {
        logger_1.logger.info(e);
        logger_1.logger.info(this);
    }
    return str;
}
function performTranslation(str, translations) {
    var translation = translations[str];
    if (translation) {
        return translation;
    }
    var start = str.indexOf("{{");
    var end = str.indexOf("}}");
    if (start != -1 && end != -1) {
        var key = str.substring(start + 2, end);
        translation = translations[key.trim()];
        return str.replace("{{" + key + "}}", translation);
    }
    return str;
}
/**
 * Implementation of the date filter using moment.
 * The default implementation uses the "lll" string format, resulting in
 * Feb 19, 2018 4:57 PM in English.
 * @param d the date to format
 * @param format the string to format the date, default to lll
 * @return the formatted date
 */
function date(d, format) {
    var lang = retrieveLanguage(this);
    var m = moment(d).locale(lang);
    if (!format) {
        format = "lll";
    }
    return m.format(format);
}
/**
 * Apply parameters to an URL. If a parameter is not found as path parameter,
 * it is added as query parameter.
 * @param url the url to compile
 * @param parameters a plain object containing the parameters
 * @return the compiled url
 */
function applyParametersToUrl(url, parameters) {
    if (!parameters) {
        return url;
    }
    if (url.indexOf("?") == -1) {
        url += "?";
    }
    else {
        url += "&";
    }
    for (var key in parameters) {
        if (url.indexOf(":" + key) == -1) {
            url += key + "=" + parameters[key] + "&";
        }
        else {
            url = url.replace(":" + key, parameters[key]);
        }
    }
    if (url.endsWith("?") || url.endsWith("&")) {
        url = url.substring(0, url.length - 1);
    }
    return url;
}
/**
 * Transform the route name to a URL and compile it with the given parameters.
 * @param name the route name (or, eventually, the path)
 * @param parameters a plain object containing the parameters
 * @return the compiled url
 */
function route(name, parameters) {
    var url = name;
    if (routes[name]) {
        url = routes[name];
    }
    return applyParametersToUrl(url, parameters);
}
/**
 * Implementation of the old filter function. This function returns the previous
 * value of the input form. Fallback to the defaultValue.
 * @param name the name used in the form
 * @param defaultValue a fallback value
 * @return the previous value or defaultValue
 */
function old(name, defaultValue) {
    var req = this.ctx.req;
    if (req.body && req.body[name]) {
        return req.body[name];
    }
    if (req.query[name]) {
        return req.query[name];
    }
    return defaultValue;
}
/**
 * Implementation of the format filter function to format a float number.
 * By default, the number is formatted with 2 decimal numbers.
 * @param val the number to format
 * @param decimal the number of decimal number
 * @return the formatted number as a string
 */
function format(val, decimal) {
    if (decimal === void 0) { decimal = 2; }
    return Number(val).toFixed(decimal);
}
/**
 * Implementation of the resolvePath global function. Using this function, it is
 * possible to refer to any views with a virtual folder containing all the available
 * views.
 * @param path the virtual absolute path of the view
 * @return the absolute path of the view if resolved, or the original path otherwise
 */
function resolvePath(path) {
    var normalizedPath = path;
    if (normalizedPath.endsWith(".njk")) {
        normalizedPath = normalizedPath.substring(0, normalizedPath.length - 4);
    }
    var app = this.ctx.req.app.get("app");
    var resolved = app.templateMap[path];
    if (resolved) {
        return resolved;
    }
    return path;
}
/**
 * This function returns the current server url, with the used protocol and port.
 * This function is available as global function on nunjucks.
 */
function currentHost() {
    var req = this.ctx.req;
    return req.protocol + '://' + req.get('host');
}
/**
 * The App class contains the initialization code for a Lynx application.
 */
var App = /** @class */ (function () {
    function App(config, modules) {
        var _this = this;
        this._modules = new Set();
        this.apiResponseWrapper = new api_response_wrapper_1.DefaultAPIResponseWrapper();
        this._config = config;
        exports.app = this;
        if (modules) {
            this._modules = new Set(modules);
            this._modules.forEach(function (module) { return module.mount(_this._config); });
        }
        config.db.entities.unshift(__dirname + "/entities/*.entity.js");
        config.middlewaresFolders.unshift(__dirname + "/middlewares");
        config.viewFolders.unshift(__dirname + "/views");
        if (!config.disabledDb) {
            typeorm_1.createConnection(config.db)
                .then(function (_) {
                // here you can start to work with your entities
                logger_1.logger.info("Connection to the db established!");
                setup_1.setup(config.db.entities)
                    .then(function (_) {
                    _this._modules.forEach(function (module) {
                        return module.onDatabaseConnected();
                    });
                    if (!config.disableMigrations) {
                        _this.executeMigrations()
                            .catch(function (err) {
                            logger_1.logger.error(err);
                            process.exit(1);
                        })
                            .then(function () {
                            if (_this._config.onDatabaseInit) {
                                _this._config.onDatabaseInit();
                            }
                        });
                    }
                    else if (_this._config.onDatabaseInit) {
                        _this._config.onDatabaseInit();
                    }
                })
                    .catch(function (error) {
                    logger_1.logger.error(error);
                    process.exit(1);
                });
            })
                .catch(function (error) {
                logger_1.logger.error(error);
                process.exit(1);
            });
        }
        else {
            logger_1.logger.debug("The DB service is disabled");
        }
        this.express = express();
        this.httpServer = http.createServer(this.express);
        this.express.set("app", this);
        this.express.use(function (_, res, next) {
            res.setHeader('X-Powered-By', 'lynx-framework/express');
            next();
        });
        this.express.use("/api/*", cors());
        if (this.config.jsonLimit) {
            this.express.use(bodyParser.json({ limit: this.config.jsonLimit }));
        }
        else {
            this.express.use(bodyParser.json());
        }
        this.express.use(bodyParser.urlencoded({ extended: true }));
        var app_session_options = {
            secret: config.sessionSecret,
            resave: false,
            saveUninitialized: true
        };
        if (config.sessionStore) {
            app_session_options.store = config.sessionStore;
        }
        var app_session = session(app_session_options);
        this.express.use(app_session);
        this.express.use(flash());
        this._upload = multer({ dest: config.uploadPath });
        fs.exists(config.cachePath, function (exists) {
            if (!exists) {
                fs.mkdir(config.cachePath, function (err) {
                    if (err) {
                        logger_1.logger.error("Error creating the local cache directory", err);
                    }
                });
            }
        });
        for (var _i = 0, _a = config.publicFolders; _i < _a.length; _i++) {
            var folder = _a[_i];
            this.express.use(express.static(folder));
        }
        this.generateTemplateMap(config.viewFolders);
        this._nunjucksEnvironment = nunjucks.configure(config.viewFolders, {
            autoescape: true,
            watch: true,
            express: this.express
        });
        this._nunjucksEnvironment.addFilter("tr", translate);
        this._nunjucksEnvironment.addFilter("json", JSON.stringify);
        this._nunjucksEnvironment.addFilter("format", format);
        this._nunjucksEnvironment.addFilter("date", date);
        this.loadTranslations(config.translationFolders);
        this._nunjucksEnvironment.addGlobal("route", route);
        this._nunjucksEnvironment.addGlobal("old", old);
        this._nunjucksEnvironment.addGlobal("resolvePath", resolvePath);
        this._nunjucksEnvironment.addGlobal("currentHost", currentHost);
        for (var _b = 0, _c = config.middlewaresFolders; _b < _c.length; _b++) {
            var path = _c[_b];
            this.loadMiddlewares(path);
        }
        for (var _d = 0, _e = config.controllersFolders; _d < _e.length; _d++) {
            var path = _e[_d];
            this.loadControllers(path);
        }
        if (!config.disabledDb && !config.disabledGraphQL) {
            var schema = graphqlGenerator.generateSchema(config.db.entities);
            // The GraphQL endpoint
            this.express.use("/graphql", bodyParser.json(), apollo_server_express_1.graphqlExpress({ schema: schema }));
            // GraphiQL, a visual editor for queries
            this.express.use("/graphiql", apollo_server_express_1.graphiqlExpress({ endpointURL: "/graphql" }));
        }
        this._errorController = new error_controller_1.default(this);
    }
    Object.defineProperty(App.prototype, "config", {
        get: function () {
            return this._config;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(App.prototype, "templateMap", {
        get: function () {
            return this._templateMap;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(App.prototype, "nunjucksEnvironment", {
        get: function () {
            return this._nunjucksEnvironment;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(App.prototype, "upload", {
        get: function () {
            return this._upload;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(App.prototype, "customErrorController", {
        /**
         * This property allow the customization of the standard error controller.
         * You need to create the controller using its standard constructor:
         * new MyCustomErrorController(app)
         */
        set: function (ctrl) {
            this._errorController = ctrl;
        },
        enumerable: false,
        configurable: true
    });
    App.prototype.recursiveGenerateTemplateMap = function (path, currentPath) {
        var files = fs.readdirSync(path);
        for (var index in files) {
            var currentFilePath = path + "/" + files[index];
            if (fs.lstatSync(currentFilePath).isDirectory()) {
                this.recursiveGenerateTemplateMap(currentFilePath, currentPath + files[index] + "/");
                continue;
            }
            var name = files[index].replace(".njk", "");
            this._templateMap[currentPath + name] = currentFilePath;
        }
    };
    App.prototype.generateTemplateMap = function (paths) {
        this._templateMap = {};
        for (var _i = 0, paths_1 = paths; _i < paths_1.length; _i++) {
            var path = paths_1[_i];
            this.recursiveGenerateTemplateMap(path, "/");
        }
    };
    App.prototype.recursiveExecuteMigrations = function (path) {
        return __awaiter(this, void 0, void 0, function () {
            var files, _a, _b, _i, index, currentFilePath, m, entity, migration, e_1;
            return __generator(this, function (_c) {
                switch (_c.label) {
                    case 0:
                        if (!fs.existsSync(path)) {
                            logger_1.logger.warn("The migration folder " + path + " doesn't exists!");
                            return [2 /*return*/];
                        }
                        files = fs.readdirSync(path).sort(function (a, b) { return a.localeCompare(b); });
                        _a = [];
                        for (_b in files)
                            _a.push(_b);
                        _i = 0;
                        _c.label = 1;
                    case 1:
                        if (!(_i < _a.length)) return [3 /*break*/, 13];
                        index = _a[_i];
                        currentFilePath = path + "/" + files[index];
                        if (!fs.lstatSync(currentFilePath).isDirectory()) return [3 /*break*/, 3];
                        return [4 /*yield*/, this.recursiveExecuteMigrations(currentFilePath)];
                    case 2:
                        _c.sent();
                        return [3 /*break*/, 12];
                    case 3:
                        if (currentFilePath.endsWith("ts"))
                            return [3 /*break*/, 12];
                        m = require(currentFilePath);
                        if (!m.default) {
                            throw new Error("Please define the migration as the export default class in file " +
                                currentFilePath +
                                ".");
                        }
                        return [4 /*yield*/, migration_entity_1.default.findByName(currentFilePath)];
                    case 4:
                        entity = _c.sent();
                        if (entity && entity.wasExecuted()) {
                            return [3 /*break*/, 12];
                        }
                        if (!!entity) return [3 /*break*/, 6];
                        entity = new migration_entity_1.default();
                        entity.name = currentFilePath;
                        return [4 /*yield*/, entity.save()];
                    case 5:
                        _c.sent();
                        _c.label = 6;
                    case 6:
                        migration = new m.default();
                        _c.label = 7;
                    case 7:
                        _c.trys.push([7, 10, , 12]);
                        return [4 /*yield*/, migration.up()];
                    case 8:
                        _c.sent();
                        entity.setExecuted();
                        return [4 /*yield*/, entity.save()];
                    case 9:
                        _c.sent();
                        logger_1.logger.info("Migration " + currentFilePath + " executed!");
                        return [3 /*break*/, 12];
                    case 10:
                        e_1 = _c.sent();
                        entity.setFailed();
                        return [4 /*yield*/, entity.save()];
                    case 11:
                        _c.sent();
                        logger_1.logger.error("Error executing the migration " + currentFilePath);
                        throw e_1;
                    case 12:
                        _i++;
                        return [3 /*break*/, 1];
                    case 13: return [2 /*return*/];
                }
            });
        });
    };
    /**
     *  This method will execute the migrations.
     *  By default, this method will be executed automatically during the app
     *  startup. In some scenario, like hight-scalability, this behaviour could
     *  be unwanted. Thus, it is possibly otherwise to explicitly call this method
     *  in some other way (for example, connecting it to a standard http route).
     */
    App.prototype.executeMigrations = function () {
        return __awaiter(this, void 0, void 0, function () {
            var _i, _a, path;
            return __generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        _i = 0, _a = this._config.migrationsFolders;
                        _b.label = 1;
                    case 1:
                        if (!(_i < _a.length)) return [3 /*break*/, 4];
                        path = _a[_i];
                        return [4 /*yield*/, this.recursiveExecuteMigrations(path)];
                    case 2:
                        _b.sent();
                        _b.label = 3;
                    case 3:
                        _i++;
                        return [3 /*break*/, 1];
                    case 4: return [2 /*return*/];
                }
            });
        });
    };
    App.prototype.loadTranslations = function (paths) {
        for (var _i = 0, paths_2 = paths; _i < paths_2.length; _i++) {
            var path = paths_2[_i];
            var files = fs.readdirSync(path);
            for (var index in files) {
                var nameWithExtension = files[index];
                if (!nameWithExtension.endsWith("json"))
                    continue;
                var name = nameWithExtension.substring(0, nameWithExtension.indexOf("."));
                var tmp = JSON.parse(fs.readFileSync(path + "/" + nameWithExtension, "utf8"));
                if (!translations[name]) {
                    translations[name] = {};
                }
                for (var key in tmp) {
                    translations[name][key] = tmp[key];
                }
            }
        }
    };
    App.prototype.loadMiddlewares = function (path) {
        if (!fs.existsSync(path)) {
            logger_1.logger.warn("The middleares folder " + path + " doesn't exists!");
            return;
        }
        var middlewares = fs.readdirSync(path);
        for (var index in middlewares) {
            var currentFilePath = path + "/" + middlewares[index];
            if (fs.lstatSync(currentFilePath).isDirectory()) {
                this.loadMiddlewares(currentFilePath);
                continue;
            }
            if (middlewares[index].endsWith("ts"))
                continue;
            var midd = require(currentFilePath);
            if (!midd.default) {
                throw new Error("Please define the middleware as the export default class in file " +
                    currentFilePath +
                    ".");
            }
            expressGenerator.useMiddleware(this, midd.default);
        }
    };
    App.prototype.loadControllers = function (path) {
        var files = fs.readdirSync(path);
        for (var index in files) {
            var currentFilePath = path + "/" + files[index];
            if (fs.lstatSync(currentFilePath).isDirectory()) {
                this.loadControllers(currentFilePath);
                continue;
            }
            if (files[index].endsWith("ts"))
                continue;
            var ctrl = require(currentFilePath);
            if (!ctrl.default) {
                throw new Error("Please define the controller as the export default class in file " +
                    currentFilePath +
                    ".");
            }
            expressGenerator.useController(this, ctrl.default, routes);
        }
    };
    App.prototype.startServer = function (port) {
        var _this = this;
        this.express.use(function (req, res) {
            _this._errorController
                .onNotFound(req)
                .then(function (r) {
                if (!res.headersSent) {
                    res.status(404);
                }
                r.performResponse(req, res);
            })
                .catch(function (err) {
                if (!res.headersSent) {
                    res.status(404);
                }
                res.send(err);
            });
        });
        this.express.use(function (error, req, res, _) {
            _this._errorController
                .onError(error, req)
                .then(function (r) {
                if (!res.headersSent) {
                    res.status(500);
                }
                r.performResponse(req, res);
            })
                .catch(function (err) {
                if (!res.headersSent) {
                    res.status(500);
                }
                res.send(err);
            });
        });
        this.httpServer.listen(port, function () {
            logger_1.logger.info("server is listening on " + port);
        });
    };
    App.prototype.route = function (name, parameters) {
        return route(name, parameters);
    };
    App.prototype.translate = function (str, req) {
        try {
            var lang = getLanguageFromRequest(req);
            if (!lang) {
                lang = this._config.defaultLanguage;
            }
            return performTranslation(str, translations[lang]);
        }
        catch (e) {
            logger_1.logger.info(e);
        }
        return str;
    };
    App.prototype.generateTokenForUser = function (user) {
        return jsonwebtoken_1.sign({ id: user.id }, this._config.tokenSecret, {
            expiresIn: "1y"
        });
    };
    return App;
}());
exports.default = App;
Object.defineProperty(Array.prototype, "serialize", {
    enumerable: false,
    configurable: true,
    value: function () {
        var r = [];
        for (var _i = 0, _a = this; _i < _a.length; _i++) {
            var el = _a[_i];
            if (el.serialize) {
                r.push(el.serialize());
            }
            else {
                r.push(el);
            }
        }
        return r;
    }
});
Object.defineProperty(Array.prototype, "addHiddenField", {
    enumerable: false,
    configurable: true,
    value: function (field) {
        for (var _i = 0, _a = this; _i < _a.length; _i++) {
            var el = _a[_i];
            if (el.addHiddenField) {
                el.addHiddenField(field);
            }
        }
    }
});
Object.defineProperty(Array.prototype, "removeHiddenField", {
    enumerable: false,
    configurable: true,
    value: function (field) {
        for (var _i = 0, _a = this; _i < _a.length; _i++) {
            var el = _a[_i];
            if (el.removeHiddenField) {
                el.removeHiddenField(field);
            }
        }
    }
});