@stemy/backend 4.0.0 → 4.0.2

package/fesm2015/stemy-backend.mjs

@@ -1,4 +1,4 @@
-import { __awaiter, __decorate, __param } from 'tslib';
+import { __awaiter, __decorate, __param, __metadata } from 'tslib';
 import { dirname, basename, join, resolve } from 'path';
 import bodyParser from 'body-parser';
 import webToken from 'jsonwebtoken';
@@ -19,19 +19,19 @@ import { ObjectId, GridFSBucket } from 'mongodb';
 import { Types, connect, model } from 'mongoose';
 import { Readable, PassThrough } from 'stream';
 import { fileTypeFromStream } from 'file-type/core';
-import { createServer } from 'http';
-import express_, { static as static$1 } from 'express';
-import { Server } from 'socket.io';
 import dotenv from 'dotenv';
-import { v4 } from 'uuid';
 import cron from 'node-cron';
 import { socket } from 'zeromq';
 import { filter as filter$1, map, first, timeout } from 'rxjs/operators';
+import { createServer } from 'http';
+import express_, { static as static$1 } from 'express';
+import { Server } from 'socket.io';
+import { v4 } from 'uuid';
 import { createTransport } from 'nodemailer';
+import * as Handlebars from 'handlebars';
 import { routingControllersToSpec, OpenAPI, getStatusCode } from 'routing-controllers-openapi';
 import { validationMetadatasToSchemas } from 'class-validator-jsonschema';
 import { ValidatorConstraint, ValidationTypes, Min, Max, IsOptional, IsBoolean } from 'class-validator';
-import * as Handlebars from 'handlebars';
 import { CommandsAddon, AnsiCodes } from '@stemy/terminal-commands-addon';
 import { compare } from 'bcrypt';
 import moment from 'moment';
@@ -148,36 +148,6 @@ AssetProcessor = AssetProcessor_1 = __decorate([
     scoped(Lifecycle.ContainerScoped)
 ], AssetProcessor);
 
-let AssetResolver = class AssetResolver {
-    constructor(assets, lazyAssets) {
-        this.assets = assets;
-        this.lazyAssets = lazyAssets;
-    }
-    resolve(id, lazy = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let asset = null;
-            if (lazy) {
-                const lazyAsset = yield this.lazyAssets.read(id);
-                if (!lazyAsset)
-                    return null;
-                return lazyAsset.loadAsset();
-            }
-            asset = yield this.assets.read(id);
-            if (!asset) {
-                const lazyAsset = yield this.lazyAssets.read(id);
-                if (!lazyAsset)
-                    return null;
-                return lazyAsset.loadAsset();
-            }
-            return asset;
-        });
-    }
-};
-AssetResolver = __decorate([
-    injectable(),
-    scoped(Lifecycle.ContainerScoped)
-], AssetResolver);
-
 const sharp$2 = sharp_;
 const diContainers = {
     appContainer: null
@@ -866,6 +836,101 @@ function fileTypeFromBuffer(buffer) {
     });
 }
 
+let Configuration = class Configuration {
+    constructor(params) {
+        dotenv.config();
+        this.paramMap = {};
+        this.paramValues = {};
+        (params || []).forEach(param => this.add(param));
+    }
+    add(param) {
+        const existingParam = this.paramMap[param.name] || param;
+        existingParam.defaultValue = param.defaultValue;
+        existingParam.resolver = param.resolver || existingParam.resolver;
+        this.paramMap[param.name] = existingParam;
+    }
+    resolveValue(param, alreadyResolved) {
+        const envName = param.name.replace(/\.?([A-Z|0-9]+)/g, function (x, y) {
+            return "_" + y.toLowerCase();
+        }).replace(/\./gi, "_").replace(/^_/, "").toUpperCase();
+        const envValue = process.env[envName];
+        const helper = (p) => this.resolveInternal(p, alreadyResolved);
+        if (typeof envValue !== "undefined") {
+            const value = isFunction(param.resolver)
+                ? param.resolver(envValue, helper)
+                : convertValue(envValue, getType(param.defaultValue));
+            console.log(colorize(`Processing param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), colorize(envName, ConsoleColor.FgBlue), `"${envValue}"`, value);
+            return value;
+        }
+        else if (isFunction(param.resolver)) {
+            const value = param.resolver(param.defaultValue, helper);
+            console.log(colorize(`Processing default param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), param.defaultValue, value);
+            return value;
+        }
+        console.log(colorize(`Using default param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), param.defaultValue);
+        return param.defaultValue;
+    }
+    hasParam(name) {
+        return !!this.paramMap[name];
+    }
+    resolve(name) {
+        return this.resolveInternal(name, []);
+    }
+    resolveInternal(name, alreadyResolved) {
+        if (alreadyResolved.includes(name)) {
+            throw new Error(`Circular dependency detected: ${alreadyResolved.join(" -> ")} -> ${name}`);
+        }
+        alreadyResolved.push(name);
+        const param = this.paramMap[name];
+        if (!param)
+            throw new Error(`Parameter with name: '${name}' does not exists in configuration`);
+        if (!(name in this.paramValues)) {
+            this.paramValues[name] = this.resolveValue(param, alreadyResolved);
+        }
+        return this.paramValues[name];
+    }
+};
+Configuration = __decorate([
+    singleton(),
+    __param(0, injectAll(PARAMETER)),
+    __metadata("design:paramtypes", [Array])
+], Configuration);
+
+let MongoConnector = class MongoConnector {
+    constructor(configuration) {
+        this.configuration = configuration;
+        this.conn = null;
+        this.db = null;
+        this.fsBucket = null;
+    }
+    get connection() {
+        return this.conn;
+    }
+    get database() {
+        return this.db;
+    }
+    get bucket() {
+        return this.fsBucket;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.db)
+                return this.db;
+            this.conn = (yield connect(this.configuration.resolve("mongoUri"), {
+                dbName: this.configuration.resolve("mongoDb"),
+                user: this.configuration.resolve("mongoUser"),
+                pass: this.configuration.resolve("mongoPassword")
+            })).connection;
+            this.db = this.conn.db;
+            this.fsBucket = new GridFSBucket(this.db, { bucketName: "assets" });
+        });
+    }
+};
+MongoConnector = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Configuration])
+], MongoConnector);
+
 class BaseEntity {
     constructor(mId, data, collection) {
         this.mId = mId;
@@ -1146,416 +1211,106 @@ let Assets = class Assets {
 };
 Assets = __decorate([
     injectable(),
-    scoped(Lifecycle.ContainerScoped)
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [MongoConnector, AssetProcessor])
 ], Assets);
 
-const express = express_;
-let BackendProvider = class BackendProvider {
-    constructor() {
-        this.express = express();
-        this.express.set("trust proxy", true);
-        this.server = createServer(this.express);
+class LazyAsset extends BaseEntity {
+    constructor(id, data, collection, logger, assets, progresses) {
+        super(id, data, collection);
+        this.logger = logger;
+        this.assets = assets;
+        this.progresses = progresses;
     }
-    get io() {
-        this.ioServer = this.ioServer || new Server(this.server, { path: "/socket" });
-        return this.ioServer;
+    get jobName() {
+        return this.data.jobName;
     }
-};
-BackendProvider = __decorate([
-    singleton()
-], BackendProvider);
-
-let Cache = class Cache {
-    constructor(connector, config, cacheProcessor) {
-        this.connector = connector;
-        this.config = config;
-        this.cacheProcessor = cacheProcessor;
+    get jobParams() {
+        return this.data.jobParams;
     }
-    prepare() {
+    get jobQue() {
+        return this.data.jobQue;
+    }
+    get progressId() {
+        return this.data.progressId;
+    }
+    get assetId() {
+        return this.data.assetId;
+    }
+    unlink() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.collection)
-                return;
-            if (!this.connector.database) {
-                throw new Error(`You can't use cache without mongo connection!`);
+            yield this.load();
+            if (!this.progressId) {
+                yield this.collection.deleteOne({ _id: this.mId });
             }
-            this.collection = this.connector.database.collection(this.config.resolve("cacheCollection"));
-            yield this.collection.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+            return deleteFromBucket(this.assets.bucket, new ObjectId$1(this.assetId));
         });
     }
-    set(key, value, ttl, expirationTimestamp = null, tags = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.prepare();
-            const item = {
-                _id: key,
-                data: yield this.cacheProcessor.serialize(value),
-                tags: yield this.cacheProcessor.serialize(tags),
-                expirationTimestamp,
-            };
-            if (ttl) {
-                const now = Math.round(new Date().getTime() / 1000);
-                item.expiresAt = now + ttl;
-            }
-            yield this.collection.updateOne({ _id: key }, { $set: item }, { upsert: true });
-            return value;
+    startWorking() {
+        this.load().then(() => {
+            if (this.deleted)
+                return;
+            this.progresses.get(this.progressId).then(p => {
+                p === null || p === void 0 ? void 0 : p.cancel();
+            });
+            this.startWorkingOnAsset(false).then(() => {
+                this.logger.log("lazy-assets", `Started working on lazy asset: ${this.id}`);
+            }).catch(reason => {
+                this.logger.log("lazy-assets", `Can't start working on lazy asset: ${this.id}\nReason: ${reason}`);
+            });
         });
     }
-    get(key) {
+    loadAsset() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.prepare();
-            let item = yield this.collection.findOne({ _id: key });
-            const now = Math.round(new Date().getTime() / 1000);
-            if (item && item.expiresAt && item.expiresAt < now) {
-                item = null;
+            yield this.load();
+            if (this.deleted)
+                return null;
+            if (this.assetId) {
+                return this.assets.read(this.assetId);
             }
-            if (!item) {
-                throw new Error(`Cache probably doesn't exists with key: ${key}`);
+            if (this.progressId) {
+                yield this.progresses.waitToFinish(this.progressId);
+                return this.loadAsset();
             }
-            return yield this.cacheProcessor.deserialize(item.data);
+            yield this.startWorkingOnAsset(true);
+            return this.loadAsset();
         });
     }
-    getOrSet(key, valueCb, ttl, expirationTimestamp = null, tags = {}) {
+    writeAsset(asset) {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this.get(key);
-            }
-            catch (e) {
-                return yield this.set(key, yield valueCb(), ttl, expirationTimestamp, tags);
-            }
+            this.data.assetId = asset.id;
+            yield this.save();
+            return asset;
         });
     }
-    delete(key) {
+    startWorkingOnAsset(fromLoad) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.prepare();
-            yield this.collection.deleteOne({ _id: key });
+            this.data.progressId = (yield this.progresses.create()).id;
+            this.data.assetId = null;
+            yield this.save();
+            yield this.progresses.jobMan.enqueueWithName(this.data.jobName, Object.assign(Object.assign({}, this.data.jobParams), { lazyId: this.id, fromLoad }));
         });
     }
