@stemy/backend 4.0.0 → 4.0.2

package/fesm2020/stemy-backend.mjs

@@ -4,7 +4,7 @@ import webToken from 'jsonwebtoken';
 import { injectable, scoped, Lifecycle, singleton, injectAll, inject, isFactoryProvider, container } from 'tsyringe';
 import { HttpError, getMetadataArgsStorage, Authorized, Post, UploadedFile, Body, Get, Param, QueryParam, Res, QueryParams, Controller, UnauthorizedError, CurrentUser, Header, BadRequestError, Middleware, createParamDecorator, useContainer, useExpressServer } from 'routing-controllers';
 import { OnMessage, ConnectedSocket, MessageBody, SocketController, Middleware as Middleware$1, SocketControllers } from 'socket-controllers';
-import { __decorate, __param } from 'tslib';
+import { __decorate, __param, __metadata } from 'tslib';
 import fontKit_ from 'fontkit';
 import sharp_ from 'sharp';
 import { ObjectId as ObjectId$1 } from 'bson';
@@ -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';
@@ -144,34 +144,6 @@ AssetProcessor = AssetProcessor_1 = __decorate([
     scoped(Lifecycle.ContainerScoped)
 ], AssetProcessor);
 
-let AssetResolver = class AssetResolver {
-    constructor(assets, lazyAssets) {
-        this.assets = assets;
-        this.lazyAssets = lazyAssets;
-    }
-    async resolve(id, lazy = false) {
-        let asset = null;
-        if (lazy) {
-            const lazyAsset = await this.lazyAssets.read(id);
-            if (!lazyAsset)
-                return null;
-            return lazyAsset.loadAsset();
-        }
-        asset = await this.assets.read(id);
-        if (!asset) {
-            const lazyAsset = await 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
@@ -851,6 +823,99 @@ async function fileTypeFromBuffer(buffer) {
     return type;
 }
 
+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;
+    }
+    async connect() {
+        if (this.db)
+            return this.db;
+        this.conn = (await 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;
@@ -1090,640 +1155,534 @@ 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;
     }
-    async prepare() {
-        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"));
-        await this.collection.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+    get jobQue() {
+        return this.data.jobQue;
     }
-    async set(key, value, ttl, expirationTimestamp = null, tags = {}) {
-        await this.prepare();
-        const item = {
-            _id: key,
-            data: await this.cacheProcessor.serialize(value),
-            tags: await this.cacheProcessor.serialize(tags),
-            expirationTimestamp,
-        };
-        if (ttl) {
-            const now = Math.round(new Date().getTime() / 1000);
-            item.expiresAt = now + ttl;
-        }
-        await this.collection.updateOne({ _id: key }, { $set: item }, { upsert: true });
-        return value;
+    get progressId() {
+        return this.data.progressId;
     }
-    async get(key) {
-        await this.prepare();
-        let item = await this.collection.findOne({ _id: key });
-        const now = Math.round(new Date().getTime() / 1000);
-        if (item && item.expiresAt && item.expiresAt < now) {
-            item = null;
-        }
-        if (!item) {
-            throw new Error(`Cache probably doesn't exists with key: ${key}`);
+    get assetId() {
+        return this.data.assetId;
+    }
+    async unlink() {
+        await this.load();
+        if (!this.progressId) {
+            await this.collection.deleteOne({ _id: this.mId });
         }
-        return await this.cacheProcessor.deserialize(item.data);
+        return deleteFromBucket(this.assets.bucket, new ObjectId$1(this.assetId));
     }
-    async getOrSet(key, valueCb, ttl, expirationTimestamp = null, tags = {}) {
-        try {
-            return await this.get(key);
+    startWorking() {
+        this.load().then(() => {
+            if (this.deleted)
+                return;
+            this.progresses.get(this.progressId).then(p => {
+                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}`);
+            });
+        });
+    }
+    async loadAsset() {
+        await this.load();
+        if (this.deleted)
+            return null;
+        if (this.assetId) {
+            return this.assets.read(this.assetId);
         }
-        catch (e) {
-            return await this.set(key, await valueCb(), ttl, expirationTimestamp, tags);
+        if (this.progressId) {
+            await this.progresses.waitToFinish(this.progressId);
+            return this.loadAsset();
         }
+        await this.startWorkingOnAsset(true);
+        return this.loadAsset();
     }
-    async delete(key) {
-        await this.prepare();
-        await this.collection.deleteOne({ _id: key });
-    }
-};
-Cache = __decorate([
-    singleton()
-], Cache);
-
-let CacheProcessor = class CacheProcessor {
-    async serialize(data) {
-        return data;
+    async writeAsset(asset) {
+        this.data.assetId = asset.id;
+        await this.save();
+        return asset;
     }
-    async deserialize(data) {
-        return data;
+    async startWorkingOnAsset(fromLoad) {
+        this.data.progressId = (await this.progresses.create()).id;
+        this.data.assetId = null;
+        await this.save();
+        await this.progresses.jobMan.enqueueWithName(this.data.jobName, { ...this.data.jobParams, lazyId: this.id, fromLoad });
     }
-};
-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));
+let Logger = class Logger {
+    constructor(config) {
+        this.config = config;
+        this.tags = this.config.resolve("logTags");
+        this.ignoredTags = this.config.resolve("ignoredLogTags");
     }
-    add(param) {
-        const existingParam = this.paramMap[param.name] || param;
-        existingParam.defaultValue = param.defaultValue;
-        existingParam.resolver = param.resolver || existingParam.resolver;
-        this.paramMap[param.name] = existingParam;
+    log(tag, ...params) {
+        if (this.ignoredTags.includes(tag))
+            return;
+        if (this.tags.length === 0 || this.tags.includes(tag)) {
+            console.log(`[${tag}]`, ...params);
+        }
     }
-    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;
+};
+Logger = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Configuration])
+], Logger);
+
+let JobManager = class JobManager {
+    constructor(config, logger, container, jobTypes) {
+        this.config = config;
+        this.logger = logger;
+        this.container = container;
+        this.jobTypes = jobTypes || [];
+        this.jobs = this.jobTypes.reduce((res, jobType) => {
+            const jobName = getConstructorName(jobType);
+            res[jobName] = (jobParams, uniqueId) => {
+                const job = this.resolveJobInstance(jobType, jobParams, uniqueId);
+                const messageBridge = {
+                    sendMessage: (message, params) => {
+                        params.uniqueId = uniqueId;
+                        this.workerPush.send([message, JSON.stringify(params)]);
+                    }
+                };
+                messageBridge.sendMessage(`job-started`, { name: jobName });
+                return job.process(messageBridge);
+            };
+            return res;
+        }, {});
+        this.messages = new Subject();
+        this.processing = false;
+        this.maxTimeout = this.config.resolve("jobTimeout");
+    }
+    on(message, cb) {
+        return this.messages
+            .pipe(filter$1(t => t.message === message))
+            .pipe(map(t => t.params)).subscribe(cb);
+    }
+    async process(jobType, params = {}) {
+        let instance = null;
+        try {
+            instance = this.resolveJobInstance(jobType, params);
         }
-        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;
+        catch (e) {
+            const jobName = getConstructorName(jobType);
+            throw new Error(`Can't resolve params for job: ${jobName}, with params: ${JSON.stringify(params)}. Reason: ${e}`);
         }
-        console.log(colorize(`Using default param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), param.defaultValue);
-        return param.defaultValue;
+        return instance.process();
     }
-    hasParam(name) {
-        return !!this.paramMap[name];
+    async enqueueWithName(name, params = {}) {
+        return this.sendToWorkers(this.tryResolveFromName(name, params), params);
     }
-    resolve(name) {
-        return this.resolveInternal(name, []);
+    async enqueue(jobType, params = {}) {
+        return this.sendToWorkers(this.tryResolveAndInit(jobType, params), params);
     }
-    resolveInternal(name, alreadyResolved) {
-        if (alreadyResolved.includes(name)) {
-            throw new Error(`Circular dependency detected: ${alreadyResolved.join(" -> ")} -> ${name}`);
+    schedule(minute, hour, dayOfMonth, month, dayOfWeek, jobType, params = {}) {
+        const expression = [minute, hour, dayOfMonth, month, dayOfWeek].map(t => {
+            if (isObject(t)) {
+                const range = t;
+                return `${range.min || 0}-${range.max || 0}`;
+            }
+            if (isArray(t)) {
+                return t.join(",");
+            }
+            return `${t}`;
+        }).join(" ");
+        const jobName = getConstructorName(jobType);
+        if (!cron.validate(expression)) {
+            this.logger.log("job-manager", `Can't schedule the task: '${jobName}' because time expression is invalid.`);
+            return null;
         }
-        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 cron.schedule(expression, () => {
+            this.enqueue(jobType, params).catch(e => {
+                this.logger.log("job-manager", `Can't enqueue job: '${jobName}' because: ${e}`);
+            });
+        });
+    }
+    async startProcessing() {
+        if (this.processing)
+            return null;
+        this.processing = true;
+        if (!this.config.resolve("isWorker")) {
+            this.logger.log("job-manager", colorize(`Processing can not be started because this is NOT a worker process!`, ConsoleColor.FgRed));
+            return null;
         }
-        return this.paramValues[name];
+        const host = this.config.resolve("zmqRemoteHost");
+        const pushHost = `${host}:${this.config.resolve("zmqBackPort")}`;
+        this.workerPush = socket("push");
+        await this.workerPush.connect(pushHost);
+        this.logger.log("job-manager", `Worker producer connected to: ${pushHost}`);
+        const pullHost = `${host}:${this.config.resolve("zmqPort")}`;
+        this.workerPull = socket("pull");
+        await this.workerPull.connect(pullHost);
+        this.logger.log("job-manager", `Worker consumer connected to: ${pullHost}`);
+        this.workerPull.on("message", async (name, args, uniqId) => {
+            try {
+                const jobName = name.toString("utf8");
+                const jobParams = JSON.parse(args.toString("utf8"));
+                const uniqueId = uniqId?.toString("utf8");
+                console.time(uniqueId);
+                console.timeLog(uniqueId, `Started working on background job: ${colorize(jobName, ConsoleColor.FgCyan)} with args: \n${jsonHighlight(jobParams)}\n\n`);
+                try {
+                    await Promise.race([this.jobs[jobName](jobParams, uniqueId), promiseTimeout(this.maxTimeout, true)]);
+                    console.timeLog(uniqueId, `Finished working on background job: ${colorize(jobName, ConsoleColor.FgCyan)}\n\n`);
+                }
+                catch (e) {
+                    console.timeLog(uniqueId, `Background job failed: ${colorize(jobName, ConsoleColor.FgRed)}\n${e}\n\n`);
+                }
+                console.timeEnd(uniqueId);
+            }
+            catch (e) {
+                this.logger.log("job-manager", `Failed to start job: ${e.message}`);
+            }
+        });
     }
-};
-Configuration = __decorate([
-    singleton(),
-    __param(0, injectAll(PARAMETER))
-], Configuration);
-
-let EndpointProvider = class EndpointProvider {
-    async configure(app) {
-        console.log(`Express app is mounted to: ${app.mountpath}`);
+    tryResolve(jobType, params) {
+        const jobName = getConstructorName(jobType);
+        if (!this.jobs[jobName]) {
+            throw `Can't find job with name: ${jobName} so it can't be enqueued!`;
+        }
+        try {
+            this.resolveJobInstance(jobType, params);
+        }
+        catch (e) {
+            throw `Can't resolve params for job: ${jobName}, with params: ${JSON.stringify(params)}. Reason: ${e}`;
+        }
+        return jobName;
     }
-};
-EndpointProvider = __decorate([
-    injectable(),
-    scoped(Lifecycle.ContainerScoped)
-], EndpointProvider);
-
-let Fixtures = class Fixtures {
-    constructor(fixtures) {
-        this.fixtures = fixtures;
+    tryResolveFromName(jobName, params) {
+        const jobType = this.jobTypes.find(type => {
+            return getConstructorName(type) == jobName;
+        });
+        if (!jobType) {
+            throw `Can't find job type with name: ${jobName} so it can't be enqueued!`;
+        }
+        return this.tryResolveAndInit(jobType, params);
     }
-    async load(output) {
-        if (!this.fixtures)
-            return;
-        output = output || {
-            write: console.log,
-            writeln: t => console.log(t + "\n")
-        };
-        for (let fixture of this.fixtures) {
-            await fixture.load(output);
+    tryResolveAndInit(jobType, params) {
+        if (!this.apiPush) {
+            const port = this.config.resolve("zmqPort");
+            this.apiPush = socket("push");
+            this.apiPush.bind(`tcp://0.0.0.0:${port}`);
+            this.logger.log("job-manager", `API producer bound to port: ${port}`);
+        }
+        if (!this.apiPull) {
+            const backPort = this.config.resolve("zmqBackPort");
+            this.apiPull = socket("pull");
+            this.apiPull.bind(`tcp://0.0.0.0:${backPort}`);
+            this.apiPull.on("message", (name, args) => {
+                const message = name.toString("utf8");
+                const params = JSON.parse(args?.toString("utf8") || "{}");
+                const paramTypes = Object.keys(params).reduce((res, key) => {
+                    res[key] = getType(params[key]);
+                    return res;
+                }, {});
+                this.logger.log("job-manager", `Received a message from worker: "${colorize(message, ConsoleColor.FgCyan)}" with args: ${jsonHighlight(paramTypes)}\n\n`);
+                this.messages.next({ message, params });
+            });
+            this.logger.log("job-manager", `API consumer bound to port: ${backPort}`);
         }
+        return this.tryResolve(jobType, params);
+    }
+    resolveJobInstance(jobType, params, uniqueId = "") {
+        const container = this.container.createChildContainer();
+        Object.keys(params).map((name) => {
+            container.register(name, { useValue: params[name] });
+        });
+        container.register("uniqueId", { useValue: uniqueId });
+        container.register(jobType, jobType);
+        return container.resolve(jobType);
+    }
+    async sendToWorkers(jobName, params) {
+        const publisher = await this.apiPush;
+        const uniqueId = new ObjectId$1().toHexString();
+        await publisher.send([jobName, JSON.stringify(params), uniqueId]);
+        return uniqueId;
     }
 };
-Fixtures = __decorate([
+JobManager = __decorate([
     injectable(),
     scoped(Lifecycle.ContainerScoped),
-    __param(0, injectAll(FIXTURE))
-], Fixtures);
+    __param(2, inject(DI_CONTAINER)),
+    __param(3, injectAll(JOB)),
+    __metadata("design:paramtypes", [Configuration,
+        Logger, Object, Array])
+], JobManager);
 
-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");
-    }
-    async getFolder(folder, size = null) {
-        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];
+class Progress extends BaseEntity {
+    constructor(id, data, collection) {
+        super(id, data, collection);
     }
-    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(async (resolve) => {
-                        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(async (res, rej) => {
-                                                const resultPath = getResultPath(isThumb);
-                                                await 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));
-                });
-            });
-        });
+    get current() {
+        return this.data.current;
     }
-};
-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;
+    get max() {
+        return this.data.max;
     }
-    async serve(id) {
-        const isThumb = id == this.thumb;
-        if (await this.handler.hasResult(isThumb)) {
-            return this.handler.serveResult(isThumb);
-        }
-        const original = sharp(await this.handler.getOriginal()).rotate();
-        const meta = await 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 = await (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());
-        await this.handler.writeResult(isThumb, buffer);
-        return this.handler.serveResult(isThumb);
+    get message() {
+        return this.data.message;
     }
-}
-
-let GalleryCache = class GalleryCache {
-    constructor() {
-        this.imgCache = {};
+    get error() {
+        return this.data.error;
     }
-    put(img) {
-        this.imgCache[img.thumb] = img;
-        this.imgCache[img.big] = img;
+    get canceled() {
+        return this.data.canceled;
     }
-    serve(id) {
-        const img = this.imgCache[id];
-        return !img ? null : img.serve(id);
+    get percent() {
+        return this.max > 0 ? Math.round(this.current / this.max * 100) : 0;
     }
-    create(folder, targetSize, handler) {
-        const image = new GalleryImage(folder, targetSize, handler);
-        this.put(image);
-        return image;
+    get remaining() {
+        return this.max > 0 ? this.max - this.current : 0;
     }
-};
-GalleryCache = __decorate([
-    injectable(),
-    scoped(Lifecycle.ContainerScoped)
-], GalleryCache);
-
-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");
+    setMessageBridge(messageBridge) {
+        this.messageBridge = messageBridge || this.messageBridge;
+        return this;
     }
-    async generate(checkCb) {
-        let id = null;
-        let tries = 0;
-        let notGood = true;
-        while (notGood && tries < 5) {
-            id = this.generateId();
-            notGood = await checkCb(id);
-            tries++;
+    async createSubProgress(progressValue, max, message) {
+        if (max <= 0 && progressValue > 0) {
+            await this.advance(progressValue);
         }
-        if (notGood) {
-            throw `Couldn't generate an unique id..`;
+        if (message !== null) {
+            this.data.message = message;
+            await this.save();
         }
-        return id;
+        return new SubProgress(this, this.current, progressValue, Math.max(max, 1));
     }
-    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);
+    async setMax(max) {
+        if (isNaN(max) || max <= 0) {
+            throw "Max progress value must be bigger than zero";
+        }
+        this.data.max = max;
+        await this.save();
     }
-};
-IdGenerator = __decorate([
-    injectable(),
-    scoped(Lifecycle.ContainerScoped)
-], IdGenerator);
-
-let JobManager = class JobManager {
-    constructor(config, logger, container, jobTypes) {
-        this.config = config;
-        this.logger = logger;
-        this.container = container;
-        this.jobTypes = jobTypes || [];
-        this.jobs = this.jobTypes.reduce((res, jobType) => {
-            const jobName = getConstructorName(jobType);
-            res[jobName] = (jobParams, uniqueId) => {
-                const job = this.resolveJobInstance(jobType, jobParams, uniqueId);
-                const messageBridge = {
-                    sendMessage: (message, params) => {
-                        params.uniqueId = uniqueId;
-                        this.workerPush.send([message, JSON.stringify(params)]);
-                    }
-                };
-                messageBridge.sendMessage(`job-started`, { name: jobName });
-                return job.process(messageBridge);
-            };
-            return res;
-        }, {});
-        this.messages = new Subject();
-        this.processing = false;
-        this.maxTimeout = this.config.resolve("jobTimeout");
+    async setMessage(message) {
+        this.data.message = message;
+        await this.save();
     }
-    on(message, cb) {
-        return this.messages
-            .pipe(filter$1(t => t.message === message))
-            .pipe(map(t => t.params)).subscribe(cb);
+    async setError(error) {
+        this.data.error = error;
+        await this.save();
     }
-    async process(jobType, params = {}) {
-        let instance = null;
-        try {
-            instance = this.resolveJobInstance(jobType, params);
+    async advance(value = 1) {
+        if (isNaN(value) || value <= 0) {
+            throw new Error(`Advance value must be bigger than zero: ${this.id}`);
         }
-        catch (e) {
-            const jobName = getConstructorName(jobType);
-            throw new Error(`Can't resolve params for job: ${jobName}, with params: ${JSON.stringify(params)}. Reason: ${e}`);
+        await this.load();
+        if (this.deleted || this.canceled) {
+            const status = this.deleted ? "deleted" : "canceled";
+            throw new Error(`Can't advance ${status} progress: ${this.id}`);
         }
-        return instance.process();
-    }
-    async enqueueWithName(name, params = {}) {
-        return this.sendToWorkers(this.tryResolveFromName(name, params), params);
-    }
-    async enqueue(jobType, params = {}) {
-        return this.sendToWorkers(this.tryResolveAndInit(jobType, params), params);
+        this.data.current = Math.min(this.max, this.current + value);
+        await this.save();
     }
-    schedule(minute, hour, dayOfMonth, month, dayOfWeek, jobType, params = {}) {
-        const expression = [minute, hour, dayOfMonth, month, dayOfWeek].map(t => {
-            if (isObject(t)) {
-                const range = t;
-                return `${range.min || 0}-${range.max || 0}`;
-            }
-            if (isArray(t)) {
-                return t.join(",");
-            }
-            return `${t}`;
-        }).join(" ");
-        const jobName = getConstructorName(jobType);
-        if (!cron.validate(expression)) {
-            this.logger.log("job-manager", `Can't schedule the task: '${jobName}' because time expression is invalid.`);
-            return null;
-        }
-        return cron.schedule(expression, () => {
-            this.enqueue(jobType, params).catch(e => {
-                this.logger.log("job-manager", `Can't enqueue job: '${jobName}' because: ${e}`);
-            });
-        });
+    async cancel() {
+        this.data.canceled = true;
+        await this.save();
     }
-    async startProcessing() {
-        if (this.processing)
-            return null;
-        this.processing = true;
-        if (!this.config.resolve("isWorker")) {
-            this.logger.log("job-manager", colorize(`Processing can not be started because this is NOT a worker process!`, ConsoleColor.FgRed));
-            return null;
+    save() {
+        if (this.messageBridge) {
+            this.messageBridge.sendMessage(`progress-changed`, this.toJSON());
         }
-        const host = this.config.resolve("zmqRemoteHost");
-        const pushHost = `${host}:${this.config.resolve("zmqBackPort")}`;
-        this.workerPush = socket("push");
-        await this.workerPush.connect(pushHost);
-        this.logger.log("job-manager", `Worker producer connected to: ${pushHost}`);
-        const pullHost = `${host}:${this.config.resolve("zmqPort")}`;
-        this.workerPull = socket("pull");
-        await this.workerPull.connect(pullHost);
-        this.logger.log("job-manager", `Worker consumer connected to: ${pullHost}`);
-        this.workerPull.on("message", async (name, args, uniqId) => {
-            try {
-                const jobName = name.toString("utf8");
-                const jobParams = JSON.parse(args.toString("utf8"));
-                const uniqueId = uniqId?.toString("utf8");
-                console.time(uniqueId);
-                console.timeLog(uniqueId, `Started working on background job: ${colorize(jobName, ConsoleColor.FgCyan)} with args: \n${jsonHighlight(jobParams)}\n\n`);
-                try {
-                    await Promise.race([this.jobs[jobName](jobParams, uniqueId), promiseTimeout(this.maxTimeout, true)]);
-                    console.timeLog(uniqueId, `Finished working on background job: ${colorize(jobName, ConsoleColor.FgCyan)}\n\n`);
-                }
-                catch (e) {
-                    console.timeLog(uniqueId, `Background job failed: ${colorize(jobName, ConsoleColor.FgRed)}\n${e}\n\n`);
-                }
-                console.timeEnd(uniqueId);
-            }
-            catch (e) {
-                this.logger.log("job-manager", `Failed to start job: ${e.message}`);
-            }
-        });
+        return super.save();
     }
-    tryResolve(jobType, params) {
-        const jobName = getConstructorName(jobType);
-        if (!this.jobs[jobName]) {
-            throw `Can't find job with name: ${jobName} so it can't be enqueued!`;
-        }
-        try {
-            this.resolveJobInstance(jobType, params);
+}
+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";
         }
-        catch (e) {
-            throw `Can't resolve params for job: ${jobName}, with params: ${JSON.stringify(params)}. Reason: ${e}`;
+        if (progressValue <= 0) {
+            throw "Progress value must be bigger than zero";
         }
-        return jobName;
+        this.mCurrent = 0;
     }
-    tryResolveFromName(jobName, params) {
-        const jobType = this.jobTypes.find(type => {
-            return getConstructorName(type) == jobName;
-        });
-        if (!jobType) {
-            throw `Can't find job type with name: ${jobName} so it can't be enqueued!`;
-        }
-        return this.tryResolveAndInit(jobType, params);
+    get id() {
+        return this.parent.id;
     }
-    tryResolveAndInit(jobType, params) {
-        if (!this.apiPush) {
-            const port = this.config.resolve("zmqPort");
-            this.apiPush = socket("push");
-            this.apiPush.bind(`tcp://0.0.0.0:${port}`);
-            this.logger.log("job-manager", `API producer bound to port: ${port}`);
-        }
-        if (!this.apiPull) {
-            const backPort = this.config.resolve("zmqBackPort");
-            this.apiPull = socket("pull");
-            this.apiPull.bind(`tcp://0.0.0.0:${backPort}`);
-            this.apiPull.on("message", (name, args) => {
-                const message = name.toString("utf8");
-                const params = JSON.parse(args?.toString("utf8") || "{}");
-                const paramTypes = Object.keys(params).reduce((res, key) => {
-                    res[key] = getType(params[key]);
-                    return res;
-                }, {});
-                this.logger.log("job-manager", `Received a message from worker: "${colorize(message, ConsoleColor.FgCyan)}" with args: ${jsonHighlight(paramTypes)}\n\n`);
-                this.messages.next({ message, params });
-            });
-            this.logger.log("job-manager", `API consumer bound to port: ${backPort}`);
-        }
-        return this.tryResolve(jobType, params);
+    get current() {
+        return this.mCurrent;
     }
-    resolveJobInstance(jobType, params, uniqueId = "") {
-        const container = this.container.createChildContainer();
-        Object.keys(params).map((name) => {
-            container.register(name, { useValue: params[name] });
-        });
-        container.register("uniqueId", { useValue: uniqueId });
-        container.register(jobType, jobType);
-        return container.resolve(jobType);
+    get max() {
+        return this.mMax;
     }
-    async sendToWorkers(jobName, params) {
-        const publisher = await this.apiPush;
-        const uniqueId = new ObjectId$1().toHexString();
-        await publisher.send([jobName, JSON.stringify(params), uniqueId]);
-        return uniqueId;
+    get message() {
+        return this.parent.message;
     }
-};
-JobManager = __decorate([
-    injectable(),
-    scoped(Lifecycle.ContainerScoped),
-    __param(2, inject(DI_CONTAINER)),
-    __param(3, injectAll(JOB))
-], JobManager);
-
-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 error() {
+        return this.parent.error;
     }
-    get jobName() {
-        return this.data.jobName;
+    get percent() {
+        return this.parent.percent;
     }
-    get jobParams() {
-        return this.data.jobParams;
+    get remaining() {
+        return this.max - this.mCurrent;
     }
-    get jobQue() {
-        return this.data.jobQue;
+    get canceled() {
+        return !this.parent || this.parent.canceled;
     }
-    get progressId() {
-        return this.data.progressId;
+    setMessageBridge(messageBridge) {
+        if (!this.parent)
+            return this;
+        this.parent.setMessageBridge(messageBridge);
+        return this;
     }
-    get assetId() {
-        return this.data.assetId;
+    async createSubProgress(progressValue, max, message) {
+        if (max <= 0 && progressValue > 0) {
+            await this.advance(progressValue);
+        }
+        if (message !== null) {
+            await this.setMessage(message);
+        }
+        return new SubProgress(this, this.current, progressValue, Math.max(max, 1));
     }
-    async unlink() {
-        await this.load();
-        if (!this.progressId) {
-            await this.collection.deleteOne({ _id: this.mId });
+    async setMax(max) {
+        if (isNaN(max) || max <= 0) {
+            throw "Max progress value must be bigger than zero";
         }
-        return deleteFromBucket(this.assets.bucket, new ObjectId$1(this.assetId));
+        this.mMax = max;
+        await this.save();
     }
-    startWorking() {
-        this.load().then(() => {
-            if (this.deleted)
-                return;
-            this.progresses.get(this.progressId).then(p => {
-                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}`);
-            });
-        });
+    async setMessage(message) {
+        if (!this.parent)
+            return null;
+        await this.parent.setMessage(message);
     }
-    async loadAsset() {
-        await this.load();
-        if (this.deleted)
+    async setError(error) {
+        if (!this.parent)
             return null;
-        if (this.assetId) {
-            return this.assets.read(this.assetId);
-        }
-        if (this.progressId) {
-            await this.progresses.waitToFinish(this.progressId);
-            return this.loadAsset();
-        }
-        await this.startWorkingOnAsset(true);
-        return this.loadAsset();
+        await this.parent.setError(error);
     }
-    async writeAsset(asset) {
-        this.data.assetId = asset.id;
+    async advance(value = 1) {
+        if (isNaN(value) || value <= 0) {
+            throw "Advance value must be bigger than zero";
+        }
+        this.mCurrent = Math.min(this.max, this.mCurrent + value);
         await this.save();
-        return asset;
     }
-    async startWorkingOnAsset(fromLoad) {
-        this.data.progressId = (await this.progresses.create()).id;
-        this.data.assetId = null;
-        await this.save();
-        await this.progresses.jobMan.enqueueWithName(this.data.jobName, { ...this.data.jobParams, lazyId: this.id, fromLoad });
+    async cancel() {
+        if (!this.parent)
+            return null;
+        await this.parent.cancel();
+    }
+    async save() {
+        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;
+        await this.parent.advance(newProgress);
+    }
+    async load() {
+        return null;
+    }
+    toJSON() {
+        return this.parent.toJSON();
     }
 }
 
+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);
+        });
+    }
+    async waitToFinish(id) {
+        return Promise.race([
+            this.waitForProgress(id, async () => {
+                let progress = this.progresses[id];
+                if (!progress || progress.percent < 100) {
+                    progress = await this.get(id);
+                }
+                if (!progress) {
+                    throw new Error(`Progress does not exists with id: ${id}`);
+                }
+                return progress;
+            }, 500),
+            this.waitForProgress(id, async () => {
+                return this.progresses[id] || null;
+            }, 25)
+        ]);
+    }
+    async get(id) {
+        return !id ? null : this.find({ _id: new ObjectId$1(id) });
+    }
+    async find(where) {
+        const data = await this.collection.findOne(where);
+        return !data ? null : new Progress(data._id, data, this.collection);
+    }
+    async create(max = 100) {
+        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 = await this.collection.insertOne(data);
+        return new Progress(res.insertedId, data, this.collection);
+    }
+    async remove(id) {
+        await this.collection.deleteOne({ _id: new ObjectId$1(id) });
+        return id;
+    }
+    async waitForProgress(id, cb, delay) {
+        let isFinished = false;
+        let progress = null;
+        let waitTime = 0;
+        while (!isFinished) {
+            progress = await 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!`);
+                }
+                await promiseTimeout(delay);
+            }
+        }
+        return progress;
+    }
+};
+Progresses = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [MongoConnector, JobManager])
+], Progresses);
+
 let LazyAssets = class LazyAssets {
     constructor(connector, assets, progresses, logger, jobMan) {
         this.connector = connector;
@@ -1764,94 +1723,114 @@ let LazyAssets = class LazyAssets {
 };
 LazyAssets = __decorate([
     injectable(),
-    scoped(Lifecycle.ContainerScoped)
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [MongoConnector,
+        Assets,
+        Progresses,
+        Logger,
+        JobManager])
 ], LazyAssets);
 
-let Logger = class Logger {
-    constructor(config) {
-        this.config = config;
-        this.tags = this.config.resolve("logTags");
-        this.ignoredTags = this.config.resolve("ignoredLogTags");
+let AssetResolver = class AssetResolver {
+    constructor(assets, lazyAssets) {
+        this.assets = assets;
+        this.lazyAssets = lazyAssets;
     }
-    log(tag, ...params) {
-        if (this.ignoredTags.includes(tag))
-            return;
-        if (this.tags.length === 0 || this.tags.includes(tag)) {
-            console.log(`[${tag}]`, ...params);
+    async resolve(id, lazy = false) {
+        let asset = null;
+        if (lazy) {
+            const lazyAsset = await this.lazyAssets.read(id);
+            if (!lazyAsset)
+                return null;
+            return lazyAsset.loadAsset();
+        }
+        asset = await this.assets.read(id);
+        if (!asset) {
+            const lazyAsset = await this.lazyAssets.read(id);
+            if (!lazyAsset)
+                return null;
+            return lazyAsset.loadAsset();
         }
+        return asset;
     }
 };
-Logger = __decorate([
-    singleton()
-], Logger);
+AssetResolver = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [Assets, LazyAssets])
+], AssetResolver);
 
-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"),
-            }
-        });
+const express = express_;
+let BackendProvider = class BackendProvider {
+    constructor() {
+        this.express = express();
+        this.express.set("trust proxy", true);
+        this.server = createServer(this.express);
     }
-    get translator() {
-        return this.renderer.translator;
+    get io() {
+        this.ioServer = this.ioServer || new Server(this.server, { path: "/socket" });
+        return this.ioServer;
     }
-    async sendMail(language, options) {
-        const subject = await this.translator.getTranslation(language, options.subject || "-");
-        const html = await 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
-        });
+};
+BackendProvider = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [])
+], BackendProvider);
+
+let CacheProcessor = class CacheProcessor {
+    async serialize(data) {
+        return data;
+    }
+    async deserialize(data) {
+        return data;
     }
 };
-MailSender = __decorate([
-    singleton()
-], MailSender);
+CacheProcessor = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], CacheProcessor);
 
-let MemoryCache = class MemoryCache {
-    constructor(cache) {
-        this.cache = cache;
-        this.cacheMap = new Map();
+let Cache = class Cache {
+    constructor(connector, config, cacheProcessor) {
+        this.connector = connector;
+        this.config = config;
+        this.cacheProcessor = cacheProcessor;
+    }
+    async prepare() {
+        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"));
+        await this.collection.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
     }
     async set(key, value, ttl, expirationTimestamp = null, tags = {}) {
-        const now = Math.round(new Date().getTime() / 1000);
-        const expTimestamp = Math.min(isNaN(ttl) ? Number.MAX_SAFE_INTEGER : ttl, 3600);
-        this.cacheMap.set(key, {
+        await this.prepare();
+        const item = {
             _id: key,
-            data: value,
-            expirationTimestamp: expTimestamp,
-            expiresAt: now + expTimestamp,
-        });
-        return this.cache.set(key, value, ttl, expirationTimestamp, tags);
+            data: await this.cacheProcessor.serialize(value),
+            tags: await this.cacheProcessor.serialize(tags),
+            expirationTimestamp,
+        };
+        if (ttl) {
+            const now = Math.round(new Date().getTime() / 1000);
+            item.expiresAt = now + ttl;
+        }
+        await this.collection.updateOne({ _id: key }, { $set: item }, { upsert: true });
+        return value;
     }
     async get(key) {
-        let item = this.cacheMap.get(key);
+        await this.prepare();
+        let item = await this.collection.findOne({ _id: 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 = await this.cache.get(key);
-            this.cacheMap.set(key, {
-                _id: key,
-                data: value,
-                expirationTimestamp: expTimestamp,
-                expiresAt: now + expTimestamp,
-            });
-            return value;
+            throw new Error(`Cache probably doesn't exists with key: ${key}`);
         }
-        return item.data;
+        return await this.cacheProcessor.deserialize(item.data);
     }
     async getOrSet(key, valueCb, ttl, expirationTimestamp = null, tags = {}) {
         try {
@@ -1862,446 +1841,345 @@ let MemoryCache = class MemoryCache {
         }
     }
     async delete(key) {
-        this.cacheMap.delete(key);
-        await this.cacheMap.delete(key);
+        await this.prepare();
+        await this.collection.deleteOne({ _id: key });
     }
 };
-MemoryCache = __decorate([
-    injectable(),
-    scoped(Lifecycle.ContainerScoped)
-], MemoryCache);
+Cache = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [MongoConnector, Configuration, CacheProcessor])
+], Cache);
 
-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;
-    }
-    async connect() {
-        if (this.db)
-            return this.db;
-        this.conn = (await 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" });
+let EndpointProvider = class EndpointProvider {
+    async configure(app) {
+        console.log(`Express app is mounted to: ${app.mountpath}`);
     }
 };
-MongoConnector = __decorate([
-    singleton()
-], MongoConnector);
+EndpointProvider = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], EndpointProvider);
 
-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);
+let Fixtures = class Fixtures {
+    constructor(fixtures) {
+        this.fixtures = fixtures;
     }
-};
-IsFile = __decorate([
-    ValidatorConstraint()
-], IsFile);
-let IsObjectId = class IsObjectId {
-    validate(value, validationArguments) {
-        const [_, multi] = (validationArguments.constraints || []);
-        return checkValue(multi, value);
+    async load(output) {
+        if (!this.fixtures)
+            return;
+        output = output || {
+            write: console.log,
+            writeln: t => console.log(t + "\n")
+        };
+        for (let fixture of this.fixtures) {
+            await fixture.load(output);
+        }
     }
 };
-IsObjectId = __decorate([
-    ValidatorConstraint()
-], IsObjectId);
+Fixtures = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __param(0, injectAll(FIXTURE)),
+    __metadata("design:paramtypes", [Array])
+], Fixtures);
 
-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;
+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;
     }
-    async schemaToExample(src, req) {
-        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 = {};
-            await Promise.all(Object.keys(schema.properties).map(async (key) => {
-                result[key] = await this.schemaToExample(schema.properties[key], req);
-            }));
-            return result;
-        }
-        if (schema.type === "array") {
-            return [await 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 schema.default ?? 0;
-        }
-        else if (schema.type === "boolean") {
-            return schema.default ?? false;
-        }
-        else {
-            return schema.default ?? null;
+    async serve(id) {
+        const isThumb = id == this.thumb;
+        if (await this.handler.hasResult(isThumb)) {
+            return this.handler.serveResult(isThumb);
         }
+        const original = sharp$1(await this.handler.getOriginal()).rotate();
+        const meta = await 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 = await (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());
+        await this.handler.writeResult(isThumb, buffer);
+        return this.handler.serveResult(isThumb);
     }
-    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;
-                }
-            }
-        });
-        docs.components.schemas = docs.definitions;
-        return docs;
-    }
-};
-OpenApi = __decorate([
-    singleton(),
-    __param(0, inject(DI_CONTAINER)),
-    __param(1, inject(OPENAPI_VALIDATION))
-], OpenApi);
+}
 
-class Progress extends BaseEntity {
-    constructor(id, data, collection) {
-        super(id, data, collection);
+let GalleryCache = class GalleryCache {
+    constructor() {
+        this.imgCache = {};
     }
-    get current() {
-        return this.data.current;
+    put(img) {
+        this.imgCache[img.thumb] = img;
+        this.imgCache[img.big] = img;
     }
-    get max() {
-        return this.data.max;
+    serve(id) {
+        const img = this.imgCache[id];
+        return !img ? null : img.serve(id);
     }
-    get message() {
-        return this.data.message;
+    create(folder, targetSize, handler) {
+        const image = new GalleryImage(folder, targetSize, handler);
+        this.put(image);
+        return image;
     }
-    get error() {
-        return this.data.error;
+};
+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");
     }
-    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;
-    }
-    async createSubProgress(progressValue, max, message) {
-        if (max <= 0 && progressValue > 0) {
-            await this.advance(progressValue);
-        }
-        if (message !== null) {
-            this.data.message = message;
-            await this.save();
-        }
-        return new SubProgress(this, this.current, progressValue, Math.max(max, 1));
-    }
-    async setMax(max) {
-        if (isNaN(max) || max <= 0) {
-            throw "Max progress value must be bigger than zero";
-        }
-        this.data.max = max;
-        await this.save();
-    }
-    async setMessage(message) {
-        this.data.message = message;
-        await this.save();
-    }
-    async setError(error) {
-        this.data.error = error;
-        await this.save();
-    }
-    async advance(value = 1) {
-        if (isNaN(value) || value <= 0) {
-            throw new Error(`Advance value must be bigger than zero: ${this.id}`);
-        }
-        await 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);
-        await this.save();
-    }
-    async cancel() {
-        this.data.canceled = true;
-        await 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;
+    async getFolder(folder, size = null) {
+        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];
     }
-    setMessageBridge(messageBridge) {
-        if (!this.parent)
-            return this;
-        this.parent.setMessageBridge(messageBridge);
-        return this;
+    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(async (resolve) => {
+                        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(async (res, rej) => {
+                                                const resultPath = getResultPath(isThumb);
+                                                await 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));
+                });
+            });
+        });
     }
-    async createSubProgress(progressValue, max, message) {
-        if (max <= 0 && progressValue > 0) {
-            await this.advance(progressValue);
-        }
-        if (message !== null) {
-            await this.setMessage(message);
-        }
-        return new SubProgress(this, this.current, progressValue, Math.max(max, 1));
+};
+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");
     }
-    async setMax(max) {
-        if (isNaN(max) || max <= 0) {
-            throw "Max progress value must be bigger than zero";
+    async generate(checkCb) {
+        let id = null;
+        let tries = 0;
+        let notGood = true;
+        while (notGood && tries < 5) {
+            id = this.generateId();
+            notGood = await checkCb(id);
+            tries++;
         }
-        this.mMax = max;
-        await this.save();
-    }
-    async setMessage(message) {
-        if (!this.parent)
-            return null;
-        await this.parent.setMessage(message);
-    }
-    async setError(error) {
-        if (!this.parent)
-            return null;
-        await this.parent.setError(error);
-    }
-    async advance(value = 1) {
-        if (isNaN(value) || value <= 0) {
-            throw "Advance value must be bigger than zero";
+        if (notGood) {
+            throw `Couldn't generate an unique id..`;
         }
-        this.mCurrent = Math.min(this.max, this.mCurrent + value);
-        await this.save();
-    }
-    async cancel() {
-        if (!this.parent)
-            return null;
-        await this.parent.cancel();
-    }
-    async save() {
-        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;
-        await this.parent.advance(newProgress);
-    }
-    async load() {
-        return null;
+        return id;
     }
-    toJSON() {
-        return this.parent.toJSON();
+    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);
     }
-}
+};
+IdGenerator = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [Configuration])
+], IdGenerator);
 
-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 TranslationProvider = class TranslationProvider {
+    constructor(config, cache) {
+        this.config = config;
+        this.cache = cache;
     }
-    async waitToFinish(id) {
-        return Promise.race([
-            this.waitForProgress(id, async () => {
-                let progress = this.progresses[id];
-                if (!progress || progress.percent < 100) {
-                    progress = await this.get(id);
-                }
-                if (!progress) {
-                    throw new Error(`Progress does not exists with id: ${id}`);
+    getDictionary(language) {
+        return this.cache.getOrSet(`translations-${language}`, async () => {
+            try {
+                const url = this.config.resolve("translationsTemplate")
+                    .replace(`__lang__`, language)
+                    .replace(`[lang]`, language);
+                const data = await axios.get(url).then(t => t.data);
+                if (isObject(data[language])) {
+                    return data[language];
                 }
-                return progress;
-            }, 500),
-            this.waitForProgress(id, async () => {
-                return this.progresses[id] || null;
-            }, 25)
-        ]);
+                return data;
+            }
+            catch (e) {
+                return {
+                    message: `${e}`
+                };
+            }
+        }, 5 * 60);
     }
-    async get(id) {
-        return !id ? null : this.find({ _id: new ObjectId$1(id) });
+};
+TranslationProvider = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Configuration, Cache])
+], TranslationProvider);
+
+let Translator = class Translator {
+    constructor(translationProvider) {
+        this.translationProvider = translationProvider;
+        this.dictionaries = {};
     }
-    async find(where) {
-        const data = await this.collection.findOne(where);
-        return !data ? null : new Progress(data._id, data, this.collection);
+    async getDictionary(language) {
+        this.dictionaries[language] = await this.translationProvider.getDictionary(language);
+        return this.dictionaries[language];
     }
-    async create(max = 100) {
-        if (isNaN(max) || max <= 0) {
-            throw new Error(`Max progress value must be bigger than zero`);
+    getTranslationSync(language, key, params) {
+        if (!isString(key) || !key.length) {
+            throw new Error(`Parameter "key" required`);
         }
-        const data = {
-            current: 0,
-            max: max,
-            message: "",
-            error: "",
-            canceled: false
-        };
-        const res = await this.collection.insertOne(data);
-        return new Progress(res.insertedId, data, this.collection);
-    }
-    async remove(id) {
-        await this.collection.deleteOne({ _id: new ObjectId$1(id) });
-        return id;
+        const dictionary = this.dictionaries[language];
+        const translation = getValue(dictionary, key, key) || key;
+        return this.interpolate(translation, params);
     }
-    async waitForProgress(id, cb, delay) {
-        let isFinished = false;
-        let progress = null;
-        let waitTime = 0;
-        while (!isFinished) {
-            progress = await 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!`);
-                }
-                await promiseTimeout(delay);
-            }
+    getTranslation(language, key, params) {
+        if (!isString(key) || !key.length) {
+            throw new Error(`Parameter "key" required`);
         }
-        return progress;
+        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;
+        });
     }
 };
-Progresses = __decorate([
-    singleton()
-], Progresses);
+Translator = __decorate([
+    injectable(),
+    singleton(),
+    __metadata("design:paramtypes", [TranslationProvider])
+], Translator);
 
 let TemplateRenderer = class TemplateRenderer {
     constructor(translator, config) {
@@ -2325,41 +2203,276 @@ let TemplateRenderer = class TemplateRenderer {
         this.initPromise = this.initPromise || this.parseTemplates(this.config.resolve("templatesDir"), []);
         return this.initPromise;
     }
-    async parseTemplates(dir, dirPath) {
-        return new Promise(resolve => {
-            readdir(dir, async (err, files) => {
-                for (let file of files) {
-                    const path = join(dir, file);
-                    if (lstatSync(path).isDirectory()) {
-                        await this.parseTemplates(join(dir, file), dirPath.concat([file]));
-                        continue;
+    async parseTemplates(dir, dirPath) {
+        return new Promise(resolve => {
+            readdir(dir, async (err, files) => {
+                for (let file of files) {
+                    const path = join(dir, file);
+                    if (lstatSync(path).isDirectory()) {
+                        await this.parseTemplates(join(dir, file), dirPath.concat([file]));
+                        continue;
+                    }
+                    const parts = file.split(".");
+                    parts.pop();
+                    const name = parts.join(".");
+                    const fullName = dirPath.concat([name]).join("-");
+                    const content = readFileSync(path).toString("utf8");
+                    this.templates[fullName] = Handlebars.compile(content);
+                    Handlebars.registerPartial(fullName, content);
+                }
+                resolve();
+            });
+        });
+    }
+    async render(template, language, context) {
+        await this.init();
+        await 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 ? await 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;
+    }
+    async sendMail(language, options) {
+        const subject = await this.translator.getTranslation(language, options.subject || "-");
+        const html = await 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();
+    }
+    async set(key, value, ttl, expirationTimestamp = null, tags = {}) {
+        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);
+    }
+    async get(key) {
+        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 = await this.cache.get(key);
+            this.cacheMap.set(key, {
+                _id: key,
+                data: value,
+                expirationTimestamp: expTimestamp,
+                expiresAt: now + expTimestamp,
+            });
+            return value;
+        }
+        return item.data;
+    }
+    async getOrSet(key, valueCb, ttl, expirationTimestamp = null, tags = {}) {
+        try {
+            return await this.get(key);
+        }
+        catch (e) {
+            return await this.set(key, await valueCb(), ttl, expirationTimestamp, tags);
+        }
+    }
+    async delete(key) {
+        this.cacheMap.delete(key);
+        await 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;
+    }
+    async schemaToExample(src, req) {
+        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 = {};
+            await Promise.all(Object.keys(schema.properties).map(async (key) => {
+                result[key] = await this.schemaToExample(schema.properties[key], req);
+            }));
+            return result;
+        }
+        if (schema.type === "array") {
+            return [await 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 schema.default ?? 0;
+        }
+        else if (schema.type === "boolean") {
+            return schema.default ?? false;
+        }
+        else {
+            return schema.default ?? null;
+        }
+    }
+    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"
+                        };
                     }
-                    const parts = file.split(".");
-                    parts.pop();
-                    const name = parts.join(".");
-                    const fullName = dirPath.concat([name]).join("-");
-                    const content = readFileSync(path).toString("utf8");
-                    this.templates[fullName] = Handlebars.compile(content);
-                    Handlebars.registerPartial(fullName, content);
+                    if (meta.constraintCls === IsObjectId) {
+                        return {
+                            endpoint: constraints[0] || false,
+                            multi: constraints[1] || false,
+                            type: "list"
+                        };
+                    }
+                    return null;
                 }
-                resolve();
-            });
+            }
         });
-    }
-    async render(template, language, context) {
-        await this.init();
-        await 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 ? await 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) {
@@ -2429,7 +2542,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 {
@@ -2460,97 +2575,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}`, async () => {
-            try {
-                const url = this.config.resolve("translationsTemplate")
-                    .replace(`__lang__`, language)
-                    .replace(`[lang]`, language);
-                const data = await 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 = {};
-    }
-    async getDictionary(language) {
-        this.dictionaries[language] = await 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",
@@ -2575,6 +2603,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;
@@ -2655,46 +2743,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 {
@@ -2725,16 +2835,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 {
@@ -2747,11 +2864,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 {
@@ -2772,11 +2893,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
@@ -2951,19 +3076,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 {
@@ -3032,7 +3167,8 @@ let ErrorHandlerMiddleware = class ErrorHandlerMiddleware {
 };
 ErrorHandlerMiddleware = __decorate([
     injectable(),
-    Middleware({ type: "after" })
+    Middleware({ type: "after" }),
+    __metadata("design:paramtypes", [Configuration, Translator])
 ], ErrorHandlerMiddleware);
 
 let ContainerMiddleware = class ContainerMiddleware {
@@ -3047,7 +3183,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 {
@@ -3061,7 +3198,8 @@ let LanguageMiddleware = class LanguageMiddleware {
 };
 LanguageMiddleware = __decorate([
     injectable(),
-    Middleware({ type: "before" })
+    Middleware({ type: "before" }),
+    __metadata("design:paramtypes", [Configuration])
 ], LanguageMiddleware);
 
 let RequestEndedMiddleware = class RequestEndedMiddleware {
@@ -3079,7 +3217,8 @@ let RequestEndedMiddleware = class RequestEndedMiddleware {
 };
 RequestEndedMiddleware = __decorate([
     injectable(),
-    Middleware({ type: "after" })
+    Middleware({ type: "after" }),
+    __metadata("design:paramtypes", [Logger])
 ], RequestEndedMiddleware);
 
 let RequestStartedMiddleware = class RequestStartedMiddleware {
@@ -3095,7 +3234,8 @@ let RequestStartedMiddleware = class RequestStartedMiddleware {
 };
 RequestStartedMiddleware = __decorate([
     injectable(),
-    Middleware({ type: "before" })
+    Middleware({ type: "before" }),
+    __metadata("design:paramtypes", [Logger])
 ], RequestStartedMiddleware);
 
 let ProgressController = class ProgressController {
@@ -3131,17 +3271,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 {
@@ -3252,21 +3399,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 {
@@ -3529,7 +3686,8 @@ let FixturesCommand = class FixturesCommand {
 };
 FixturesCommand = __decorate([
     injectable(),
-    scoped(Lifecycle.ContainerScoped)
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [Fixtures])
 ], FixturesCommand);
 
 const commands = [
@@ -3537,57 +3695,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