-};
-Cache = __decorate([
-    singleton()
-], Cache);
+}
 
-let CacheProcessor = class CacheProcessor {
-    serialize(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return data;
-        });
-    }
-    deserialize(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return data;
-        });
-    }
-};
-CacheProcessor = __decorate([
-    injectable(),
-    scoped(Lifecycle.ContainerScoped)
-], CacheProcessor);
-
-let Configuration = class Configuration {
-    constructor(params) {
-        dotenv.config();
-        this.paramMap = {};
-        this.paramValues = {};
-        (params || []).forEach(param => this.add(param));
-    }
-    add(param) {
-        const existingParam = this.paramMap[param.name] || param;
-        existingParam.defaultValue = param.defaultValue;
-        existingParam.resolver = param.resolver || existingParam.resolver;
-        this.paramMap[param.name] = existingParam;
-    }
-    resolveValue(param, alreadyResolved) {
-        const envName = param.name.replace(/\.?([A-Z|0-9]+)/g, function (x, y) {
-            return "_" + y.toLowerCase();
-        }).replace(/\./gi, "_").replace(/^_/, "").toUpperCase();
-        const envValue = process.env[envName];
-        const helper = (p) => this.resolveInternal(p, alreadyResolved);
-        if (typeof envValue !== "undefined") {
-            const value = isFunction(param.resolver)
-                ? param.resolver(envValue, helper)
-                : convertValue(envValue, getType(param.defaultValue));
-            console.log(colorize(`Processing param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), colorize(envName, ConsoleColor.FgBlue), `"${envValue}"`, value);
-            return value;
-        }
-        else if (isFunction(param.resolver)) {
-            const value = param.resolver(param.defaultValue, helper);
-            console.log(colorize(`Processing default param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), param.defaultValue, value);
-            return value;
-        }
-        console.log(colorize(`Using default param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), param.defaultValue);
-        return param.defaultValue;
-    }
-    hasParam(name) {
-        return !!this.paramMap[name];
-    }
-    resolve(name) {
-        return this.resolveInternal(name, []);
-    }
-    resolveInternal(name, alreadyResolved) {
-        if (alreadyResolved.includes(name)) {
-            throw new Error(`Circular dependency detected: ${alreadyResolved.join(" -> ")} -> ${name}`);
-        }
-        alreadyResolved.push(name);
-        const param = this.paramMap[name];
-        if (!param)
-            throw new Error(`Parameter with name: '${name}' does not exists in configuration`);
-        if (!(name in this.paramValues)) {
-            this.paramValues[name] = this.resolveValue(param, alreadyResolved);
-        }
-        return this.paramValues[name];
-    }
-};
-Configuration = __decorate([
-    singleton(),
-    __param(0, injectAll(PARAMETER))
-], Configuration);
-
-let EndpointProvider = class EndpointProvider {
-    configure(app) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log(`Express app is mounted to: ${app.mountpath}`);
-        });
-    }
-};
-EndpointProvider = __decorate([
-    injectable(),
-    scoped(Lifecycle.ContainerScoped)
-], EndpointProvider);
-
-let Fixtures = class Fixtures {
-    constructor(fixtures) {
-        this.fixtures = fixtures;
-    }
-    load(output) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.fixtures)
-                return;
-            output = output || {
-                write: console.log,
-                writeln: t => console.log(t + "\n")
-            };
-            for (let fixture of this.fixtures) {
-                yield fixture.load(output);
-            }
-        });
-    }
-};
-Fixtures = __decorate([
-    injectable(),
-    scoped(Lifecycle.ContainerScoped),
-    __param(0, injectAll(FIXTURE))
-], Fixtures);
-
-const sharp$1 = sharp_;
-let Gallery = class Gallery {
-    constructor(config, galleryCache) {
-        this.config = config;
-        this.galleryCache = galleryCache;
-        this.cache = {};
-        this.dir = this.config.resolve("galleryDir");
-        this.output = join(this.config.resolve("cacheDir"), "gallery");
-    }
-    getFolder(folder, size = null) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.cache[folder] = this.cache[folder] || new Promise(resolve => {
-                lstat(join(this.dir, folder), (err, stats) => {
-                    if (err || !stats.isDirectory()) {
-                        resolve([]);
-                        return;
-                    }
-                    this.readRecursive(folder, "", size).then(resolve, () => resolve([]));
-                });
-            });
-            return this.cache[folder];
-        });
-    }
-    readRecursive(path, folder, size) {
-        return new Promise(resolve => {
-            readdir(join(this.dir, path), (err, files) => {
-                if (err) {
-                    resolve([]);
-                    return;
-                }
-                const promises = files.map(file => {
-                    return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
-                        const filePath = join(path, file);
-                        const absoluteFilePath = join(this.dir, filePath);
-                        lstat(absoluteFilePath, (err, stats) => {
-                            if (err) {
-                                resolve([]);
-                                return;
-                            }
-                            if (stats.isDirectory()) {
-                                this.readRecursive(filePath, join(folder, file), size).then(resolve);
-                                return;
-                            }
-                            const sharpImg = sharp$1(absoluteFilePath);
-                            sharpImg.rotate().metadata().then(() => {
-                                const getResultPath = (isThumb) => {
-                                    return join(this.output, filePath.replace(/.([a-z|A-Z]+)$/gi, function (ext) {
-                                        const suffix = isThumb ? 'thumb' : 'big';
-                                        return `-${suffix}${ext}`;
-                                    }));
-                                };
-                                resolve([this.galleryCache.create(folder, size, {
-                                        getOriginal: () => {
-                                            return new Promise((res, rej) => {
-                                                readFile$1(absoluteFilePath, (err, data) => {
-                                                    if (err) {
-                                                        rej(err);
-                                                        return;
-                                                    }
-                                                    res(data);
-                                                });
-                                            });
-                                        },
-                                        writeResult: (isThumb, buffer) => {
-                                            return new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
-                                                const resultPath = getResultPath(isThumb);
-                                                yield mkdirRecursive(dirname(resultPath));
-                                                writeFile$1(resultPath, buffer, err => {
-                                                    if (err) {
-                                                        rej(err);
-                                                        return;
-                                                    }
-                                                    res();
-                                                });
-                                            }));
-                                        },
-                                        hasResult: (isThumb) => {
-                                            return new Promise(res => {
-                                                access(getResultPath(isThumb), constants.R_OK, err => {
-                                                    res(!err);
-                                                });
-                                            });
-                                        },
-                                        serveResult: (isThumb) => {
-                                            return new Promise((res, rej) => {
-                                                readFile$1(getResultPath(isThumb), (err, data) => {
-                                                    if (err) {
-                                                        rej(err);
-                                                        return;
-                                                    }
-                                                    res(data);
-                                                });
-                                            });
-                                        }
-                                    })]);
-                            }, () => resolve([]));
-                        });
-                    }));
-                });
-                Promise.all(promises).then(folders => {
-                    resolve([].concat.apply([], folders));
-                });
-            });
-        });
-    }
-};
-Gallery = __decorate([
-    injectable(),
-    scoped(Lifecycle.ContainerScoped)
-], Gallery);
-
-const sharp = sharp_;
-const bigSize = 1500;
-const thumbSize = 250;
-class GalleryImage {
-    constructor(folder, size, handler) {
-        this.folder = folder;
-        this.handler = handler;
-        this.thumb = v4();
-        this.big = v4();
-        this.targetSize = !size ? { width: thumbSize, height: thumbSize } : size;
-    }
-    serve(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const isThumb = id == this.thumb;
-            if (yield this.handler.hasResult(isThumb)) {
-                return this.handler.serveResult(isThumb);
-            }
-            const original = sharp(yield this.handler.getOriginal()).rotate();
-            const meta = yield original.metadata();
-            const ratio = meta.width / meta.height;
-            const sizeRatio = isThumb ? this.targetSize.width / this.targetSize.height : 1;
-            const size = isThumb ? Math.max(this.targetSize.width, this.targetSize.height) : bigSize;
-            const targetHeight = ratio > sizeRatio ? size : Math.round(size / ratio);
-            const targetWidth = Math.round(targetHeight * ratio);
-            const resized = original.resize(targetWidth, targetHeight);
-            const buffer = yield (isThumb ? resized.extract({
-                left: Math.floor((targetWidth - this.targetSize.width) / 2),
-                top: Math.floor((targetHeight - this.targetSize.height) / 2),
-                width: this.targetSize.width,
-                height: this.targetSize.height
-            }).toBuffer() : resized.toBuffer());
-            yield this.handler.writeResult(isThumb, buffer);
-            return this.handler.serveResult(isThumb);
-        });
-    }
-}
-
-let GalleryCache = class GalleryCache {
-    constructor() {
-        this.imgCache = {};
-    }
-    put(img) {
-        this.imgCache[img.thumb] = img;
-        this.imgCache[img.big] = img;
-    }
-    serve(id) {
-        const img = this.imgCache[id];
-        return !img ? null : img.serve(id);
-    }
-    create(folder, targetSize, handler) {
-        const image = new GalleryImage(folder, targetSize, handler);
-        this.put(image);
-        return image;
-    }
-};
-GalleryCache = __decorate([
-    injectable(),
-    scoped(Lifecycle.ContainerScoped)
-], GalleryCache);
-
-let IdGenerator = class IdGenerator {
+let Logger = class Logger {
     constructor(config) {
         this.config = config;
-        this.prefix = config.resolve("idPrefix");
-        this.separator = config.resolve("idSeparator");
-        this.chars = config.resolve("idChars");
-        this.parts = config.resolve("idParts");
-    }
-    generate(checkCb) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let id = null;
-            let tries = 0;
-            let notGood = true;
-            while (notGood && tries < 5) {
-                id = this.generateId();
-                notGood = yield checkCb(id);
-                tries++;
-            }
-            if (notGood) {
-                throw `Couldn't generate an unique id..`;
-            }
-            return id;
-        });
+        this.tags = this.config.resolve("logTags");
+        this.ignoredTags = this.config.resolve("ignoredLogTags");
     }
-    generateId() {
-        return this.prefix + this.parts.map(num => {
-            let s = "";
-            for (let i = 0; i < num; i++) {
-                const ix = rand(0, this.chars.length - 1);
-                s += this.chars[ix];
-            }
-            return s;
-        }).join(this.separator);
+    log(tag, ...params) {
+        if (this.ignoredTags.includes(tag))
+            return;
+        if (this.tags.length === 0 || this.tags.includes(tag)) {
+            console.log(`[${tag}]`, ...params);
+        }
     }
 };
-IdGenerator = __decorate([
-    injectable(),
-    scoped(Lifecycle.ContainerScoped)
-], IdGenerator);
+Logger = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Configuration])
+], Logger);
 
 let JobManager = class JobManager {
     constructor(config, logger, container, jobTypes) {
@@ -1741,86 +1496,306 @@ JobManager = __decorate([
     injectable(),
     scoped(Lifecycle.ContainerScoped),
     __param(2, inject(DI_CONTAINER)),
-    __param(3, injectAll(JOB))
+    __param(3, injectAll(JOB)),
+    __metadata("design:paramtypes", [Configuration,
+        Logger, Object, Array])
 ], JobManager);
 
-class LazyAsset extends BaseEntity {
-    constructor(id, data, collection, logger, assets, progresses) {
+class Progress extends BaseEntity {
+    constructor(id, data, collection) {
         super(id, data, collection);
-        this.logger = logger;
-        this.assets = assets;
-        this.progresses = progresses;
     }
-    get jobName() {
-        return this.data.jobName;
+    get current() {
+        return this.data.current;
+    }
+    get max() {
+        return this.data.max;
+    }
+    get message() {
+        return this.data.message;
+    }
+    get error() {
+        return this.data.error;
+    }
+    get canceled() {
+        return this.data.canceled;
+    }
+    get percent() {
+        return this.max > 0 ? Math.round(this.current / this.max * 100) : 0;
+    }
+    get remaining() {
+        return this.max > 0 ? this.max - this.current : 0;
+    }
+    setMessageBridge(messageBridge) {
+        this.messageBridge = messageBridge || this.messageBridge;
+        return this;
+    }
+    createSubProgress(progressValue, max, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (max <= 0 && progressValue > 0) {
+                yield this.advance(progressValue);
+            }
+            if (message !== null) {
+                this.data.message = message;
+                yield this.save();
+            }
+            return new SubProgress(this, this.current, progressValue, Math.max(max, 1));
+        });
+    }
+    setMax(max) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isNaN(max) || max <= 0) {
+                throw "Max progress value must be bigger than zero";
+            }
+            this.data.max = max;
+            yield this.save();
+        });
+    }
+    setMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.data.message = message;
+            yield this.save();
+        });
+    }
+    setError(error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.data.error = error;
+            yield this.save();
+        });
+    }
+    advance(value = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isNaN(value) || value <= 0) {
+                throw new Error(`Advance value must be bigger than zero: ${this.id}`);
+            }
+            yield this.load();
+            if (this.deleted || this.canceled) {
+                const status = this.deleted ? "deleted" : "canceled";
+                throw new Error(`Can't advance ${status} progress: ${this.id}`);
+            }
+            this.data.current = Math.min(this.max, this.current + value);
+            yield this.save();
+        });
+    }
+    cancel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.data.canceled = true;
+            yield this.save();
+        });
+    }
+    save() {
+        if (this.messageBridge) {
+            this.messageBridge.sendMessage(`progress-changed`, this.toJSON());
+        }
+        return super.save();
+    }
+}
+class SubProgress {
+    constructor(parent, progressFrom, progressValue, mMax = 100) {
+        this.parent = parent;
+        this.progressFrom = progressFrom;
+        this.progressValue = progressValue;
+        this.mMax = mMax;
+        if (progressFrom < 0) {
+            throw "Progress from must be bigger than or zero";
+        }
+        if (progressValue <= 0) {
+            throw "Progress value must be bigger than zero";
+        }
+        this.mCurrent = 0;
+    }
+    get id() {
+        return this.parent.id;
+    }
+    get current() {
+        return this.mCurrent;
+    }
+    get max() {
+        return this.mMax;
+    }
+    get message() {
+        return this.parent.message;
+    }
+    get error() {
+        return this.parent.error;
+    }
+    get percent() {
+        return this.parent.percent;
+    }
+    get remaining() {
+        return this.max - this.mCurrent;
+    }
+    get canceled() {
+        return !this.parent || this.parent.canceled;
+    }
+    setMessageBridge(messageBridge) {
+        if (!this.parent)
+            return this;
+        this.parent.setMessageBridge(messageBridge);
+        return this;
+    }
+    createSubProgress(progressValue, max, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (max <= 0 && progressValue > 0) {
+                yield this.advance(progressValue);
+            }
+            if (message !== null) {
+                yield this.setMessage(message);
+            }
+            return new SubProgress(this, this.current, progressValue, Math.max(max, 1));
+        });
+    }
+    setMax(max) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isNaN(max) || max <= 0) {
+                throw "Max progress value must be bigger than zero";
+            }
+            this.mMax = max;
+            yield this.save();
+        });
+    }
+    setMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.parent)
+                return null;
+            yield this.parent.setMessage(message);
+        });
+    }
+    setError(error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.parent)
+                return null;
+            yield this.parent.setError(error);
+        });
+    }
+    advance(value = 1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isNaN(value) || value <= 0) {
+                throw "Advance value must be bigger than zero";
+            }
+            this.mCurrent = Math.min(this.max, this.mCurrent + value);
+            yield this.save();
+        });
+    }
+    cancel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.parent)
+                return null;
+            yield this.parent.cancel();
+        });
+    }
+    save() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ratio = this.max > 0 ? this.mCurrent / this.max : 0;
+            const newProgress = this.progressFrom + Math.round(this.progressValue * ratio);
+            const current = this.parent.current;
+            if (newProgress <= current)
+                return null;
+            yield this.parent.advance(newProgress);
+        });
     }
-    get jobParams() {
-        return this.data.jobParams;
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return null;
+        });
     }
-    get jobQue() {
-        return this.data.jobQue;
+    toJSON() {
+        return this.parent.toJSON();
     }
-    get progressId() {
-        return this.data.progressId;
+}
+
+let Progresses = class Progresses {
+    constructor(connector, jobMan) {
+        this.connector = connector;
+        this.jobMan = jobMan;
+        this.collection = connector.database.collection("progresses");
+        this.progresses = {};
+        this.jobMan.on("progress-changed", progress => {
+            const id = progress.id;
+            this.progresses[id] = new Progress(new ObjectId$1(id), progress, this.collection);
+        });
     }
-    get assetId() {
-        return this.data.assetId;
+    waitToFinish(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.race([
+                this.waitForProgress(id, () => __awaiter(this, void 0, void 0, function* () {
+                    let progress = this.progresses[id];
+                    if (!progress || progress.percent < 100) {
+                        progress = yield this.get(id);
+                    }
+                    if (!progress) {
+                        throw new Error(`Progress does not exists with id: ${id}`);
+                    }
+                    return progress;
+                }), 500),
+                this.waitForProgress(id, () => __awaiter(this, void 0, void 0, function* () {
+                    return this.progresses[id] || null;
+                }), 25)
+            ]);
+        });
     }
-    unlink() {
+    get(id) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.load();
-            if (!this.progressId) {
-                yield this.collection.deleteOne({ _id: this.mId });
-            }
-            return deleteFromBucket(this.assets.bucket, new ObjectId$1(this.assetId));
+            return !id ? null : this.find({ _id: new ObjectId$1(id) });
         });
     }
-    startWorking() {
-        this.load().then(() => {
-            if (this.deleted)
-                return;
-            this.progresses.get(this.progressId).then(p => {
-                p === null || p === void 0 ? void 0 : p.cancel();
-            });
-            this.startWorkingOnAsset(false).then(() => {
-                this.logger.log("lazy-assets", `Started working on lazy asset: ${this.id}`);
-            }).catch(reason => {
-                this.logger.log("lazy-assets", `Can't start working on lazy asset: ${this.id}\nReason: ${reason}`);
-            });
+    find(where) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.collection.findOne(where);
+            return !data ? null : new Progress(data._id, data, this.collection);
         });
     }
-    loadAsset() {
+    create(max = 100) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.load();
-            if (this.deleted)
-                return null;
-            if (this.assetId) {
-                return this.assets.read(this.assetId);
-            }
-            if (this.progressId) {
-                yield this.progresses.waitToFinish(this.progressId);
-                return this.loadAsset();
+            if (isNaN(max) || max <= 0) {
+                throw new Error(`Max progress value must be bigger than zero`);
             }
-            yield this.startWorkingOnAsset(true);
-            return this.loadAsset();
+            const data = {
+                current: 0,
+                max: max,
+                message: "",
+                error: "",
+                canceled: false
+            };
+            const res = yield this.collection.insertOne(data);
+            return new Progress(res.insertedId, data, this.collection);
         });
     }
-    writeAsset(asset) {
+    remove(id) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.data.assetId = asset.id;
-            yield this.save();
-            return asset;
+            yield this.collection.deleteOne({ _id: new ObjectId$1(id) });
+            return id;
         });
     }
-    startWorkingOnAsset(fromLoad) {
+    waitForProgress(id, cb, delay) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.data.progressId = (yield this.progresses.create()).id;
-            this.data.assetId = null;
-            yield this.save();
-            yield this.progresses.jobMan.enqueueWithName(this.data.jobName, Object.assign(Object.assign({}, this.data.jobParams), { lazyId: this.id, fromLoad }));
+            let isFinished = false;
+            let progress = null;
+            let waitTime = 0;
+            while (!isFinished) {
+                progress = yield cb();
+                waitTime += delay;
+                if (progress) {
+                    if (progress.error) {
+                        throw new Error(progress.error);
+                    }
+                    isFinished = progress.percent >= 100;
+                }
+                if (!isFinished) {
+                    if (waitTime >= this.jobMan.maxTimeout) {
+                        throw new Error(`Progress with id: ${id} probably never will be finished!`);
+                    }
+                    yield promiseTimeout(delay);
+                }
+            }
+            return progress;
         });
     }
-}
+};
+Progresses = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [MongoConnector, JobManager])
+], Progresses);
 
 let LazyAssets = class LazyAssets {
     constructor(connector, assets, progresses, logger, jobMan) {
@@ -1856,613 +1831,505 @@ let LazyAssets = class LazyAssets {
             const data = yield this.collection.findOne(where);
             return !data
                 ? null
-                : new LazyAsset(data._id, data, this.collection, this.logger, this.assets, this.progresses);
-        });
-    }
-    unlink(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const asset = yield this.read(id);
-            if (!asset)
-                return null;
-            return asset.unlink();
-        });
-    }
-};
-LazyAssets = __decorate([
-    injectable(),
-    scoped(Lifecycle.ContainerScoped)
-], LazyAssets);
-
-let Logger = class Logger {
-    constructor(config) {
-        this.config = config;
-        this.tags = this.config.resolve("logTags");
-        this.ignoredTags = this.config.resolve("ignoredLogTags");
-    }
-    log(tag, ...params) {
-        if (this.ignoredTags.includes(tag))
-            return;
-        if (this.tags.length === 0 || this.tags.includes(tag)) {
-            console.log(`[${tag}]`, ...params);
-        }
-    }
-};
-Logger = __decorate([
-    singleton()
-], Logger);
-
-let MailSender = class MailSender {
-    constructor(config, renderer) {
-        this.config = config;
-        this.renderer = renderer;
-        this.transporter = createTransport({
-            host: this.config.resolve("smtpHost"),
-            port: this.config.resolve("smtpPort"),
-            auth: {
-                user: this.config.resolve("smtpUser"),
-                pass: this.config.resolve("smtpPassword"),
-            }
-        });
-    }
-    get translator() {
-        return this.renderer.translator;
-    }
-    sendMail(language, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const subject = yield this.translator.getTranslation(language, options.subject || "-");
-            const html = yield this.renderer.render(options.template, language, options.context);
-            return this.transporter.sendMail({
-                from: options.from || this.config.resolve("mailSenderAddress"),
-                to: options.to,
-                attachments: options.attachments,
-                subject,
-                html
-            });
-        });
-    }
-};
-MailSender = __decorate([
-    singleton()
-], MailSender);
-
-let MemoryCache = class MemoryCache {
-    constructor(cache) {
-        this.cache = cache;
-        this.cacheMap = new Map();
-    }
-    set(key, value, ttl, expirationTimestamp = null, tags = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const now = Math.round(new Date().getTime() / 1000);
-            const expTimestamp = Math.min(isNaN(ttl) ? Number.MAX_SAFE_INTEGER : ttl, 3600);
-            this.cacheMap.set(key, {
-                _id: key,
-                data: value,
-                expirationTimestamp: expTimestamp,
-                expiresAt: now + expTimestamp,
-            });
-            return this.cache.set(key, value, ttl, expirationTimestamp, tags);
-        });
-    }
-    get(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let item = this.cacheMap.get(key);
-            const now = Math.round(new Date().getTime() / 1000);
-            let expTimestamp = 3600;
-            if (item && item.expiresAt && item.expiresAt < now) {
-                expTimestamp = item.expirationTimestamp;
-                item = null;
-            }
-            if (!item) {
-                const value = yield this.cache.get(key);
-                this.cacheMap.set(key, {
-                    _id: key,
-                    data: value,
-                    expirationTimestamp: expTimestamp,
-                    expiresAt: now + expTimestamp,
-                });
-                return value;
-            }
-            return item.data;
-        });
-    }
-    getOrSet(key, valueCb, ttl, expirationTimestamp = null, tags = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this.get(key);
-            }
-            catch (e) {
-                return yield this.set(key, yield valueCb(), ttl, expirationTimestamp, tags);
-            }
+                : new LazyAsset(data._id, data, this.collection, this.logger, this.assets, this.progresses);
         });
     }
-    delete(key) {
+    unlink(id) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.cacheMap.delete(key);
-            yield this.cacheMap.delete(key);
+            const asset = yield this.read(id);
+            if (!asset)
+                return null;
+            return asset.unlink();
         });
     }
 };
-MemoryCache = __decorate([
+LazyAssets = __decorate([
     injectable(),
-    scoped(Lifecycle.ContainerScoped)
-], MemoryCache);
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [MongoConnector,
+        Assets,
+        Progresses,
+        Logger,
+        JobManager])
+], LazyAssets);
 
-let MongoConnector = class MongoConnector {
-    constructor(configuration) {
-        this.configuration = configuration;
-        this.conn = null;
-        this.db = null;
-        this.fsBucket = null;
-    }
-    get connection() {
-        return this.conn;
-    }
-    get database() {
-        return this.db;
-    }
-    get bucket() {
-        return this.fsBucket;
+let AssetResolver = class AssetResolver {
+    constructor(assets, lazyAssets) {
+        this.assets = assets;
+        this.lazyAssets = lazyAssets;
     }
-    connect() {
+    resolve(id, lazy = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.db)
-                return this.db;
-            this.conn = (yield connect(this.configuration.resolve("mongoUri"), {
-                dbName: this.configuration.resolve("mongoDb"),
-                user: this.configuration.resolve("mongoUser"),
-                pass: this.configuration.resolve("mongoPassword")
-            })).connection;
-            this.db = this.conn.db;
-            this.fsBucket = new GridFSBucket(this.db, { bucketName: "assets" });
-        });
-    }
-};
-MongoConnector = __decorate([
-    singleton()
-], MongoConnector);
-
-function checkValue(multi, value) {
-    if (multi) {
-        return Array.isArray(value) && value.every(v => {
-            try {
-                const id = new ObjectId$1(v);
-                return id instanceof ObjectId$1;
+            let asset = null;
+            if (lazy) {
+                const lazyAsset = yield this.lazyAssets.read(id);
+                if (!lazyAsset)
+                    return null;
+                return lazyAsset.loadAsset();
             }
-            catch (e) {
-                return false;
+            asset = yield this.assets.read(id);
+            if (!asset) {
+                const lazyAsset = yield this.lazyAssets.read(id);
+                if (!lazyAsset)
+                    return null;
+                return lazyAsset.loadAsset();
             }
+            return asset;
         });
     }
-    if (null === value)
-        return true;
-    try {
-        const id = new ObjectId$1(value);
-        return id instanceof ObjectId$1;
-    }
-    catch (e) {
-        return false;
-    }
-}
-let IsFile = class IsFile {
-    validate(value, validationArguments) {
-        const [multi] = (validationArguments.constraints || []);
-        return checkValue(multi, value);
-    }
-};
-IsFile = __decorate([
-    ValidatorConstraint()
-], IsFile);
-let IsObjectId = class IsObjectId {
-    validate(value, validationArguments) {
-        const [_, multi] = (validationArguments.constraints || []);
-        return checkValue(multi, value);
-    }
 };
-IsObjectId = __decorate([
-    ValidatorConstraint()
-], IsObjectId);
+AssetResolver = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [Assets, LazyAssets])
+], AssetResolver);
 
-let OpenApi = class OpenApi {
-    constructor(container, customValidation) {
-        this.container = container;
-        this.customValidation = customValidation;
-        this.docs = null;
-    }
-    get apiDocs() {
-        if (!this.docs)
-            this.docs = this.createApiDocs();
-        return this.docs;
+const express = express_;
+let BackendProvider = class BackendProvider {
+    constructor() {
+        this.express = express();
+        this.express.set("trust proxy", true);
+        this.server = createServer(this.express);
     }
-    get apiDocsStr() {
-        if (!this.docsStr)
-            this.docsStr = JSON.stringify(this.apiDocs);
-        return this.docsStr;
+    get io() {
+        this.ioServer = this.ioServer || new Server(this.server, { path: "/socket" });
+        return this.ioServer;
     }
-    schemaToExample(src, req) {
-        var _a, _b, _c;
+};
+BackendProvider = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [])
+], BackendProvider);
+
+let CacheProcessor = class CacheProcessor {
+    serialize(data) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (src.$ref) {
-                const schemas = this.apiDocs.components.schemas;
-                const schema = src.$ref
-                    .replace("#/components/schemas/", "")
-                    .replace("#/definitions/", "");
-                return this.schemaToExample(schemas[schema], req);
-            }
-            let schema = src;
-            if (schema.oneOf) {
-                schema = Object.assign({}, schema, schema.oneOf[0]);
-            }
-            if (schema.type === "object") {
-                const result = {};
-                yield Promise.all(Object.keys(schema.properties).map((key) => __awaiter(this, void 0, void 0, function* () {
-                    result[key] = yield this.schemaToExample(schema.properties[key], req);
-                })));
-                return result;
-            }
-            if (schema.type === "array") {
-                return [yield this.schemaToExample(schema.items, req)];
-            }
-            if (schema.type === "string") {
-                if (isDefined(schema.default)) {
-                    if (isFunction(schema.default)) {
-                        return schema.default(this.container);
-                    }
-                    return schema.default;
-                }
-                if (schema.format == "date") {
-                    return new Date().toISOString().substr(0, 10);
-                }
-                if (schema.format == "date-time") {
-                    return new Date().toISOString();
-                }
-                if (schema.enum) {
-                    return schema.enum[0];
-                }
-                return "string";
-            }
-            if (schema.type === "number") {
-                return (_a = schema.default) !== null && _a !== void 0 ? _a : 0;
-            }
-            else if (schema.type === "boolean") {
-                return (_b = schema.default) !== null && _b !== void 0 ? _b : false;
-            }
-            else {
-                return (_c = schema.default) !== null && _c !== void 0 ? _c : null;
-            }
+            return data;
         });
     }
-    createApiDocs() {
-        const storage = getMetadataArgsStorage();
-        const docs = routingControllersToSpec(storage);
-        docs.basePath = "/api/";
-        docs.definitions = validationMetadatasToSchemas({
-            additionalConverters: {
-                [ValidationTypes.CUSTOM_VALIDATION]: (meta, options) => {
-                    const res = isFunction(this.customValidation) ? this.customValidation(meta, options) : this.customValidation;
-                    if (isObject(res))
-                        return res;
-                    const constraints = meta.constraints || [];
-                    if (meta.constraintCls === IsFile) {
-                        return {
-                            multi: constraints[0] || false,
-                            type: "file"
-                        };
-                    }
-                    if (meta.constraintCls === IsObjectId) {
-                        return {
-                            endpoint: constraints[0] || false,
-                            multi: constraints[1] || false,
-                            type: "list"
-                        };
-                    }
-                    return null;
-                }
-            }
+    deserialize(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return data;
         });
-        docs.components.schemas = docs.definitions;
-        return docs;
     }
 };
-OpenApi = __decorate([
-    singleton(),
-    __param(0, inject(DI_CONTAINER)),
-    __param(1, inject(OPENAPI_VALIDATION))
-], OpenApi);
+CacheProcessor = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], CacheProcessor);
 
-class Progress extends BaseEntity {
-    constructor(id, data, collection) {
-        super(id, data, collection);
-    }
-    get current() {
-        return this.data.current;
-    }
-    get max() {
-        return this.data.max;
-    }
-    get message() {
-        return this.data.message;
-    }
-    get error() {
-        return this.data.error;
-    }
-    get canceled() {
-        return this.data.canceled;
-    }
-    get percent() {
-        return this.max > 0 ? Math.round(this.current / this.max * 100) : 0;
-    }
-    get remaining() {
-        return this.max > 0 ? this.max - this.current : 0;
+let Cache = class Cache {
+    constructor(connector, config, cacheProcessor) {
+        this.connector = connector;
+        this.config = config;
+        this.cacheProcessor = cacheProcessor;
     }
-    setMessageBridge(messageBridge) {
-        this.messageBridge = messageBridge || this.messageBridge;
-        return this;
+    prepare() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.collection)
+                return;
+            if (!this.connector.database) {
+                throw new Error(`You can't use cache without mongo connection!`);
+            }
+            this.collection = this.connector.database.collection(this.config.resolve("cacheCollection"));
+            yield this.collection.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+        });
     }
-    createSubProgress(progressValue, max, message) {
+    set(key, value, ttl, expirationTimestamp = null, tags = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (max <= 0 && progressValue > 0) {
-                yield this.advance(progressValue);
+            yield this.prepare();
+            const item = {
+                _id: key,
+                data: yield this.cacheProcessor.serialize(value),
+                tags: yield this.cacheProcessor.serialize(tags),
+                expirationTimestamp,
+            };
+            if (ttl) {
+                const now = Math.round(new Date().getTime() / 1000);
+                item.expiresAt = now + ttl;
             }
-            if (message !== null) {
-                this.data.message = message;
-                yield this.save();
+            yield this.collection.updateOne({ _id: key }, { $set: item }, { upsert: true });
+            return value;
+        });
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.prepare();
+            let item = yield this.collection.findOne({ _id: key });
+            const now = Math.round(new Date().getTime() / 1000);
+            if (item && item.expiresAt && item.expiresAt < now) {
+                item = null;
             }
-            return new SubProgress(this, this.current, progressValue, Math.max(max, 1));
+            if (!item) {
+                throw new Error(`Cache probably doesn't exists with key: ${key}`);
+            }
+            return yield this.cacheProcessor.deserialize(item.data);
         });
     }
-    setMax(max) {
+    getOrSet(key, valueCb, ttl, expirationTimestamp = null, tags = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (isNaN(max) || max <= 0) {
-                throw "Max progress value must be bigger than zero";
+            try {
+                return yield this.get(key);
+            }
+            catch (e) {
+                return yield this.set(key, yield valueCb(), ttl, expirationTimestamp, tags);
             }
-            this.data.max = max;
-            yield this.save();
         });
     }
-    setMessage(message) {
+    delete(key) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.data.message = message;
-            yield this.save();
+            yield this.prepare();
+            yield this.collection.deleteOne({ _id: key });
         });
     }
-    setError(error) {
+};
+Cache = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [MongoConnector, Configuration, CacheProcessor])
+], Cache);
+
+let EndpointProvider = class EndpointProvider {
+    configure(app) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.data.error = error;
-            yield this.save();
+            console.log(`Express app is mounted to: ${app.mountpath}`);
         });
     }
-    advance(value = 1) {
+};
+EndpointProvider = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], EndpointProvider);
+
+let Fixtures = class Fixtures {
+    constructor(fixtures) {
+        this.fixtures = fixtures;
+    }
+    load(output) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (isNaN(value) || value <= 0) {
-                throw new Error(`Advance value must be bigger than zero: ${this.id}`);
+            if (!this.fixtures)
+                return;
+            output = output || {
+                write: console.log,
+                writeln: t => console.log(t + "\n")
+            };
+            for (let fixture of this.fixtures) {
+                yield fixture.load(output);
             }
-            yield this.load();
-            if (this.deleted || this.canceled) {
-                const status = this.deleted ? "deleted" : "canceled";
-                throw new Error(`Can't advance ${status} progress: ${this.id}`);
+        });
+    }
+};
+Fixtures = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __param(0, injectAll(FIXTURE)),
+    __metadata("design:paramtypes", [Array])
+], Fixtures);
+
+const sharp$1 = sharp_;
+const bigSize = 1500;
+const thumbSize = 250;
+class GalleryImage {
+    constructor(folder, size, handler) {
+        this.folder = folder;
+        this.handler = handler;
+        this.thumb = v4();
+        this.big = v4();
+        this.targetSize = !size ? { width: thumbSize, height: thumbSize } : size;
+    }
+    serve(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isThumb = id == this.thumb;
+            if (yield this.handler.hasResult(isThumb)) {
+                return this.handler.serveResult(isThumb);
             }
-            this.data.current = Math.min(this.max, this.current + value);
-            yield this.save();
+            const original = sharp$1(yield this.handler.getOriginal()).rotate();
+            const meta = yield original.metadata();
+            const ratio = meta.width / meta.height;
+            const sizeRatio = isThumb ? this.targetSize.width / this.targetSize.height : 1;
+            const size = isThumb ? Math.max(this.targetSize.width, this.targetSize.height) : bigSize;
+            const targetHeight = ratio > sizeRatio ? size : Math.round(size / ratio);
+            const targetWidth = Math.round(targetHeight * ratio);
+            const resized = original.resize(targetWidth, targetHeight);
+            const buffer = yield (isThumb ? resized.extract({
+                left: Math.floor((targetWidth - this.targetSize.width) / 2),
+                top: Math.floor((targetHeight - this.targetSize.height) / 2),
+                width: this.targetSize.width,
+                height: this.targetSize.height
+            }).toBuffer() : resized.toBuffer());
+            yield this.handler.writeResult(isThumb, buffer);
+            return this.handler.serveResult(isThumb);
         });
     }
-    cancel() {
+}
+
+let GalleryCache = class GalleryCache {
+    constructor() {
+        this.imgCache = {};
+    }
+    put(img) {
+        this.imgCache[img.thumb] = img;
+        this.imgCache[img.big] = img;
+    }
+    serve(id) {
+        const img = this.imgCache[id];
+        return !img ? null : img.serve(id);
+    }
+    create(folder, targetSize, handler) {
+        const image = new GalleryImage(folder, targetSize, handler);
+        this.put(image);
+        return image;
+    }
+};
+GalleryCache = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [])
+], GalleryCache);
+
+const sharp = sharp_;
+let Gallery = class Gallery {
+    constructor(config, galleryCache) {
+        this.config = config;
+        this.galleryCache = galleryCache;
+        this.cache = {};
+        this.dir = this.config.resolve("galleryDir");
+        this.output = join(this.config.resolve("cacheDir"), "gallery");
+    }
+    getFolder(folder, size = null) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.data.canceled = true;
-            yield this.save();
+            this.cache[folder] = this.cache[folder] || new Promise(resolve => {
+                lstat(join(this.dir, folder), (err, stats) => {
+                    if (err || !stats.isDirectory()) {
+                        resolve([]);
+                        return;
+                    }
+                    this.readRecursive(folder, "", size).then(resolve, () => resolve([]));
+                });
+            });
+            return this.cache[folder];
+        });
+    }
+    readRecursive(path, folder, size) {
+        return new Promise(resolve => {
+            readdir(join(this.dir, path), (err, files) => {
+                if (err) {
+                    resolve([]);
+                    return;
+                }
+                const promises = files.map(file => {
+                    return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                        const filePath = join(path, file);
+                        const absoluteFilePath = join(this.dir, filePath);
+                        lstat(absoluteFilePath, (err, stats) => {
+                            if (err) {
+                                resolve([]);
+                                return;
+                            }
+                            if (stats.isDirectory()) {
+                                this.readRecursive(filePath, join(folder, file), size).then(resolve);
+                                return;
+                            }
+                            const sharpImg = sharp(absoluteFilePath);
+                            sharpImg.rotate().metadata().then(() => {
+                                const getResultPath = (isThumb) => {
+                                    return join(this.output, filePath.replace(/.([a-z|A-Z]+)$/gi, function (ext) {
+                                        const suffix = isThumb ? 'thumb' : 'big';
+                                        return `-${suffix}${ext}`;
+                                    }));
+                                };
+                                resolve([this.galleryCache.create(folder, size, {
+                                        getOriginal: () => {
+                                            return new Promise((res, rej) => {
+                                                readFile$1(absoluteFilePath, (err, data) => {
+                                                    if (err) {
+                                                        rej(err);
+                                                        return;
+                                                    }
+                                                    res(data);
+                                                });
+                                            });
+                                        },
+                                        writeResult: (isThumb, buffer) => {
+                                            return new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
+                                                const resultPath = getResultPath(isThumb);
+                                                yield mkdirRecursive(dirname(resultPath));
+                                                writeFile$1(resultPath, buffer, err => {
+                                                    if (err) {
+                                                        rej(err);
+                                                        return;
+                                                    }
+                                                    res();
+                                                });
+                                            }));
+                                        },
+                                        hasResult: (isThumb) => {
+                                            return new Promise(res => {
+                                                access(getResultPath(isThumb), constants.R_OK, err => {
+                                                    res(!err);
+                                                });
+                                            });
+                                        },
+                                        serveResult: (isThumb) => {
+                                            return new Promise((res, rej) => {
+                                                readFile$1(getResultPath(isThumb), (err, data) => {
+                                                    if (err) {
+                                                        rej(err);
+                                                        return;
+                                                    }
+                                                    res(data);
+                                                });
+                                            });
+                                        }
+                                    })]);
+                            }, () => resolve([]));
+                        });
+                    }));
+                });
+                Promise.all(promises).then(folders => {
+                    resolve([].concat.apply([], folders));
+                });
+            });
         });
     }
-    save() {
-        if (this.messageBridge) {
-            this.messageBridge.sendMessage(`progress-changed`, this.toJSON());
-        }
-        return super.save();
-    }
-}
-class SubProgress {
-    constructor(parent, progressFrom, progressValue, mMax = 100) {
-        this.parent = parent;
-        this.progressFrom = progressFrom;
-        this.progressValue = progressValue;
-        this.mMax = mMax;
-        if (progressFrom < 0) {
-            throw "Progress from must be bigger than or zero";
-        }
-        if (progressValue <= 0) {
-            throw "Progress value must be bigger than zero";
-        }
-        this.mCurrent = 0;
-    }
-    get id() {
-        return this.parent.id;
-    }
-    get current() {
-        return this.mCurrent;
-    }
-    get max() {
-        return this.mMax;
-    }
-    get message() {
-        return this.parent.message;
-    }
-    get error() {
-        return this.parent.error;
-    }
-    get percent() {
-        return this.parent.percent;
-    }
-    get remaining() {
-        return this.max - this.mCurrent;
-    }
-    get canceled() {
-        return !this.parent || this.parent.canceled;
-    }
-    setMessageBridge(messageBridge) {
-        if (!this.parent)
-            return this;
-        this.parent.setMessageBridge(messageBridge);
-        return this;
+};
+Gallery = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [Configuration, GalleryCache])
+], Gallery);
+
+let IdGenerator = class IdGenerator {
+    constructor(config) {
+        this.config = config;
+        this.prefix = config.resolve("idPrefix");
+        this.separator = config.resolve("idSeparator");
+        this.chars = config.resolve("idChars");
+        this.parts = config.resolve("idParts");
     }
-    createSubProgress(progressValue, max, message) {
+    generate(checkCb) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (max <= 0 && progressValue > 0) {
-                yield this.advance(progressValue);
+            let id = null;
+            let tries = 0;
+            let notGood = true;
+            while (notGood && tries < 5) {
+                id = this.generateId();
+                notGood = yield checkCb(id);
+                tries++;
             }
-            if (message !== null) {
-                yield this.setMessage(message);
+            if (notGood) {
+                throw `Couldn't generate an unique id..`;
             }
-            return new SubProgress(this, this.current, progressValue, Math.max(max, 1));
+            return id;
         });
     }
-    setMax(max) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (isNaN(max) || max <= 0) {
-                throw "Max progress value must be bigger than zero";
+    generateId() {
+        return this.prefix + this.parts.map(num => {
+            let s = "";
+            for (let i = 0; i < num; i++) {
+                const ix = rand(0, this.chars.length - 1);
+                s += this.chars[ix];
             }
-            this.mMax = max;
-            yield this.save();
-        });
-    }
-    setMessage(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.parent)
-                return null;
-            yield this.parent.setMessage(message);
-        });
+            return s;
+        }).join(this.separator);
     }
-    setError(error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.parent)
-                return null;
-            yield this.parent.setError(error);
-        });
+};
+IdGenerator = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [Configuration])
+], IdGenerator);
+
+let TranslationProvider = class TranslationProvider {
+    constructor(config, cache) {
+        this.config = config;
+        this.cache = cache;
     }
-    advance(value = 1) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (isNaN(value) || value <= 0) {
-                throw "Advance value must be bigger than zero";
+    getDictionary(language) {
+        return this.cache.getOrSet(`translations-${language}`, () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = this.config.resolve("translationsTemplate")
+                    .replace(`__lang__`, language)
+                    .replace(`[lang]`, language);
+                const data = yield axios.get(url).then(t => t.data);
+                if (isObject(data[language])) {
+                    return data[language];
+                }
+                return data;
             }
-            this.mCurrent = Math.min(this.max, this.mCurrent + value);
-            yield this.save();
-        });
-    }
-    cancel() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.parent)
-                return null;
-            yield this.parent.cancel();
-        });
-    }
-    save() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ratio = this.max > 0 ? this.mCurrent / this.max : 0;
-            const newProgress = this.progressFrom + Math.round(this.progressValue * ratio);
-            const current = this.parent.current;
-            if (newProgress <= current)
-                return null;
-            yield this.parent.advance(newProgress);
-        });
-    }
-    load() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return null;
-        });
-    }
-    toJSON() {
-        return this.parent.toJSON();
+            catch (e) {
+                return {
+                    message: `${e}`
+                };
+            }
+        }), 5 * 60);
     }
-}
+};
+TranslationProvider = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Configuration, Cache])
+], TranslationProvider);
 
-let Progresses = class Progresses {
-    constructor(connector, jobMan) {
-        this.connector = connector;
-        this.jobMan = jobMan;
-        this.collection = connector.database.collection("progresses");
-        this.progresses = {};
-        this.jobMan.on("progress-changed", progress => {
-            const id = progress.id;
-            this.progresses[id] = new Progress(new ObjectId$1(id), progress, this.collection);
-        });
+let Translator = class Translator {
+    constructor(translationProvider) {
+        this.translationProvider = translationProvider;
+        this.dictionaries = {};
     }
-    waitToFinish(id) {
+    getDictionary(language) {
         return __awaiter(this, void 0, void 0, function* () {
-            return Promise.race([
-                this.waitForProgress(id, () => __awaiter(this, void 0, void 0, function* () {
-                    let progress = this.progresses[id];
-                    if (!progress || progress.percent < 100) {
-                        progress = yield this.get(id);
-                    }
-                    if (!progress) {
-                        throw new Error(`Progress does not exists with id: ${id}`);
-                    }
-                    return progress;
-                }), 500),
-                this.waitForProgress(id, () => __awaiter(this, void 0, void 0, function* () {
-                    return this.progresses[id] || null;
-                }), 25)
-            ]);
+            this.dictionaries[language] = yield this.translationProvider.getDictionary(language);
+            return this.dictionaries[language];
         });
     }
-    get(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return !id ? null : this.find({ _id: new ObjectId$1(id) });
-        });
+    getTranslationSync(language, key, params) {
+        if (!isString(key) || !key.length) {
+            throw new Error(`Parameter "key" required`);
+        }
+        const dictionary = this.dictionaries[language];
+        const translation = getValue(dictionary, key, key) || key;
+        return this.interpolate(translation, params);
     }
-    find(where) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = yield this.collection.findOne(where);
-            return !data ? null : new Progress(data._id, data, this.collection);
+    getTranslation(language, key, params) {
+        if (!isString(key) || !key.length) {
+            throw new Error(`Parameter "key" required`);
+        }
+        return this.getDictionary(language).then(dictionary => {
+            const translation = getValue(dictionary, key, key) || key;
+            return this.interpolate(translation, params);
         });
     }
-    create(max = 100) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (isNaN(max) || max <= 0) {
-                throw new Error(`Max progress value must be bigger than zero`);
-            }
-            const data = {
-                current: 0,
-                max: max,
-                message: "",
-                error: "",
-                canceled: false
-            };
-            const res = yield this.collection.insertOne(data);
-            return new Progress(res.insertedId, data, this.collection);
+    getTranslations(language, ...keys) {
+        return new Promise(resolve => {
+            Promise.all(keys.map(key => this.getTranslation(language, key))).then(translations => {
+                resolve(keys.reduce((result, key, i) => {
+                    result[key] = translations[i];
+                    return result;
+                }, {}));
+            });
         });
     }
-    remove(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.collection.deleteOne({ _id: new ObjectId$1(id) });
-            return id;
-        });
+    interpolate(expr, params) {
+        if (typeof expr === "string") {
+            return this.interpolateString(expr, params);
+        }
+        if (typeof expr === "function") {
+            return expr(params);
+        }
+        return expr;
     }
-    waitForProgress(id, cb, delay) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let isFinished = false;
-            let progress = null;
-            let waitTime = 0;
-            while (!isFinished) {
-                progress = yield cb();
-                waitTime += delay;
-                if (progress) {
-                    if (progress.error) {
-                        throw new Error(progress.error);
-                    }
-                    isFinished = progress.percent >= 100;
-                }
-                if (!isFinished) {
-                    if (waitTime >= this.jobMan.maxTimeout) {
-                        throw new Error(`Progress with id: ${id} probably never will be finished!`);
-                    }
-                    yield promiseTimeout(delay);
-                }
-            }
-            return progress;
+    interpolateString(expr, params) {
+        if (!expr || !params)
+            return expr;
+        return expr.replace(/{{\s?([^{}\s]*)\s?}}/g, (substring, b) => {
+            const r = getValue(params, b);
+            return isDefined(r) ? r : substring;
         });
     }
 };
-Progresses = __decorate([
-    singleton()
-], Progresses);
+Translator = __decorate([
+    injectable(),
+    singleton(),
+    __metadata("design:paramtypes", [TranslationProvider])
+], Translator);
 
 let TemplateRenderer = class TemplateRenderer {
     constructor(translator, config) {
@@ -2504,27 +2371,275 @@ let TemplateRenderer = class TemplateRenderer {
                         this.templates[fullName] = Handlebars.compile(content);
                         Handlebars.registerPartial(fullName, content);
                     }
-                    resolve();
-                }));
-            });
+                    resolve();
+                }));
+            });
+        });
+    }
+    render(template, language, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.init();
+            yield this.translator.getDictionary(language);
+            if (!this.templates[template]) {
+                return Promise.reject(`Template not found with name: ${template}`);
+            }
+            context = Object.assign({ language }, context || {});
+            const res = this.templates[template](context);
+            return res instanceof Error ? yield Promise.reject(res) : res;
+        });
+    }
+};
+TemplateRenderer = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Translator, Configuration])
+], TemplateRenderer);
+
+let MailSender = class MailSender {
+    constructor(config, renderer) {
+        this.config = config;
+        this.renderer = renderer;
+        this.transporter = createTransport({
+            host: this.config.resolve("smtpHost"),
+            port: this.config.resolve("smtpPort"),
+            auth: {
+                user: this.config.resolve("smtpUser"),
+                pass: this.config.resolve("smtpPassword"),
+            }
+        });
+    }
+    get translator() {
+        return this.renderer.translator;
+    }
+    sendMail(language, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const subject = yield this.translator.getTranslation(language, options.subject || "-");
+            const html = yield this.renderer.render(options.template, language, options.context);
+            return this.transporter.sendMail({
+                from: options.from || this.config.resolve("mailSenderAddress"),
+                to: options.to,
+                attachments: options.attachments,
+                subject,
+                html
+            });
+        });
+    }
+};
+MailSender = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Configuration, TemplateRenderer])
+], MailSender);
+
+let MemoryCache = class MemoryCache {
+    constructor(cache) {
+        this.cache = cache;
+        this.cacheMap = new Map();
+    }
+    set(key, value, ttl, expirationTimestamp = null, tags = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const now = Math.round(new Date().getTime() / 1000);
+            const expTimestamp = Math.min(isNaN(ttl) ? Number.MAX_SAFE_INTEGER : ttl, 3600);
+            this.cacheMap.set(key, {
+                _id: key,
+                data: value,
+                expirationTimestamp: expTimestamp,
+                expiresAt: now + expTimestamp,
+            });
+            return this.cache.set(key, value, ttl, expirationTimestamp, tags);
+        });
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let item = this.cacheMap.get(key);
+            const now = Math.round(new Date().getTime() / 1000);
+            let expTimestamp = 3600;
+            if (item && item.expiresAt && item.expiresAt < now) {
+                expTimestamp = item.expirationTimestamp;
+                item = null;
+            }
+            if (!item) {
+                const value = yield this.cache.get(key);
+                this.cacheMap.set(key, {
+                    _id: key,
+                    data: value,
+                    expirationTimestamp: expTimestamp,
+                    expiresAt: now + expTimestamp,
+                });
+                return value;
+            }
+            return item.data;
+        });
+    }
+    getOrSet(key, valueCb, ttl, expirationTimestamp = null, tags = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.get(key);
+            }
+            catch (e) {
+                return yield this.set(key, yield valueCb(), ttl, expirationTimestamp, tags);
+            }
+        });
+    }
+    delete(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.cacheMap.delete(key);
+            yield this.cacheMap.delete(key);
+        });
+    }
+};
+MemoryCache = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [Cache])
+], MemoryCache);
+
+function checkValue(multi, value) {
+    if (multi) {
+        return Array.isArray(value) && value.every(v => {
+            try {
+                const id = new ObjectId$1(v);
+                return id instanceof ObjectId$1;
+            }
+            catch (e) {
+                return false;
+            }
+        });
+    }
+    if (null === value)
+        return true;
+    try {
+        const id = new ObjectId$1(value);
+        return id instanceof ObjectId$1;
+    }
+    catch (e) {
+        return false;
+    }
+}
+let IsFile = class IsFile {
+    validate(value, validationArguments) {
+        const [multi] = (validationArguments.constraints || []);
+        return checkValue(multi, value);
+    }
+};
+IsFile = __decorate([
+    ValidatorConstraint()
+], IsFile);
+let IsObjectId = class IsObjectId {
+    validate(value, validationArguments) {
+        const [_, multi] = (validationArguments.constraints || []);
+        return checkValue(multi, value);
+    }
+};
+IsObjectId = __decorate([
+    ValidatorConstraint()
+], IsObjectId);
+
+let OpenApi = class OpenApi {
+    constructor(container, customValidation) {
+        this.container = container;
+        this.customValidation = customValidation;
+        this.docs = null;
+    }
+    get apiDocs() {
+        if (!this.docs)
+            this.docs = this.createApiDocs();
+        return this.docs;
+    }
+    get apiDocsStr() {
+        if (!this.docsStr)
+            this.docsStr = JSON.stringify(this.apiDocs);
+        return this.docsStr;
+    }
+    schemaToExample(src, req) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (src.$ref) {
+                const schemas = this.apiDocs.components.schemas;
+                const schema = src.$ref
+                    .replace("#/components/schemas/", "")
+                    .replace("#/definitions/", "");
+                return this.schemaToExample(schemas[schema], req);
+            }
+            let schema = src;
+            if (schema.oneOf) {
+                schema = Object.assign({}, schema, schema.oneOf[0]);
+            }
+            if (schema.type === "object") {
+                const result = {};
+                yield Promise.all(Object.keys(schema.properties).map((key) => __awaiter(this, void 0, void 0, function* () {
+                    result[key] = yield this.schemaToExample(schema.properties[key], req);
+                })));
+                return result;
+            }
+            if (schema.type === "array") {
+                return [yield this.schemaToExample(schema.items, req)];
+            }
+            if (schema.type === "string") {
+                if (isDefined(schema.default)) {
+                    if (isFunction(schema.default)) {
+                        return schema.default(this.container);
+                    }
+                    return schema.default;
+                }
+                if (schema.format == "date") {
+                    return new Date().toISOString().substr(0, 10);
+                }
+                if (schema.format == "date-time") {
+                    return new Date().toISOString();
+                }
+                if (schema.enum) {
+                    return schema.enum[0];
+                }
+                return "string";
+            }
+            if (schema.type === "number") {
+                return (_a = schema.default) !== null && _a !== void 0 ? _a : 0;
+            }
+            else if (schema.type === "boolean") {
+                return (_b = schema.default) !== null && _b !== void 0 ? _b : false;
+            }
+            else {
+                return (_c = schema.default) !== null && _c !== void 0 ? _c : null;
+            }
         });
     }
-    render(template, language, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.init();
-            yield this.translator.getDictionary(language);
-            if (!this.templates[template]) {
-                return Promise.reject(`Template not found with name: ${template}`);
+    createApiDocs() {
+        const storage = getMetadataArgsStorage();
+        const docs = routingControllersToSpec(storage);
+        docs.basePath = "/api/";
+        docs.definitions = validationMetadatasToSchemas({
+            additionalConverters: {
+                [ValidationTypes.CUSTOM_VALIDATION]: (meta, options) => {
+                    const res = isFunction(this.customValidation) ? this.customValidation(meta, options) : this.customValidation;
+                    if (isObject(res))
+                        return res;
+                    const constraints = meta.constraints || [];
+                    if (meta.constraintCls === IsFile) {
+                        return {
+                            multi: constraints[0] || false,
+                            type: "file"
+                        };
+                    }
+                    if (meta.constraintCls === IsObjectId) {
+                        return {
+                            endpoint: constraints[0] || false,
+                            multi: constraints[1] || false,
+                            type: "list"
+                        };
+                    }
+                    return null;
+                }
             }
-            context = Object.assign({ language }, context || {});
-            const res = this.templates[template](context);
-            return res instanceof Error ? yield Promise.reject(res) : res;
         });
+        docs.components.schemas = docs.definitions;
+        return docs;
     }
 };
-TemplateRenderer = __decorate([
-    singleton()
-], TemplateRenderer);
+OpenApi = __decorate([
+    singleton(),
+    __param(0, inject(DI_CONTAINER)),
+    __param(1, inject(OPENAPI_VALIDATION)),
+    __metadata("design:paramtypes", [Object, Object])
+], OpenApi);
 
 let TerminalManager = class TerminalManager {
     constructor(logger, config, commands) {
@@ -2587,7 +2702,9 @@ let TerminalManager = class TerminalManager {
 };
 TerminalManager = __decorate([
     singleton(),
-    __param(2, injectAll(TERMINAL_COMMAND))
+    __param(2, injectAll(TERMINAL_COMMAND)),
+    __metadata("design:paramtypes", [Logger,
+        Configuration, Array])
 ], TerminalManager);
 
 let TokenGenerator = class TokenGenerator {
@@ -2620,99 +2737,10 @@ let TokenGenerator = class TokenGenerator {
     }
 };
 TokenGenerator = __decorate([
-    singleton()
+    singleton(),
+    __metadata("design:paramtypes", [])
 ], TokenGenerator);
 
-let TranslationProvider = class TranslationProvider {
-    constructor(config, cache) {
-        this.config = config;
-        this.cache = cache;
-    }
-    getDictionary(language) {
-        return this.cache.getOrSet(`translations-${language}`, () => __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = this.config.resolve("translationsTemplate")
-                    .replace(`__lang__`, language)
-                    .replace(`[lang]`, language);
-                const data = yield axios.get(url).then(t => t.data);
-                if (isObject(data[language])) {
-                    return data[language];
-                }
-                return data;
-            }
-            catch (e) {
-                return {
-                    message: `${e}`
-                };
-            }
-        }), 5 * 60);
-    }
-};
-TranslationProvider = __decorate([
-    singleton()
-], TranslationProvider);
-
-let Translator = class Translator {
-    constructor(translationProvider) {
-        this.translationProvider = translationProvider;
-        this.dictionaries = {};
-    }
-    getDictionary(language) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.dictionaries[language] = yield this.translationProvider.getDictionary(language);
-            return this.dictionaries[language];
-        });
-    }
-    getTranslationSync(language, key, params) {
-        if (!isString(key) || !key.length) {
-            throw new Error(`Parameter "key" required`);
-        }
-        const dictionary = this.dictionaries[language];
-        const translation = getValue(dictionary, key, key) || key;
-        return this.interpolate(translation, params);
-    }
-    getTranslation(language, key, params) {
-        if (!isString(key) || !key.length) {
-            throw new Error(`Parameter "key" required`);
-        }
-        return this.getDictionary(language).then(dictionary => {
-            const translation = getValue(dictionary, key, key) || key;
-            return this.interpolate(translation, params);
-        });
-    }
-    getTranslations(language, ...keys) {
-        return new Promise(resolve => {
-            Promise.all(keys.map(key => this.getTranslation(language, key))).then(translations => {
-                resolve(keys.reduce((result, key, i) => {
-                    result[key] = translations[i];
-                    return result;
-                }, {}));
-            });
-        });
-    }
-    interpolate(expr, params) {
-        if (typeof expr === "string") {
-            return this.interpolateString(expr, params);
-        }
-        if (typeof expr === "function") {
-            return expr(params);
-        }
-        return expr;
-    }
-    interpolateString(expr, params) {
-        if (!expr || !params)
-            return expr;
-        return expr.replace(/{{\s?([^{}\s]*)\s?}}/g, (substring, b) => {
-            const r = getValue(params, b);
-            return isDefined(r) ? r : substring;
-        });
-    }
-};
-Translator = __decorate([
-    injectable(),
-    singleton()
-], Translator);
-
 const sampleUser = {
     id: "5a3cdf7c6a9cf0ba32feccdf",
     email: "admin@site.com",
@@ -2743,6 +2771,66 @@ UserManager = __decorate([
     scoped(Lifecycle.ContainerScoped)
 ], UserManager);
 
+class AssetImageParams {
+    constructor() {
+        this.rotation = 0;
+        this.canvasScaleX = 1;
+        this.canvasScaleY = 1;
+        this.scaleX = 1;
+        this.scaleY = 1;
+        this.lazy = false;
+        this.crop = false;
+        this.cropBefore = false;
+        this.cropAfter = false;
+    }
+}
+__decorate([
+    Min(-360),
+    Max(360),
+    IsOptional(),
+    __metadata("design:type", Number)
+], AssetImageParams.prototype, "rotation", void 0);
+__decorate([
+    Min(0.0001),
+    IsOptional(),
+    __metadata("design:type", Number)
+], AssetImageParams.prototype, "canvasScaleX", void 0);
+__decorate([
+    Min(0.0001),
+    IsOptional(),
+    __metadata("design:type", Number)
+], AssetImageParams.prototype, "canvasScaleY", void 0);
+__decorate([
+    Min(0.0001),
+    IsOptional(),
+    __metadata("design:type", Number)
+], AssetImageParams.prototype, "scaleX", void 0);
+__decorate([
+    Min(0.0001),
+    IsOptional(),
+    __metadata("design:type", Number)
+], AssetImageParams.prototype, "scaleY", void 0);
+__decorate([
+    IsBoolean(),
+    IsOptional(),
+    __metadata("design:type", Boolean)
+], AssetImageParams.prototype, "lazy", void 0);
+__decorate([
+    IsBoolean(),
+    IsOptional(),
+    __metadata("design:type", Boolean)
+], AssetImageParams.prototype, "crop", void 0);
+__decorate([
+    IsBoolean(),
+    IsOptional(),
+    __metadata("design:type", Boolean)
+], AssetImageParams.prototype, "cropBefore", void 0);
+__decorate([
+    IsBoolean(),
+    IsOptional(),
+    __metadata("design:type", Boolean)
+], AssetImageParams.prototype, "cropAfter", void 0);
+
 let AssetsController = class AssetsController {
     constructor(assets, assetResolver) {
         this.assets = assets;
@@ -2842,46 +2930,68 @@ let AssetsController = class AssetsController {
 __decorate([
     Authorized(),
     Post(""),
-    __param(0, UploadedFile("file"))
+    __param(0, UploadedFile("file")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
 ], AssetsController.prototype, "upload", null);
 __decorate([
     Authorized(),
     Post("url"),
-    __param(0, Body())
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
 ], AssetsController.prototype, "uploadUrl", null);
 __decorate([
     Get("/:id"),
     __param(0, Param("id")),
     __param(1, QueryParam("lazy")),
-    __param(2, Res())
+    __param(2, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Boolean, Object]),
+    __metadata("design:returntype", Promise)
 ], AssetsController.prototype, "getFile", null);
 __decorate([
     Get("/image/:id/:rotation"),
     __param(0, Param("id")),
     __param(1, QueryParams()),
     __param(2, Res()),
-    __param(3, Param("rotation"))
+    __param(3, Param("rotation")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, AssetImageParams, Object, Number]),
+    __metadata("design:returntype", Promise)
 ], AssetsController.prototype, "getImageRotation", null);
 __decorate([
     Get("/image/:id"),
     __param(0, Param("id")),
     __param(1, QueryParams()),
-    __param(2, Res())
+    __param(2, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, AssetImageParams, Object]),
+    __metadata("design:returntype", Promise)
 ], AssetsController.prototype, "getImage", null);
 __decorate([
     Get("/by-name/:name"),
     __param(0, Param("name")),
-    __param(1, Res())
+    __param(1, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
 ], AssetsController.prototype, "getFileByName", null);
 __decorate([
     Get("/by-name/image/:name"),
     __param(0, Param("name")),
     __param(1, QueryParams()),
-    __param(2, Res())
+    __param(2, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, AssetImageParams, Object]),
+    __metadata("design:returntype", Promise)
 ], AssetsController.prototype, "getImageByName", null);
 AssetsController = __decorate([
     injectable(),
-    Controller("/assets")
+    Controller("/assets"),
+    __metadata("design:paramtypes", [Assets, AssetResolver])
 ], AssetsController);
 
 let AuthController = class AuthController {
@@ -2914,16 +3024,23 @@ let AuthController = class AuthController {
 __decorate([
     Post("/login"),
     __param(0, Body()),
-    __param(1, Res())
+    __param(1, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
 ], AuthController.prototype, "login", null);
 __decorate([
     Authorized(),
     Get("/user"),
-    __param(0, CurrentUser())
+    __param(0, CurrentUser()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
 ], AuthController.prototype, "getProfile", null);
 AuthController = __decorate([
     injectable(),
-    Controller()
+    Controller(),
+    __metadata("design:paramtypes", [Configuration, UserManager])
 ], AuthController);
 
 let GalleryController = class GalleryController {
@@ -2936,11 +3053,15 @@ let GalleryController = class GalleryController {
 };
 __decorate([
     Get("/:id"),
-    __param(0, Param("id"))
+    __param(0, Param("id")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
 ], GalleryController.prototype, "getFile", null);
 GalleryController = __decorate([
     injectable(),
-    Controller("/gallery")
+    Controller("/gallery"),
+    __metadata("design:paramtypes", [GalleryCache])
 ], GalleryController);
 
 let ProgressesController = class ProgressesController {
@@ -2963,11 +3084,15 @@ let ProgressesController = class ProgressesController {
 };
 __decorate([
     Get("/:id"),
-    __param(0, Param("id"))
+    __param(0, Param("id")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
 ], ProgressesController.prototype, "getProgress", null);
 ProgressesController = __decorate([
     injectable(),
-    Controller("/progresses")
+    Controller("/progresses"),
+    __metadata("design:paramtypes", [Progresses, Configuration])
 ], ProgressesController);
 
 // Add a comment hint for webstorm to style the string as css
@@ -3142,19 +3267,29 @@ let TerminalController$1 = class TerminalController {
 };
 __decorate([
     Get("/terminal"),
-    Header("Content-Type", "text/html")
+    Header("Content-Type", "text/html"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
 ], TerminalController$1.prototype, "terminal", null);
 __decorate([
     Get("/console"),
-    Header("Content-Type", "text/html")
+    Header("Content-Type", "text/html"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
 ], TerminalController$1.prototype, "console", null);
 __decorate([
     Get(),
-    Header("Content-Type", "text/html")
+    Header("Content-Type", "text/html"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", String)
 ], TerminalController$1.prototype, "generateClient", null);
 TerminalController$1 = __decorate([
     injectable(),
-    Controller()
+    Controller(),
+    __metadata("design:paramtypes", [Configuration])
 ], TerminalController$1);
 
 let ErrorHandlerMiddleware = class ErrorHandlerMiddleware {
@@ -3228,7 +3363,8 @@ let ErrorHandlerMiddleware = class ErrorHandlerMiddleware {
 };
 ErrorHandlerMiddleware = __decorate([
     injectable(),
-    Middleware({ type: "after" })
+    Middleware({ type: "after" }),
+    __metadata("design:paramtypes", [Configuration, Translator])
 ], ErrorHandlerMiddleware);
 
 let ContainerMiddleware = class ContainerMiddleware {
@@ -3243,7 +3379,8 @@ let ContainerMiddleware = class ContainerMiddleware {
 ContainerMiddleware = __decorate([
     injectable(),
     Middleware({ type: "before" }),
-    __param(0, inject(DI_CONTAINER))
+    __param(0, inject(DI_CONTAINER)),
+    __metadata("design:paramtypes", [Object])
 ], ContainerMiddleware);
 
 let LanguageMiddleware = class LanguageMiddleware {
@@ -3257,7 +3394,8 @@ let LanguageMiddleware = class LanguageMiddleware {
 };
 LanguageMiddleware = __decorate([
     injectable(),
-    Middleware({ type: "before" })
+    Middleware({ type: "before" }),
+    __metadata("design:paramtypes", [Configuration])
 ], LanguageMiddleware);
 
 let RequestEndedMiddleware = class RequestEndedMiddleware {
@@ -3275,7 +3413,8 @@ let RequestEndedMiddleware = class RequestEndedMiddleware {
 };
 RequestEndedMiddleware = __decorate([
     injectable(),
-    Middleware({ type: "after" })
+    Middleware({ type: "after" }),
+    __metadata("design:paramtypes", [Logger])
 ], RequestEndedMiddleware);
 
 let RequestStartedMiddleware = class RequestStartedMiddleware {
@@ -3291,7 +3430,8 @@ let RequestStartedMiddleware = class RequestStartedMiddleware {
 };
 RequestStartedMiddleware = __decorate([
     injectable(),
-    Middleware({ type: "before" })
+    Middleware({ type: "before" }),
+    __metadata("design:paramtypes", [Logger])
 ], RequestStartedMiddleware);
 
 let ProgressController = class ProgressController {
@@ -3331,17 +3471,24 @@ let ProgressController = class ProgressController {
 __decorate([
     OnMessage("background-progress"),
     __param(0, ConnectedSocket()),
-    __param(1, MessageBody())
+    __param(1, MessageBody()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
 ], ProgressController.prototype, "advanceProgress", null);
 __decorate([
     OnMessage("background-progress-interest"),
     __param(0, ConnectedSocket()),
-    __param(1, MessageBody())
+    __param(1, MessageBody()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
 ], ProgressController.prototype, "setProgressInterest", null);
 ProgressController = __decorate([
     singleton(),
     SocketController(),
-    __param(1, inject(SOCKET_SERVER))
+    __param(1, inject(SOCKET_SERVER)),
+    __metadata("design:paramtypes", [Progresses, Server])
 ], ProgressController);
 
 class Terminal {
@@ -3462,21 +3609,31 @@ let TerminalController = class TerminalController {
 };
 __decorate([
     OnMessage("terminal-init"),
-    __param(0, ConnectedSocket())
+    __param(0, ConnectedSocket()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
 ], TerminalController.prototype, "terminalInit", null);
 __decorate([
     OnMessage("terminal-data"),
     __param(0, ConnectedSocket()),
-    __param(1, MessageBody())
+    __param(1, MessageBody()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
 ], TerminalController.prototype, "terminalData", null);
 __decorate([
     OnMessage("terminal-upload"),
     __param(0, ConnectedSocket()),
-    __param(1, MessageBody())
+    __param(1, MessageBody()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
 ], TerminalController.prototype, "terminalUpload", null);
 TerminalController = __decorate([
     singleton(),
-    SocketController()
+    SocketController(),
+    __metadata("design:paramtypes", [TerminalManager])
 ], TerminalController);
 
 let CompressionMiddleware = class CompressionMiddleware {
@@ -3748,7 +3905,8 @@ let FixturesCommand = class FixturesCommand {
 };
 FixturesCommand = __decorate([
     injectable(),
-    scoped(Lifecycle.ContainerScoped)
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [Fixtures])
 ], FixturesCommand);
 
 const commands = [
@@ -3756,57 +3914,6 @@ const commands = [
     FixturesCommand
 ];
 
-class AssetImageParams {
-    constructor() {
-        this.rotation = 0;
-        this.canvasScaleX = 1;
-        this.canvasScaleY = 1;
-        this.scaleX = 1;
-        this.scaleY = 1;
-        this.lazy = false;
-        this.crop = false;
-        this.cropBefore = false;
-        this.cropAfter = false;
-    }
-}
-__decorate([
-    Min(-360),
-    Max(360),
-    IsOptional()
-], AssetImageParams.prototype, "rotation", void 0);
-__decorate([
-    Min(0.0001),
-    IsOptional()
-], AssetImageParams.prototype, "canvasScaleX", void 0);
-__decorate([
-    Min(0.0001),
-    IsOptional()
-], AssetImageParams.prototype, "canvasScaleY", void 0);
-__decorate([
-    Min(0.0001),
-    IsOptional()
-], AssetImageParams.prototype, "scaleX", void 0);
-__decorate([
-    Min(0.0001),
-    IsOptional()
-], AssetImageParams.prototype, "scaleY", void 0);
-__decorate([
-    IsBoolean(),
-    IsOptional()
-], AssetImageParams.prototype, "lazy", void 0);
-__decorate([
-    IsBoolean(),
-    IsOptional()
-], AssetImageParams.prototype, "crop", void 0);
-__decorate([
-    IsBoolean(),
-    IsOptional()
-], AssetImageParams.prototype, "cropBefore", void 0);
-__decorate([
-    IsBoolean(),
-    IsOptional()
-], AssetImageParams.prototype, "cropAfter", void 0);
-
 class BaseDoc {
     /**
      * Casts this to DocumentType<this> to allow using document methods in get/set-s