@stemy/backend 3.6.0 → 4.0.1

package/fesm2020/stemy-backend.mjs

@@ -0,0 +1,4202 @@
+import { dirname, basename, join, resolve } from 'path';
+import bodyParser from 'body-parser';
+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 fontKit_ from 'fontkit';
+import sharp_ from 'sharp';
+import { ObjectId as ObjectId$1 } from 'bson';
+import axios from 'axios';
+import { mkdir, unlink, readFile as readFile$1, writeFile as writeFile$1, lstat, readdir, access, constants, lstatSync, readFileSync, existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { exec } from 'child_process';
+import { createHash } from 'crypto';
+import { Subscription, Observable, Subject, from, BehaviorSubject } from 'rxjs';
+import { canReportError } from 'rxjs/internal/util/canReportError';
+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 { createTransport } from 'nodemailer';
+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';
+import { getModelForClass } from '@typegoose/typegoose';
+import { getValue as getValue$1, setValue } from 'mongoose/lib/utils';
+
+// --- DI functions ---
+const Type = Function;
+// --- Injection tokens ---
+const FIXTURE = Symbol.for("fixture-token");
+const JOB = Symbol.for("job-token");
+const TERMINAL_COMMAND = Symbol.for("terminal-command-token");
+const EXPRESS = Symbol.for("express-token");
+const HTTP_SERVER = Symbol.for("http-server-token");
+const SOCKET_SERVER = Symbol.for("socket-server-token");
+const SOCKET_CONTROLLERS = Symbol.for("socket-controllers-token");
+const PARAMETER = Symbol.for("parameter-token");
+const DI_CONTAINER = Symbol.for("di-container-token");
+const OPENAPI_VALIDATION = Symbol.for("openapi-validation-token");
+class Parameter {
+    constructor(name, defaultValue, resolver = null) {
+        this.name = name;
+        this.defaultValue = defaultValue;
+        this.resolver = resolver;
+    }
+}
+
+var AssetProcessor_1;
+const sharp$3 = sharp_;
+const fontKit = fontKit_;
+const fontTypes = [
+    "application/font-woff", "application/font-woff2", "application/x-font-opentype", "application/x-font-truetype", "application/x-font-datafork",
+    "font/woff", "font/woff2", "font/otf", "font/ttf", "font/datafork"
+];
+const imageTypes = ["image/jpeg", "image/jpg", "image/png", "image/svg+xml"];
+const fontProps = [
+    "postscriptName", "fullName", "familyName", "subfamilyName",
+    "copyright", "version", "unitsPerEm", "ascent", "descent", "lineGap",
+    "underlinePosition", "underlineThickness", "italicAngle", "capHeight",
+    "xHeight", "numGlyphs", "characterSet", "availableFeatures"
+];
+let AssetProcessor = AssetProcessor_1 = class AssetProcessor {
+    static extractFontFormat(font) {
+        const name = font.constructor.name;
+        const tag = font["directory"].tag;
+        switch (name) {
+            case "TTFFont":
+                return tag === "OTTO" ? "opentype" : "truetype";
+            case "WOFF2Font":
+                return "woff2";
+            case "WOFFFont":
+                return "woff";
+            case "DFont":
+                return "datafork";
+        }
+        return null;
+    }
+    static isImage(contentType) {
+        return imageTypes.indexOf(contentType) >= 0;
+    }
+    static async copyImageMeta(buffer, metadata, fileType) {
+        if (fileType.mime === "image/svg+xml") {
+            const match = /<svg([^<>]+)>/gi.exec(buffer.toString("utf8"));
+            if (match && match.length > 1) {
+                const attrs = match[1].match(/([a-z]+)="([^"]+)"/gi);
+                attrs.forEach(attr => {
+                    if (attr.length < 5)
+                        return;
+                    const [name, value] = attr.split("=");
+                    const val = value.replace(/"/gi, "");
+                    metadata[name] = isNaN(val) ? val : Number(val);
+                });
+                if (metadata.viewBox && (isNaN(metadata.width) || isNaN(metadata.height))) {
+                    const parts = metadata.viewBox.split(" ");
+                    metadata.width = Number(parts[0]) + Number(parts[2]);
+                    metadata.height = Number(parts[1]) + Number(parts[3]);
+                }
+                if (!isNaN(metadata.width) && !isNaN(metadata.height)) {
+                    metadata.svgSize = { x: metadata.width, y: metadata.height };
+                }
+            }
+            return buffer;
+        }
+        const output = await sharp$3(buffer).rotate().toBuffer({ resolveWithObject: true });
+        Object.assign(metadata, output.info);
+        return output.data;
+    }
+    static isFont(contentType) {
+        return fontTypes.indexOf(contentType) >= 0;
+    }
+    static copyFontMeta(buffer, metadata) {
+        const font = fontKit.create(buffer);
+        metadata.format = AssetProcessor_1.extractFontFormat(font);
+        fontProps.forEach(prop => {
+            metadata[prop] = font[prop];
+        });
+    }
+    async process(buffer, metadata, fileType) {
+        if (AssetProcessor_1.isImage(fileType.mime)) {
+            buffer = await AssetProcessor_1.copyImageMeta(buffer, metadata, fileType);
+        }
+        if (AssetProcessor_1.isFont(fileType.mime)) {
+            AssetProcessor_1.copyFontMeta(buffer, metadata);
+        }
+        return buffer;
+    }
+};
+AssetProcessor = AssetProcessor_1 = __decorate([
+    injectable(),
+    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
+};
+function isNullOrUndefined(value) {
+    return value == null || typeof value == "undefined";
+}
+function isDefined(value) {
+    return !isNullOrUndefined(value);
+}
+function getType(obj) {
+    const regex = new RegExp("\\s([a-zA-Z]+)");
+    return Object.prototype.toString.call(obj).match(regex)[1].toLowerCase();
+}
+function isObject(value) {
+    return getType(value) == "object";
+}
+function isArray(value) {
+    return Array.isArray(value);
+}
+function isBuffer(value) {
+    return value instanceof Buffer;
+}
+function isBoolean(value) {
+    return typeof value === "boolean";
+}
+function isDate(value) {
+    return !!value && value[Symbol.toPrimitive] && !isNaN(value) && "undefined" !== typeof value.getDate;
+}
+function isPrimitive(value) {
+    const type = typeof value;
+    return value == null || (type !== "object" && type !== "function");
+}
+function isString(value) {
+    return typeof value === "string";
+}
+function isFunction(value) {
+    return typeof value === "function";
+}
+function isConstructor(value) {
+    return (value && typeof value === "function" && value.prototype && value.prototype.constructor) === value && value.name !== "Object";
+}
+function isType(value) {
+    return isConstructor(value);
+}
+function isInterface(obj, interFaceObject) {
+    if (!obj || typeof obj !== "object" || isArray(obj) || !isObject(interFaceObject))
+        return false;
+    const keys = Object.keys(interFaceObject);
+    for (const key of keys) {
+        let type = interFaceObject[key] || "";
+        if (type.startsWith("*")) {
+            type = type.substr(1);
+            if (obj.hasOwnProperty(key) && getType(obj[key]) !== type)
+                return false;
+        }
+        else if (!obj.hasOwnProperty(key) || getType(obj[key]) !== type) {
+            return false;
+        }
+    }
+    return true;
+}
+function ucFirst(value) {
+    if (!value)
+        return "";
+    return value[0].toUpperCase() + value.substr(1);
+}
+function lcFirst(value) {
+    if (!value)
+        return "";
+    return value[0].toLowerCase() + value.substr(1);
+}
+function isObjectId(id) {
+    return typeof id === "string" && id.length == 24 && !isNaN(Number("0x" + id));
+}
+function firstItem(value) {
+    return value[0];
+}
+function lastItem(value) {
+    return value[value.length - 1];
+}
+function regroup(value, comparator) {
+    const result = [];
+    if (!isArray(value) || value.length == 0)
+        return result;
+    value = Array.from(value);
+    result.push([value.shift()]);
+    value.forEach(item => {
+        const group = result.find(g => g.some(a => comparator(a, item)));
+        if (group) {
+            group.push(item);
+            return;
+        }
+        result.push([item]);
+    });
+    return result;
+}
+function uniqueItems(value) {
+    return value.filter((v, ix) => value.indexOf(v) === ix);
+}
+function getValue(obj, key, defaultValue, treeFallback = false) {
+    key = key || "";
+    const keys = key.split(".");
+    let curKey = "";
+    do {
+        curKey += keys.shift();
+        if (isDefined(obj) && isDefined(obj[curKey]) && (typeof obj[curKey] === "object" || !keys.length)) {
+            obj = obj[curKey];
+            curKey = "";
+        }
+        else if (!keys.length) {
+            defaultValue = typeof defaultValue == "undefined" ? key.replace(new RegExp(`${curKey}$`), `{${curKey}}`) : defaultValue;
+            obj = treeFallback ? obj || defaultValue : defaultValue;
+        }
+        else {
+            curKey += ".";
+        }
+    } while (keys.length);
+    return obj;
+}
+function groupBy(items, cb) {
+    return items.reduce((res, item) => {
+        const group = cb(item);
+        res[group] = res[group] || [];
+        res[group].push(item);
+        return res;
+    }, {});
+}
+function convertValue(value, type) {
+    switch (type) {
+        case "boolean":
+            value = typeof value == "string" ? value.toLowerCase() : value;
+            return (value == "no" || value == "false" || value == "0") ? false : !!value;
+        case "number":
+            const val = parseFloat(value);
+            return isNaN(val) ? 0 : val;
+        case "array":
+            try {
+                return JSON.parse(value);
+            }
+            catch (e) {
+                return `${value}`.split(", ");
+            }
+    }
+    return value;
+}
+const cropInterface = {
+    x: "number",
+    y: "number",
+    w: "number",
+    h: "number"
+};
+function toCropRegion(cropInfo) {
+    let crop = cropInfo;
+    if (isString(cropInfo)) {
+        try {
+            crop = JSON.parse(cropInfo);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    if (!isInterface(crop, cropInterface))
+        return null;
+    return {
+        width: Math.round(crop.w),
+        height: Math.round(crop.h),
+        top: Math.round(crop.y),
+        left: Math.round(crop.x)
+    };
+}
+async function toImage(src, params, meta) {
+    // Default params and meta
+    params = params || {};
+    meta = meta || {};
+    // Get default crop info
+    const crop = toCropRegion(meta.crop);
+    // Return the src if there are no params and no default crop exists
+    if (meta.extension === "svg" || (Object.keys(params).length == 0 && !crop)) {
+        return src;
+    }
+    // Parse params
+    params.rotation = isNaN(params.rotation) ? 0 : Math.round(params.rotation / 90) * 90;
+    params.canvasScaleX = isNaN(params.canvasScaleX) ? 1 : Number(params.canvasScaleX);
+    params.canvasScaleY = isNaN(params.canvasScaleY) ? 1 : Number(params.canvasScaleY);
+    params.scaleX = isNaN(params.scaleX) ? 1 : Number(params.scaleX);
+    params.scaleY = isNaN(params.scaleY) ? 1 : Number(params.scaleY);
+    params.crop = isBoolean(params.crop) ? params.crop : params.crop == "true";
+    let buffer = src instanceof Readable ? await streamToBuffer(src) : src;
+    try {
+        // Get crop info
+        const cropBefore = toCropRegion(params.cropBefore || (params.crop ? meta.cropBefore : null));
+        const cropAfter = toCropRegion(params.cropAfter || (params.crop ? meta.cropAfter : null));
+        // Get metadata
+        let img = sharp$2(buffer);
+        let { width, height } = await img.metadata();
+        // Crop before resize
+        if (cropBefore) {
+            width = cropBefore.width;
+            height = cropBefore.height;
+            img = img.extract(cropBefore);
+        }
+        else if (crop) {
+            width = crop.width;
+            height = crop.height;
+            img = img.extract(crop);
+        }
+        // Resize canvas
+        const canvasScaleX = meta?.canvasScaleX || 1;
+        const canvasScaleY = meta?.canvasScaleY || 1;
+        if (params.canvasScaleX !== canvasScaleX || params.canvasScaleY !== canvasScaleY) {
+            width = Math.round(width * params.canvasScaleX);
+            height = Math.round(height * params.canvasScaleY);
+            img = img.resize({ width, height, background: "#00000000", fit: "contain" });
+        }
+        // Resize image
+        if (params.scaleX !== 1 || params.scaleY !== 1) {
+            width = Math.round(width * params.scaleX);
+            height = Math.round(height * params.scaleY);
+            img = img.resize({ width, height, background: "#00000000", fit: "fill" });
+        }
+        // Crop after resize
+        if (cropAfter) {
+            img = img.extract(cropAfter);
+        }
+        // Rotate
+        if (params.rotation !== 0) {
+            buffer = await img.toBuffer();
+            img = sharp$2(buffer).rotate(params.rotation);
+        }
+        buffer = await img.toBuffer();
+        src = src instanceof Readable ? bufferToStream(buffer) : buffer;
+        return src;
+    }
+    catch (e) {
+        console.log("Image conversion error", e);
+        src = src instanceof Readable ? bufferToStream(buffer) : buffer;
+        return src;
+    }
+}
+function bufferToStream(buffer) {
+    const readStream = new PassThrough();
+    readStream.end(buffer);
+    return readStream;
+}
+function streamToBuffer(stream) {
+    return new Promise((resolve, reject) => {
+        const concat = [];
+        stream.on("data", data => {
+            concat.push(data);
+        });
+        stream.on("error", reject);
+        stream.on("end", () => resolve(Buffer.concat(concat)));
+    });
+}
+class ReadableStreamClone extends Readable {
+    constructor(readableStream, opts) {
+        super(opts);
+        readableStream?.on("data", chunk => {
+            this.push(chunk);
+        });
+        readableStream?.on("end", () => {
+            this.push(null);
+        });
+        readableStream?.on("error", err => {
+            this.emit("error", err);
+        });
+    }
+    _read(size) {
+    }
+}
+function copyStream(stream, opts) {
+    return new ReadableStreamClone(stream, opts);
+}
+function mkdirRecursive(path, mode = null) {
+    return new Promise((resolve, reject) => {
+        mkdir(path, { mode: mode || 0o777, recursive: true }, err => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+function deleteFile(path) {
+    return new Promise((resolve, reject) => {
+        unlink(path, err => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+function readFile(path) {
+    return new Promise((res, rej) => {
+        readFile$1(path, (err, data) => {
+            if (err) {
+                rej(err);
+                return;
+            }
+            res(data);
+        });
+    });
+}
+async function readAndDeleteFile(path, timeout = 5000) {
+    const data = await readFile(path);
+    setTimeout(() => {
+        unlink(path, () => {
+        });
+    }, timeout);
+    return data;
+}
+async function writeFile(path, data) {
+    await mkdirRecursive(dirname(path));
+    return new Promise((res, rej) => {
+        writeFile$1(path, data, err => {
+            if (err) {
+                rej(err);
+                return;
+            }
+            res(data);
+        });
+    });
+}
+function valueToPromise(value) {
+    return value instanceof Promise ? value : Promise.resolve(value);
+}
+function promiseTimeout(timeout = 1000, error = false) {
+    return new Promise((resolve, reject) => {
+        setTimeout(() => {
+            if (error) {
+                reject(`Timeout exceeded: ${timeout}ms`);
+                return;
+            }
+            resolve(`Timeout: ${timeout}ms`);
+        }, timeout);
+    });
+}
+function getConstructorName(type) {
+    return type.prototype.constructor.name;
+}
+function getFunctionParams(func) {
+    // Remove comments of the form /* ... */
+    // Removing comments of the form //
+    // Remove body of the function { ... }
+    // removing "=>" if func is arrow function
+    const str = func.toString()
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/\/\/(.)*/g, "")
+        .replace(/{[\s\S]*}/, "")
+        .replace(/=>/g, "")
+        .trim();
+    // Start parameter names after first "("
+    const start = str.indexOf("(") + 1;
+    // End parameter names is just before last ")"
+    const end = str.length - 1;
+    const result = str.substring(start, end).split(", ");
+    const params = [];
+    result.forEach(element => {
+        // Removing any default value
+        element = element.replace(/=[\s\S]*/g, "").trim();
+        if (element.length > 0)
+            params.push(element);
+    });
+    return params;
+}
+function getFileName(path, withExtension = false) {
+    const name = basename(path || "");
+    return withExtension ? name : name.split(".").slice(0, -1).join(".");
+}
+function getExtension(path) {
+    const name = basename(path || "");
+    return name.split(".").pop();
+}
+function createIdString() {
+    return new ObjectId().toHexString();
+}
+function idToString(value) {
+    if (Array.isArray(value)) {
+        return value.map(idToString);
+    }
+    return value instanceof ObjectId || value instanceof Types.ObjectId
+        ? value.toHexString()
+        : (isString(value) ? value : value || null);
+}
+function createTransformer(transform) {
+    return (doc, ret, options) => {
+        ret.id = idToString(ret.id) || ret.id;
+        if (doc._id) {
+            ret._id = idToString(doc._id);
+            ret.id = ret.id || ret._id;
+        }
+        delete ret.__v;
+        return isFunction(transform) ? transform(doc, ret, options) || ret : ret;
+    };
+}
+function broadcast(socketServer, cb) {
+    Array.from(Object.values(socketServer.sockets.sockets)).forEach(cb);
+}
+function rand(min, max) {
+    return Math.round(random(min, max));
+}
+function random(min, max) {
+    return min + Math.random() * (max - min);
+}
+function multiSubscription(...subscriptions) {
+    return new Subscription(() => {
+        subscriptions.forEach(s => {
+            s.unsubscribe();
+        });
+    });
+}
+function observableFromFunction(callbackFunc) {
+    let subject;
+    return new Observable((subscriber) => {
+        if (!subject) {
+            subject = new Subject();
+            try {
+                subject = from(callbackFunc());
+            }
+            catch (err) {
+                if (canReportError(subject)) {
+                    subject.error(err);
+                }
+                else {
+                    console.warn(err);
+                }
+            }
+        }
+        return subject.subscribe(subscriber);
+    });
+}
+function padLeft(value, count = 3, padWith = "0") {
+    return `${value}`.padStart(count, padWith);
+}
+function padRight(value, count = 3, padWith = "0") {
+    return `${value}`.padEnd(count, padWith);
+}
+function camelCaseToDash(str) {
+    return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function deleteFromBucket(bucket, fileId) {
+    return new Promise(((resolve, reject) => {
+        bucket.delete(fileId, error => {
+            let err = error;
+            if (error) {
+                err = error.message || error || "";
+                if (!isString(err) || !err.startsWith("FileNotFound")) {
+                    reject(err);
+                    return;
+                }
+            }
+            resolve(fileId.toHexString());
+        });
+    }));
+}
+const defaultPredicate = () => true;
+function copyRecursive(target, source, predicate) {
+    predicate = predicate || defaultPredicate;
+    if (isPrimitive(source) || isDate(source) || isFunction(source))
+        return source;
+    if (isArray(source)) {
+        target = isArray(target) ? Array.from(target) : [];
+        source.forEach((item, index) => {
+            if (!predicate(item, index, target, source))
+                return;
+            if (target.length > index)
+                target[index] = copyRecursive(target[index], item, predicate);
+            else
+                target.push(copyRecursive(null, item, predicate));
+        });
+        return target;
+    }
+    if (isBuffer(source))
+        return Buffer.from(source);
+    const shouldCopy = isFunction(source.__shouldCopy) ? source.__shouldCopy : () => true;
+    if (isConstructor(source.constructor)) {
+        if (source.__shouldCopy === false)
+            return source;
+        if (!target) {
+            try {
+                target = new source.constructor();
+            }
+            catch (e) {
+                const proto = source.constructor.prototype || source.prototype;
+                target = Object.create(proto);
+            }
+        }
+    }
+    else {
+        target = Object.assign({}, target || {});
+    }
+    // Copy map entries
+    if (target instanceof Map) {
+        if (source instanceof Map) {
+            for (let [key, value] of source.entries()) {
+                if (!predicate(value, key, target, source))
+                    continue;
+                target.set(key, !shouldCopy(key, value) ? value : copyRecursive(target.get(key), value, predicate));
+            }
+        }
+        return target;
+    }
+    // Copy object members
+    let keys = Object.keys(source);
+    target = keys.reduce((result, key) => {
+        if (!predicate(source[key], key, result, source))
+            return result;
+        result[key] = !shouldCopy(key, source[key]) ? source[key] : copyRecursive(result[key], source[key], predicate);
+        return result;
+    }, target);
+    // Copy object properties
+    const descriptors = Object.getOwnPropertyDescriptors(source);
+    keys = Object.keys(descriptors).filter(k => keys.indexOf(k) < 0);
+    keys.forEach(key => {
+        Object.defineProperty(target, key, descriptors[key]);
+    });
+    return target;
+}
+function filter(obj, predicate) {
+    return copyRecursive(null, obj, predicate);
+}
+function copy(obj) {
+    return copyRecursive(null, obj);
+}
+function assign(target, source, predicate) {
+    return copyRecursive(target, source, predicate);
+}
+function md5(data) {
+    if (isObject(data)) {
+        data = JSON.stringify(data);
+    }
+    if (!isString(data)) {
+        throw `Can't md5 other that raw object or string`;
+    }
+    return createHash("md5").update(data).digest("hex");
+}
+function runCommand(scriptPath, expectedCode = 0) {
+    return new Promise((resolve, reject) => {
+        const cp = exec(scriptPath, (error, stdout) => {
+            if (error && expectedCode !== error.code) {
+                console.log(error);
+                reject(error);
+                return;
+            }
+            const lines = (stdout || "").split("\n");
+            let line = null;
+            while (!line && lines.length > 0) {
+                line = lines.pop();
+            }
+            resolve(line);
+        });
+        cp.stdout.on("data", function (data) {
+            console.log(data.toString());
+        });
+        cp.stderr.on("data", function (data) {
+            console.error(data.toString());
+        });
+    });
+}
+var ConsoleColor;
+(function (ConsoleColor) {
+    ConsoleColor["Reset"] = "\u001B[0m";
+    ConsoleColor["Bright"] = "\u001B[1m";
+    ConsoleColor["Dim"] = "\u001B[2m";
+    ConsoleColor["Underscore"] = "\u001B[4m";
+    ConsoleColor["Blink"] = "\u001B[5m";
+    ConsoleColor["Reverse"] = "\u001B[7m";
+    ConsoleColor["Hidden"] = "\u001B[8m";
+    ConsoleColor["FgBlack"] = "\u001B[30m";
+    ConsoleColor["FgRed"] = "\u001B[31m";
+    ConsoleColor["FgGreen"] = "\u001B[32m";
+    ConsoleColor["FgYellow"] = "\u001B[33m";
+    ConsoleColor["FgBlue"] = "\u001B[34m";
+    ConsoleColor["FgMagenta"] = "\u001B[35m";
+    ConsoleColor["FgCyan"] = "\u001B[36m";
+    ConsoleColor["FgWhite"] = "\u001B[37m";
+    ConsoleColor["FgDefault"] = "\u001B[38m";
+    ConsoleColor["BgBlack"] = "\u001B[40m";
+    ConsoleColor["BgRed"] = "\u001B[41m";
+    ConsoleColor["BgGreen"] = "\u001B[42m";
+    ConsoleColor["BgYellow"] = "\u001B[43m";
+    ConsoleColor["BgBlue"] = "\u001B[44m";
+    ConsoleColor["BgMagenta"] = "\u001B[45m";
+    ConsoleColor["BgCyan"] = "\u001B[46m";
+    ConsoleColor["BgWhite"] = "\u001B[47m";
+    ConsoleColor["BgDefault"] = "\u001B[48m";
+})(ConsoleColor || (ConsoleColor = {}));
+const defaultColors = {
+    keyColor: ConsoleColor.FgWhite,
+    numberColor: ConsoleColor.FgBlue,
+    stringColor: ConsoleColor.FgYellow,
+    trueColor: ConsoleColor.FgGreen,
+    falseColor: ConsoleColor.FgRed,
+    nullColor: ConsoleColor.BgMagenta
+};
+function colorize(input, color) {
+    return `${color}${input}${ConsoleColor.Reset}`;
+}
+function jsonHighlight(input, colorOptions) {
+    const colors = Object.assign({}, defaultColors, colorOptions);
+    const json = (isString(input) ? input : JSON.stringify(input, null, 2)).replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>');
+    return json.replace(/("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+]?\d+)?)/g, (match) => {
+        let color = colors.numberColor;
+        if (/^"/.test(match)) {
+            if (/:$/.test(match)) {
+                color = colors.keyColor;
+            }
+            else {
+                color = colors.stringColor;
+                match = '"' + match.substr(1, match.length - 2) + '"';
+            }
+        }
+        else {
+            color = /true/.test(match)
+                ? colors.trueColor
+                : /false/.test(match)
+                    ? colors.falseColor
+                    : /null/.test(match)
+                        ? colors.nullColor
+                        : color;
+        }
+        return `${color}${match}${ConsoleColor.Reset}`;
+    });
+}
+function replaceSpecialChars(str, to = "-") {
+    return `${str}`.replace(/[&\/\\#, +()$~%.@'":*?<>{}]/g, to);
+}
+function regexEscape(str) {
+    return `${str}`.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+function flatten(arr) {
+    return arr.reduce((flat, toFlatten) => {
+        return flat.concat(isArray(toFlatten) ? flatten(toFlatten) : toFlatten);
+    }, []);
+}
+function wrapError(e, message, httpCode = 500) {
+    if (axios.isAxiosError(e)) {
+        e.message = message;
+        return e;
+    }
+    return new HttpError(httpCode, `${message}: ${e}`);
+}
+function getDirName() {
+    if (typeof __dirname === "undefined") {
+        const __filename = fileURLToPath(import.meta.url);
+        return dirname(__filename);
+    }
+    return __dirname;
+}
+function prepareUrl(ending = "/") {
+    return url => {
+        return url ? `${url.replace(/\/+$/, "")}${ending}` : ending;
+    };
+}
+const prepareUrlSlash = prepareUrl("/");
+const prepareUrlEmpty = prepareUrl("");
+function checkTextFileType(type) {
+    return type.mime.indexOf("text") >= 0 || type.mime.indexOf("xml") >= 0;
+}
+function fixTextFileType(type, buffer) {
+    const text = buffer.toString("utf8");
+    if (text.indexOf("<svg") >= 0) {
+        return { ext: "svg", mime: "image/svg+xml" };
+    }
+    return type;
+}
+async function fileTypeFromBuffer(buffer) {
+    const stream = bufferToStream(buffer);
+    const type = (await fileTypeFromStream(stream) ?? { ext: "txt", mime: "text/plain" });
+    if (checkTextFileType(type)) {
+        return fixTextFileType(type, buffer);
+    }
+    return type;
+}
+
+class BaseEntity {
+    constructor(mId, data, collection) {
+        this.mId = mId;
+        this.data = data;
+        this.collection = collection;
+    }
+    get id() {
+        return this.mId.toHexString();
+    }
+    save() {
+        return this.collection.updateOne({ _id: this.mId }, { $set: this.toJSON() });
+    }
+    async load() {
+        const res = await this.collection.findOne({ _id: this.mId });
+        this.deleted = !res;
+        this.data = res || {};
+        return this;
+    }
+    toJSON() {
+        const ret = Object.assign({}, this.data);
+        delete ret._id;
+        ret.id = this.id;
+        return ret;
+    }
+}
+
+class Asset extends BaseEntity {
+    constructor(id, data, collection, bucket) {
+        super(id, data, collection);
+        this.bucket = bucket;
+    }
+    get filename() {
+        return this.data.filename;
+    }
+    get contentType() {
+        return this.data.contentType;
+    }
+    get metadata() {
+        return this.data.metadata;
+    }
+    get stream() {
+        return this.bucket.openDownloadStream(this.mId);
+    }
+    async unlink() {
+        return deleteFromBucket(this.bucket, this.mId);
+    }
+    getBuffer() {
+        return streamToBuffer(this.stream);
+    }
+    async download(metadata) {
+        metadata = Object.assign(this.metadata, metadata || {});
+        metadata.downloadCount = isNaN(metadata.downloadCount) || !metadata.firstDownload
+            ? 1
+            : metadata.downloadCount + 1;
+        metadata.firstDownload = metadata.firstDownload || new Date();
+        metadata.lastDownload = new Date();
+        await this.collection.updateOne({ _id: this.mId }, { $set: { metadata } });
+        return this.stream;
+    }
+    async getImage(params = null) {
+        return toImage(this.stream, params, this.metadata);
+    }
+    async downloadImage(params, metadata) {
+        return toImage(await this.download(metadata), params, this.metadata);
+    }
+}
+
+class TempAsset {
+    constructor(buffer, filename, contentType, metadata) {
+        this.buffer = buffer;
+        this.filename = filename;
+        this.contentType = contentType;
+        this.metadata = metadata;
+        this.id = new ObjectId$1().toHexString();
+    }
+    get stream() {
+        return bufferToStream(this.buffer);
+    }
+    async unlink() {
+        throw new Error(`Temp asset '${this.id}' can not be removed!`);
+    }
+    async getBuffer() {
+        return this.buffer;
+    }
+    async download(metadata) {
+        return this.stream;
+    }
+    downloadImage(params, metadata) {
+        Object.assign(this.metadata, metadata || {});
+        return toImage(this.stream, params, this.metadata);
+    }
+    getImage(params) {
+        return this.downloadImage(params);
+    }
+    async save() {
+        return this;
+    }
+    async load() {
+        return this;
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            filename: this.filename,
+            contentType: this.contentType,
+            metadata: this.metadata
+        };
+    }
+}
+
+let Assets = class Assets {
+    constructor(connector, assetProcessor) {
+        this.connector = connector;
+        this.assetProcessor = assetProcessor;
+        this.bucket = connector.bucket;
+        this.collection = connector.database?.collection("assets.files");
+    }
+    async write(stream, contentType = null, metadata = null) {
+        const uploadStream = copyStream(stream);
+        const buffer = await streamToBuffer(stream);
+        let fileType = { ext: "", mime: contentType };
+        try {
+            fileType = await fileTypeFromBuffer(buffer);
+        }
+        catch (e) {
+            if (!fileType.mime) {
+                throw new Error(`Can't determine mime type: ${e}`);
+            }
+            console.log(`Can't determine mime type`, e);
+        }
+        metadata = metadata || {};
+        return this.upload(uploadStream, fileType, metadata);
+    }
+    async writeBuffer(buffer, metadata = null, contentType = null) {
+        let fileType = { ext: "", mime: contentType };
+        try {
+            fileType = await fileTypeFromBuffer(buffer);
+        }
+        catch (e) {
+            if (!fileType.mime) {
+                throw `Can't determine mime type`;
+            }
+            console.log(`Can't determine mime type`, e);
+        }
+        metadata = metadata || {};
+        buffer = await this.assetProcessor.process(buffer, metadata, fileType);
+        return this.upload(bufferToStream(buffer), fileType, metadata);
+    }
+    async writeUrl(url, metadata = null) {
+        metadata = metadata || {};
+        metadata.filename = metadata.filename || url;
+        metadata.url = url;
+        metadata.uploadTime = new Date().getTime();
+        const oneWeek = 1000 * 3600 * 24 * 7;
+        const asset = await this.find({ "metadata.url": url, "metadata.uploadTime": { $gt: metadata.uploadTime - oneWeek } });
+        if (asset)
+            return asset;
+        const buffer = (await axios({ url, responseType: "arraybuffer" })).data;
+        return this.writeBuffer(buffer, metadata);
+    }
+    async download(url, contentType = null) {
+        let buffer = (await axios({ url, responseType: "arraybuffer" })).data;
+        let fileType = { ext: "", mime: contentType };
+        try {
+            fileType = await fileTypeFromBuffer(buffer);
+        }
+        catch (e) {
+            if (!fileType.mime) {
+                throw `Can't determine mime type`;
+            }
+            console.log(`Can't determine mime type`, e);
+        }
+        const metadata = {
+            filename: url,
+            extension: (fileType.ext || "").trim()
+        };
+        buffer = await this.assetProcessor.process(buffer, metadata, fileType);
+        return new TempAsset(buffer, url, fileType.mime, metadata);
+    }
+    async read(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 Asset(data._id, data, this.collection, this.bucket);
+    }
+    async findMany(where) {
+        const cursor = this.collection.find(where);
+        const items = await cursor.toArray() || [];
+        const result = [];
+        for (let item of items) {
+            if (!item)
+                continue;
+            result.push(new Asset(item._id, item, this.collection, this.bucket));
+        }
+        return result;
+    }
+    async deleteMany(where) {
+        const assets = await this.findMany(where);
+        return Promise.all(assets.map(a => a.unlink()));
+    }
+    async unlink(id) {
+        const asset = await this.read(id);
+        if (!asset)
+            return null;
+        return asset.unlink();
+    }
+    async upload(stream, fileType, metadata) {
+        const contentType = fileType.mime.trim();
+        metadata = Object.assign({
+            downloadCount: 0,
+            firstDownload: null,
+            lastDownload: null
+        }, metadata || {});
+        metadata.filename = metadata.filename || new ObjectId$1().toHexString();
+        metadata.extension = (fileType.ext || "").trim();
+        return new Promise(((resolve, reject) => {
+            const uploaderStream = this.bucket.openUploadStream(metadata.filename);
+            stream.pipe(uploaderStream)
+                .on("error", error => {
+                reject(error.message || error);
+            })
+                .on("finish", () => {
+                const asset = new Asset(uploaderStream.id, {
+                    filename: metadata.filename,
+                    contentType,
+                    metadata
+                }, this.collection, this.bucket);
+                asset.save().then(() => {
+                    resolve(asset);
+                }, error => {
+                    reject(error.message || error);
+                });
+            });
+        }));
+    }
+};
+Assets = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], Assets);
+
+const express = express_;
+let BackendProvider = class BackendProvider {
+    constructor() {
+        this.express = express();
+        this.express.set("trust proxy", true);
+        this.server = createServer(this.express);
+    }
+    get io() {
+        this.ioServer = this.ioServer || new Server(this.server, { path: "/socket" });
+        return this.ioServer;
+    }
+};
+BackendProvider = __decorate([
+    singleton()
+], BackendProvider);
+
+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 = {}) {
+        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;
+    }
+    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}`);
+        }
+        return await this.cacheProcessor.deserialize(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) {
+        await this.prepare();
+        await this.collection.deleteOne({ _id: key });
+    }
+};
+Cache = __decorate([
+    singleton()
+], Cache);
+
+let CacheProcessor = class CacheProcessor {
+    async serialize(data) {
+        return data;
+    }
+    async deserialize(data) {
+        return data;
+    }
+};
+CacheProcessor = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], CacheProcessor);
+
+let Configuration = class Configuration {
+    constructor(params) {
+        dotenv.config();
+        this.paramMap = {};
+        this.paramValues = {};
+        (params || []).forEach(param => this.add(param));
+    }
+    add(param) {
+        const existingParam = this.paramMap[param.name] || param;
+        existingParam.defaultValue = param.defaultValue;
+        existingParam.resolver = param.resolver || existingParam.resolver;
+        this.paramMap[param.name] = existingParam;
+    }
+    resolveValue(param, alreadyResolved) {
+        const envName = param.name.replace(/\.?([A-Z|0-9]+)/g, function (x, y) {
+            return "_" + y.toLowerCase();
+        }).replace(/\./gi, "_").replace(/^_/, "").toUpperCase();
+        const envValue = process.env[envName];
+        const helper = (p) => this.resolveInternal(p, alreadyResolved);
+        if (typeof envValue !== "undefined") {
+            const value = isFunction(param.resolver)
+                ? param.resolver(envValue, helper)
+                : convertValue(envValue, getType(param.defaultValue));
+            console.log(colorize(`Processing param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), colorize(envName, ConsoleColor.FgBlue), `"${envValue}"`, value);
+            return value;
+        }
+        else if (isFunction(param.resolver)) {
+            const value = param.resolver(param.defaultValue, helper);
+            console.log(colorize(`Processing default param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), param.defaultValue, value);
+            return value;
+        }
+        console.log(colorize(`Using default param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), param.defaultValue);
+        return param.defaultValue;
+    }
+    hasParam(name) {
+        return !!this.paramMap[name];
+    }
+    resolve(name) {
+        return this.resolveInternal(name, []);
+    }
+    resolveInternal(name, alreadyResolved) {
+        if (alreadyResolved.includes(name)) {
+            throw new Error(`Circular dependency detected: ${alreadyResolved.join(" -> ")} -> ${name}`);
+        }
+        alreadyResolved.push(name);
+        const param = this.paramMap[name];
+        if (!param)
+            throw new Error(`Parameter with name: '${name}' does not exists in configuration`);
+        if (!(name in this.paramValues)) {
+            this.paramValues[name] = this.resolveValue(param, alreadyResolved);
+        }
+        return this.paramValues[name];
+    }
+};
+Configuration = __decorate([
+    singleton(),
+    __param(0, injectAll(PARAMETER))
+], Configuration);
+
+let EndpointProvider = class EndpointProvider {
+    async configure(app) {
+        console.log(`Express app is mounted to: ${app.mountpath}`);
+    }
+};
+EndpointProvider = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], EndpointProvider);
+
+let Fixtures = class Fixtures {
+    constructor(fixtures) {
+        this.fixtures = fixtures;
+    }
+    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);
+        }
+    }
+};
+Fixtures = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __param(0, injectAll(FIXTURE))
+], Fixtures);
+
+const sharp$1 = sharp_;
+let Gallery = class Gallery {
+    constructor(config, galleryCache) {
+        this.config = config;
+        this.galleryCache = galleryCache;
+        this.cache = {};
+        this.dir = this.config.resolve("galleryDir");
+        this.output = join(this.config.resolve("cacheDir"), "gallery");
+    }
+    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];
+    }
+    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));
+                });
+            });
+        });
+    }
+};
+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;
+    }
+    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);
+    }
+}
+
+let GalleryCache = class GalleryCache {
+    constructor() {
+        this.imgCache = {};
+    }
+    put(img) {
+        this.imgCache[img.thumb] = img;
+        this.imgCache[img.big] = img;
+    }
+    serve(id) {
+        const img = this.imgCache[id];
+        return !img ? null : img.serve(id);
+    }
+    create(folder, targetSize, handler) {
+        const image = new GalleryImage(folder, targetSize, handler);
+        this.put(image);
+        return image;
+    }
+};
+GalleryCache = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], GalleryCache);
+
+let IdGenerator = class IdGenerator {
+    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 generate(checkCb) {
+        let id = null;
+        let tries = 0;
+        let notGood = true;
+        while (notGood && tries < 5) {
+            id = this.generateId();
+            notGood = await checkCb(id);
+            tries++;
+        }
+        if (notGood) {
+            throw `Couldn't generate an unique id..`;
+        }
+        return id;
+    }
+    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)
+], 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");
+    }
+    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);
+        }
+        catch (e) {
+            const jobName = getConstructorName(jobType);
+            throw new Error(`Can't resolve params for job: ${jobName}, with params: ${JSON.stringify(params)}. Reason: ${e}`);
+        }
+        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);
+    }
+    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 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;
+        }
+        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}`);
+            }
+        });
+    }
+    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;
+    }
+    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);
+    }
+    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;
+    }
+};
+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 jobName() {
+        return this.data.jobName;
+    }
+    get jobParams() {
+        return this.data.jobParams;
+    }
+    get jobQue() {
+        return this.data.jobQue;
+    }
+    get progressId() {
+        return this.data.progressId;
+    }
+    get assetId() {
+        return this.data.assetId;
+    }
+    async unlink() {
+        await this.load();
+        if (!this.progressId) {
+            await this.collection.deleteOne({ _id: this.mId });
+        }
+        return deleteFromBucket(this.assets.bucket, new ObjectId$1(this.assetId));
+    }
+    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);
+        }
+        if (this.progressId) {
+            await this.progresses.waitToFinish(this.progressId);
+            return this.loadAsset();
+        }
+        await this.startWorkingOnAsset(true);
+        return this.loadAsset();
+    }
+    async writeAsset(asset) {
+        this.data.assetId = asset.id;
+        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 });
+    }
+}
+
+let LazyAssets = class LazyAssets {
+    constructor(connector, assets, progresses, logger, jobMan) {
+        this.connector = connector;
+        this.assets = assets;
+        this.progresses = progresses;
+        this.logger = logger;
+        this.jobMan = jobMan;
+        this.collection = connector.database.collection("lazyassets");
+    }
+    async create(jobType, jobParams = {}, jobQue = "main") {
+        const jobName = this.jobMan.tryResolve(jobType, { ...jobParams, lazyId: "" });
+        const data = {
+            jobName,
+            jobParams,
+            jobQue
+        };
+        const existingAsset = await this.find(data);
+        if (existingAsset)
+            return existingAsset;
+        const res = await this.collection.insertOne(data);
+        return new LazyAsset(res.insertedId, data, this.collection, this.logger, this.assets, this.progresses);
+    }
+    async read(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 LazyAsset(data._id, data, this.collection, this.logger, this.assets, this.progresses);
+    }
+    async unlink(id) {
+        const asset = await this.read(id);
+        if (!asset)
+            return null;
+        return asset.unlink();
+    }
+};
+LazyAssets = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], LazyAssets);
+
+let Logger = class Logger {
+    constructor(config) {
+        this.config = config;
+        this.tags = this.config.resolve("logTags");
+        this.ignoredTags = this.config.resolve("ignoredLogTags");
+    }
+    log(tag, ...params) {
+        if (this.ignoredTags.includes(tag))
+            return;
+        if (this.tags.length === 0 || this.tags.includes(tag)) {
+            console.log(`[${tag}]`, ...params);
+        }
+    }
+};
+Logger = __decorate([
+    singleton()
+], Logger);
+
+let MailSender = class MailSender {
+    constructor(config, renderer) {
+        this.config = config;
+        this.renderer = renderer;
+        this.transporter = createTransport({
+            host: this.config.resolve("smtpHost"),
+            port: this.config.resolve("smtpPort"),
+            auth: {
+                user: this.config.resolve("smtpUser"),
+                pass: this.config.resolve("smtpPassword"),
+            }
+        });
+    }
+    get translator() {
+        return this.renderer.translator;
+    }
+    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()
+], 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)
+], MemoryCache);
+
+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()
+], MongoConnector);
+
+function checkValue(multi, value) {
+    if (multi) {
+        return Array.isArray(value) && value.every(v => {
+            try {
+                const id = new ObjectId$1(v);
+                return id instanceof ObjectId$1;
+            }
+            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"
+                        };
+                    }
+                    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);
+    }
+    get current() {
+        return this.data.current;
+    }
+    get max() {
+        return this.data.max;
+    }
+    get message() {
+        return this.data.message;
+    }
+    get error() {
+        return this.data.error;
+    }
+    get canceled() {
+        return this.data.canceled;
+    }
+    get percent() {
+        return this.max > 0 ? Math.round(this.current / this.max * 100) : 0;
+    }
+    get remaining() {
+        return this.max > 0 ? this.max - this.current : 0;
+    }
+    setMessageBridge(messageBridge) {
+        this.messageBridge = messageBridge || this.messageBridge;
+        return this;
+    }
+    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;
+    }
+    setMessageBridge(messageBridge) {
+        if (!this.parent)
+            return this;
+        this.parent.setMessageBridge(messageBridge);
+        return this;
+    }
+    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 setMax(max) {
+        if (isNaN(max) || max <= 0) {
+            throw "Max progress value must be bigger than zero";
+        }
+        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";
+        }
+        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;
+    }
+    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()
+], Progresses);
+
+let TemplateRenderer = class TemplateRenderer {
+    constructor(translator, config) {
+        this.translator = translator;
+        this.config = config;
+        this.templates = {};
+        Handlebars.registerHelper(`object`, function ({ hash }) {
+            return hash;
+        });
+        Handlebars.registerHelper(`now`, function () {
+            return new Date().getTime();
+        });
+        Handlebars.registerHelper(`keys`, function (obj) {
+            return !obj ? [] : Object.keys(obj);
+        });
+        Handlebars.registerHelper(`translate`, function (key, params) {
+            return translator.getTranslationSync(this.language, key, params);
+        });
+    }
+    init() {
+        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;
+                    }
+                    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()
+], TemplateRenderer);
+
+let TerminalManager = class TerminalManager {
+    constructor(logger, config, commands) {
+        this.logger = logger;
+        this.config = config;
+        this.servicePassword = config.resolve("servicePassword");
+        this.suggestions = {
+            login: async (args) => {
+                if (args.length > 2) {
+                    return null;
+                }
+                const input = `${args.at(1).label}`;
+                return (!input) ? [] : [{
+                        id: input,
+                        label: input,
+                        masked: true
+                    }];
+            },
+            ...commands.reduce((acc, command) => {
+                command.name = camelCaseToDash(command.name || command.constructor.name || "");
+                if (!command.name || !command.suggest)
+                    return acc;
+                acc[command.name] = async (a, t) => command.suggest(a, t);
+                return acc;
+            }, {})
+        };
+        this.commands = commands.reduce((acc, command) => {
+            if (!command.name)
+                return acc;
+            acc[command.name] = async (a, t) => command.execute(a, t);
+            return acc;
+        }, {});
+        this.loggedOutCommands = ["login", "clear"];
+        this.loggedInCommands = Object.keys(this.commands);
+        this.loggedInCommands.push("logout");
+        console.log(`Current service password is: ${colorize(this.servicePassword, ConsoleColor.FgGreen)}`);
+    }
+    loadAddons(terminal) {
+        let loggedIn = false;
+        const addon = new CommandsAddon({
+            commands: {
+                login: async (args, terminal) => {
+                    if (args.at(1).label === this.servicePassword) {
+                        loggedIn = true;
+                        terminal.writeln("Logged in as admin");
+                    }
+                    else {
+                        throw new Error("Invalid login");
+                    }
+                },
+                logout: async (args, terminal) => {
+                    loggedIn = false;
+                    terminal.writeln("Logged out");
+                },
+                ...this.commands
+            },
+            suggestCommands: async () => {
+                if (loggedIn) {
+                    return this.loggedInCommands;
+                }
+                return this.loggedOutCommands;
+            },
+            suggestions: this.suggestions
+        });
+        terminal.loadAddon(addon);
+    }
+};
+TerminalManager = __decorate([
+    singleton(),
+    __param(2, injectAll(TERMINAL_COMMAND))
+], TerminalManager);
+
+let TokenGenerator = class TokenGenerator {
+    constructor() {
+        this.chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    }
+    async generate(checkCb) {
+        let token = null;
+        let tries = 0;
+        let notGood = true;
+        while (notGood && tries < 5) {
+            token = this.generateToken();
+            notGood = await checkCb(token);
+            tries++;
+        }
+        if (notGood) {
+            throw new Error(`Couldn't generate an unique token..`);
+        }
+        return token;
+    }
+    generateToken() {
+        let s = "";
+        for (let i = 0; i < 15; i++) {
+            const ix = rand(0, this.chars.length - 1);
+            s += this.chars[ix];
+        }
+        return s;
+    }
+};
+TokenGenerator = __decorate([
+    singleton()
+], 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",
+    password: "",
+    roles: ["admin"]
+};
+let UserManager = class UserManager {
+    async getByCredentials(credentials) {
+        return (sampleUser.email == credentials.email) ? sampleUser : await Promise.reject("message.login.error");
+    }
+    async getById(id) {
+        return (sampleUser.id == id) ? sampleUser : null;
+    }
+    async serialize(user) {
+        const res = Object.assign({}, user);
+        delete res.password;
+        return res;
+    }
+};
+UserManager = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], UserManager);
+
+let AssetsController = class AssetsController {
+    constructor(assets, assetResolver) {
+        this.assets = assets;
+        this.assetResolver = assetResolver;
+    }
+    async upload(file) {
+        try {
+            const contentType = file.mimetype === "application/octet-stream" ? null : file.mimetype;
+            const asset = await this.assets.writeBuffer(file.buffer, { filename: file.filename }, contentType);
+            return asset.toJSON();
+        }
+        catch (e) {
+            const msg = e?.message || e || "Unknown error";
+            throw new HttpError(400, `Asset can't be uploaded.\n${msg}`);
+        }
+    }
+    async uploadUrl(body) {
+        try {
+            const asset = await this.assets.writeUrl(body.url, body);
+            return asset.toJSON();
+        }
+        catch (e) {
+            const msg = e?.message || e || "Unknown error";
+            throw new HttpError(400, `Asset can't be uploaded.\n${msg}`);
+        }
+    }
+    async getFile(id, lazy, res) {
+        const asset = await this.getAsset("Asset", id, lazy, res);
+        return asset.download();
+    }
+    async getImageRotation(id, params, res, rotation = 0) {
+        const asset = await this.getAsset("Image", id, params.lazy, res);
+        if (rotation !== 0) {
+            params.rotation = params.rotation || rotation;
+        }
+        return asset.downloadImage(params);
+    }
+    async getImage(id, params, res) {
+        return this.getImageRotation(id, params, res);
+    }
+    async getFileByName(name, res) {
+        const asset = await this.getAssetByName("Asset", name, res);
+        return asset.download();
+    }
+    async getImageByName(name, params, res) {
+        const asset = await this.getAssetByName("Image", name, res);
+        return asset.downloadImage(params);
+    }
+    setAssetHeaders(type, asset, res) {
+        if (asset.metadata?.classified) {
+            throw new HttpError(403, `${type} is classified, and can be only downloaded from a custom url.`);
+        }
+        const ext = asset.metadata?.extension;
+        if (ext) {
+            res.header("content-disposition", `inline; filename=${asset.filename}.${ext}`);
+        }
+        if (asset.contentType) {
+            res.header("content-type", asset.contentType);
+        }
+    }
+    async getAsset(type, id, lazy, res) {
+        const asset = await this.assetResolver.resolve(id, lazy);
+        if (!asset) {
+            throw new HttpError(404, `${type} with id: '${id}' not found.`);
+        }
+        this.setAssetHeaders(type, asset, res);
+        return asset;
+    }
+    async getAssetByName(type, filename, res) {
+        const asset = await this.assets.find({ filename });
+        if (!asset) {
+            throw new HttpError(404, `${type} with filename: '${filename}' not found.`);
+        }
+        this.setAssetHeaders(type, asset, res);
+        return asset;
+    }
+};
+__decorate([
+    Authorized(),
+    Post(""),
+    __param(0, UploadedFile("file"))
+], AssetsController.prototype, "upload", null);
+__decorate([
+    Authorized(),
+    Post("url"),
+    __param(0, Body())
+], AssetsController.prototype, "uploadUrl", null);
+__decorate([
+    Get("/:id"),
+    __param(0, Param("id")),
+    __param(1, QueryParam("lazy")),
+    __param(2, Res())
+], AssetsController.prototype, "getFile", null);
+__decorate([
+    Get("/image/:id/:rotation"),
+    __param(0, Param("id")),
+    __param(1, QueryParams()),
+    __param(2, Res()),
+    __param(3, Param("rotation"))
+], AssetsController.prototype, "getImageRotation", null);
+__decorate([
+    Get("/image/:id"),
+    __param(0, Param("id")),
+    __param(1, QueryParams()),
+    __param(2, Res())
+], AssetsController.prototype, "getImage", null);
+__decorate([
+    Get("/by-name/:name"),
+    __param(0, Param("name")),
+    __param(1, Res())
+], AssetsController.prototype, "getFileByName", null);
+__decorate([
+    Get("/by-name/image/:name"),
+    __param(0, Param("name")),
+    __param(1, QueryParams()),
+    __param(2, Res())
+], AssetsController.prototype, "getImageByName", null);
+AssetsController = __decorate([
+    injectable(),
+    Controller("/assets")
+], AssetsController);
+
+let AuthController = class AuthController {
+    constructor(config, userManager) {
+        this.config = config;
+        this.userManager = userManager;
+    }
+    async login(credentials, res) {
+        let user = null;
+        try {
+            user = await this.userManager.getByCredentials(credentials);
+        }
+        catch (reason) {
+            throw new HttpError(401, reason);
+        }
+        const valid = !user ? false : await compare(credentials.password, user.password);
+        if (valid !== true)
+            throw new UnauthorizedError(`message.login.error`);
+        return {
+            token: webToken.sign({ id: user._id || user.id }, this.config.resolve("jwtSecret")),
+            user: await this.userManager.serialize(user)
+        };
+    }
+    getProfile(user) {
+        return this.userManager.serialize(user);
+    }
+};
+__decorate([
+    Post("/login"),
+    __param(0, Body()),
+    __param(1, Res())
+], AuthController.prototype, "login", null);
+__decorate([
+    Authorized(),
+    Get("/user"),
+    __param(0, CurrentUser())
+], AuthController.prototype, "getProfile", null);
+AuthController = __decorate([
+    injectable(),
+    Controller()
+], AuthController);
+
+let GalleryController = class GalleryController {
+    constructor(galleryCache) {
+        this.galleryCache = galleryCache;
+    }
+    getFile(id) {
+        return this.galleryCache.serve(id);
+    }
+};
+__decorate([
+    Get("/:id"),
+    __param(0, Param("id"))
+], GalleryController.prototype, "getFile", null);
+GalleryController = __decorate([
+    injectable(),
+    Controller("/gallery")
+], GalleryController);
+
+let ProgressesController = class ProgressesController {
+    constructor(progresses, config) {
+        this.progresses = progresses;
+        this.config = config;
+        const mainEndpoint = this.config.resolve("mainEndpoint");
+        this.connectionType = !mainEndpoint ? "polling" : "socket";
+    }
+    async getProgress(id) {
+        const progress = await this.progresses.get(id);
+        if (!progress)
+            return null;
+        const json = progress.toJSON();
+        json.connectionType = this.connectionType;
+        return json;
+    }
+};
+__decorate([
+    Get("/:id"),
+    __param(0, Param("id"))
+], ProgressesController.prototype, "getProgress", null);
+ProgressesController = __decorate([
+    injectable(),
+    Controller("/progresses")
+], ProgressesController);
+
+// Add a comment hint for webstorm to style the string as css
+var styles = `
+
+body {
+    margin: 0;
+    padding: 0;
+    background: #1e1e1e;
+}
+body * {
+    box-sizing: border-box;
+}
+
+#terminal {
+    margin: 40px;
+    background: black;
+    border: 1px solid #dedede;
+    border-radius: 5px;
+    overflow: hidden;
+}
+
+#terminal .xterm {
+    margin: 10px;
+    height: calc(100vh - 120px);
+    border-radius: 5px;
+}
+
+#terminal .xterm-viewport::-webkit-scrollbar {
+    width: 0.4em;
+    background-color: #222;
+}
+
+#terminal .xterm-viewport::-webkit-scrollbar-thumb {
+    background-color: #555;
+}
+
+#terminal .window-header {
+    display: flex;
+    align-items: center;
+    justify-content: flex-end;
+    background-color: #f1f1f1;
+    padding: 10px;
+}
+
+#terminal .window-header button {
+    background-color: transparent;
+    border: none;
+    font-size: 14px;
+    font-weight: bold;
+    color: #444;
+    cursor: pointer;
+    margin-left: 10px;
+}
+
+.minimize-button {
+    content: "-";
+}
+
+.maximize-button {
+    content: "+";
+}
+
+.close-button {
+    content: "x";
+}
+
+`;
+
+let TerminalController$1 = class TerminalController {
+    constructor(config) {
+        this.config = config;
+        this.serviceName = config.resolve("serviceName");
+        this.serviceUrl = config.resolve("serviceUrl");
+    }
+    terminal() {
+        return this.generateClient("terminal");
+    }
+    console() {
+        return this.generateClient("console");
+    }
+    generateClient(alias) {
+        return `
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <meta charset="utf-8">
+            <title>${this.serviceName} ${alias}</title>
+            <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/xterm@5.1.0/css/xterm.min.css"/>
+            <script type="text/javascript" src="${this.serviceUrl}/socket/socket.io.js"></script>
+            <style>
+                ${styles}
+            </style>
+        </head>
+        <body>
+            <div id="terminal"></div>
+            <script type="module">
+                // Import terminal modules
+                import xterm from 'https://cdn.jsdelivr.net/npm/xterm@5.1.0/+esm';
+                import xtermFit from 'https://cdn.jsdelivr.net/npm/xterm-addon-fit@0.7.0/+esm';
+                // Initialize variables
+                var terminal = new xterm.Terminal();
+                var fitAddon = new xtermFit.FitAddon();
+                var socket = io("${this.serviceUrl}", {path: "/socket"});
+                var clear = function () {
+                    terminal.clear();
+                    terminal.reset();
+                    // Prev line
+                    terminal.write("\u001B[F");
+                }
+                // Initialize terminal
+                terminal.loadAddon(fitAddon);
+                terminal.open(document.getElementById('terminal'));
+                terminal.onData(function (data) {
+                    socket.emit("terminal-data", data.charCodeAt(0) === 127 ? "\b" : data);
+                });
+                // Socket listeners
+                socket.on("terminal-data", function (data) {
+                    if (data === "\x1bc") {
+                        clear();
+                        return;
+                    }
+                    terminal.write(data);
+                });
+                socket.on("terminal-upload", function (data) {
+                    var input = document.createElement("input");
+                    input.type = "file";
+                    input.accept = data.accept;
+                    input.onchange = function () {
+                        var file = input.files[0];
+                        var reader = new FileReader();
+                        reader.onload = function () {
+                            socket.emit("terminal-upload", {
+                                id: data.id,
+                                label: file.name,
+                                content: reader.result,
+                                accept: data.accept
+                            });
+                        };
+                        reader.onerror = function () {
+                            socket.emit("terminal-upload", {
+                                id: data.id,
+                                label: file.name,
+                                error: reader.error,
+                                accept: data.accept
+                            });
+                        };
+                        reader.readAsDataURL(file);
+                    };
+                    input.click();
+                });
+                socket.on("terminal-download", function (data) {
+                    var link = document.createElement("a");
+                    link.href = data.content;
+                    link.download = data.filename;
+                    link.click();
+                });
+                socket.on("connect", function () {
+                    clear();
+                    terminal.writeln("Welcome to ${this.serviceName} service's ${alias}!");
+                    socket.emit("terminal-init");
+                });
+                socket.on("disconnect", function () {
+                    clear();
+                    terminal.writeln("Disconnected from ${this.serviceName} service's ${alias}.");
+                });
+            </script>
+        </body>
+        </html>
+        `;
+    }
+};
+__decorate([
+    Get("/terminal"),
+    Header("Content-Type", "text/html")
+], TerminalController$1.prototype, "terminal", null);
+__decorate([
+    Get("/console"),
+    Header("Content-Type", "text/html")
+], TerminalController$1.prototype, "console", null);
+__decorate([
+    Get(),
+    Header("Content-Type", "text/html")
+], TerminalController$1.prototype, "generateClient", null);
+TerminalController$1 = __decorate([
+    injectable(),
+    Controller()
+], TerminalController$1);
+
+let ErrorHandlerMiddleware = class ErrorHandlerMiddleware {
+    constructor(configuration, translator) {
+        this.configuration = configuration;
+        this.translator = translator;
+    }
+    get isDev() {
+        return this.configuration.resolve("nodeEnv") === "development";
+    }
+    async error(error, req, res, next) {
+        const result = await this.getResult(error, req, res);
+        if (this.isDev) {
+            if (axios.isAxiosError(error)) {
+                console.log(`Axios error:`, result);
+                console.log(error.config.data);
+            }
+            else {
+                console.log(error.constructor?.name || "Error", result, res.statusCode);
+            }
+        }
+        res.json(result);
+    }
+    async getResult(error, req, res) {
+        const result = {};
+        if (axios.isAxiosError(error)) {
+            res.status(error.response.status);
+            result.message = error.message;
+            result.error = error.response.data;
+            result.headers = error.response.headers;
+            result.url = `${error.config.baseURL}${error.config.url}`;
+            return result;
+        }
+        if (error instanceof BadRequestError) {
+            res.status(400);
+            if (error.constructor.name === "ParamRequiredError") {
+                result.message = await this.translator.getTranslation(req.language, "message.parameter-required.error");
+                result.param = error.message;
+            }
+            else {
+                result.message = error.message || await this.translator.getTranslation(req.language, "message.form-validation.error");
+                result.errors = error["errors"];
+                if (error.stack && this.isDev) {
+                    result.stack = error.stack;
+                }
+            }
+            return result;
+        }
+        res.status(error.httpCode || 500);
+        if (error instanceof Error) {
+            if (error.name) {
+                result.name = error.name;
+            }
+            if (error.message) {
+                result.message = error.message;
+            }
+            if (error.stack && this.isDev) {
+                result.stack = error.stack;
+            }
+        }
+        else if (typeof error === "string") {
+            result.message = error;
+        }
+        return result;
+    }
+};
+ErrorHandlerMiddleware = __decorate([
+    injectable(),
+    Middleware({ type: "after" })
+], ErrorHandlerMiddleware);
+
+let ContainerMiddleware = class ContainerMiddleware {
+    constructor(container) {
+        this.container = container;
+    }
+    use(request, response, next) {
+        request.container = this.container;
+        next(null);
+    }
+};
+ContainerMiddleware = __decorate([
+    injectable(),
+    Middleware({ type: "before" }),
+    __param(0, inject(DI_CONTAINER))
+], ContainerMiddleware);
+
+let LanguageMiddleware = class LanguageMiddleware {
+    constructor(config) {
+        this.config = config;
+    }
+    use(request, response, next) {
+        request.language = request.query.language || this.config.resolve("defaultLanguage");
+        next(null);
+    }
+};
+LanguageMiddleware = __decorate([
+    injectable(),
+    Middleware({ type: "before" })
+], LanguageMiddleware);
+
+let RequestEndedMiddleware = class RequestEndedMiddleware {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    use(request, response, next) {
+        request.ended = moment();
+        const diff = request.ended.diff(request.started);
+        const duration = moment.duration(diff);
+        this.logger.log("request-time", `Request '${request.id}' ended at: ${request.ended.format("YYYY-MM-DD HH:mm:ss")} [${request.method}] ${request.url}`);
+        this.logger.log("request-time", `Request '${request.id}' lasted: ${duration.asMilliseconds()}ms`);
+        next(null);
+    }
+};
+RequestEndedMiddleware = __decorate([
+    injectable(),
+    Middleware({ type: "after" })
+], RequestEndedMiddleware);
+
+let RequestStartedMiddleware = class RequestStartedMiddleware {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    use(request, response, next) {
+        request.id = new ObjectId$1().toHexString();
+        request.started = moment();
+        this.logger.log("request-time", `Request '${request.id}' started at: ${request.started.format("YYYY-MM-DD HH:mm:ss")} [${request.method}] ${request.url}`);
+        next(null);
+    }
+};
+RequestStartedMiddleware = __decorate([
+    injectable(),
+    Middleware({ type: "before" })
+], RequestStartedMiddleware);
+
+let ProgressController = class ProgressController {
+    constructor(progresses, socketServer) {
+        this.progresses = progresses;
+        this.socketServer = socketServer;
+    }
+    async advanceProgress(client, progressId) {
+        const progress = await this.progresses.get(progressId);
+        if (!progress)
+            return;
+        const json = progress.toJSON();
+        broadcast(this.socketServer, c => {
+            if (c.interestedProgresses instanceof Set && c.interestedProgresses.has(progressId)) {
+                client.emit("background-progress-changed", json);
+            }
+        });
+        console.log(`progress changed: ${client.id}, data: ${JSON.stringify(json)}`);
+    }
+    async setProgressInterest(client, progressId) {
+        const progress = await this.progresses.get(progressId);
+        if (!progress)
+            return;
+        const json = progress.toJSON();
+        client.interestedProgresses = client.interestedProgresses || new Set();
+        if (client.interestedProgresses.has(progressId))
+            return;
+        client.interestedProgresses.add(progressId);
+        client.emit("background-progress-changed", json);
+        console.log(`progress interest added: ${client.id}, data: ${JSON.stringify(json)}`);
+    }
+};
+__decorate([
+    OnMessage("background-progress"),
+    __param(0, ConnectedSocket()),
+    __param(1, MessageBody())
+], ProgressController.prototype, "advanceProgress", null);
+__decorate([
+    OnMessage("background-progress-interest"),
+    __param(0, ConnectedSocket()),
+    __param(1, MessageBody())
+], ProgressController.prototype, "setProgressInterest", null);
+ProgressController = __decorate([
+    singleton(),
+    SocketController(),
+    __param(1, inject(SOCKET_SERVER))
+], ProgressController);
+
+class Terminal {
+    constructor(client) {
+        this.client = client;
+        this.addons = [];
+        this.files$ = new BehaviorSubject([]);
+        this.input$ = new Subject();
+    }
+    onData(cb) {
+        const sub = this.input$.pipe(map(v => {
+            if (v === "\b") {
+                return "\x7f";
+            }
+            return v;
+        })).subscribe(cb);
+        return {
+            dispose: () => sub.unsubscribe()
+        };
+    }
+    write(data) {
+        this.client.emit("terminal-data", data);
+    }
+    writeln(data) {
+        this.write(data + "\n");
+    }
+    loadAddon(addon) {
+        addon.activate(this);
+        this.addons.push(addon);
+    }
+    dispose() {
+        this.input$.complete();
+        this.client = null;
+        this.addons.forEach(a => a.dispose());
+    }
+    async suggestFiles(accept) {
+        const rand = Math.round(Math.random() * 1000);
+        const id = `${Date.now()}-${rand}`;
+        const files = this.files$.value;
+        return files.filter(f => f.accept === accept).concat([
+            {
+                id,
+                label: "...",
+                onAccept: async () => {
+                    this.client.emit("terminal-upload", {
+                        id,
+                        accept
+                    });
+                    const file = await this.files$
+                        .pipe(first(v => v.some(f => f.id === id)))
+                        .pipe(timeout(120000))
+                        .pipe(map(v => v.find(f => f.id === id)))
+                        .toPromise();
+                    if (file.error) {
+                        this.files$.next(this.files$.value.filter(f => f.id !== id));
+                        throw new Error(file.error);
+                    }
+                    return file;
+                },
+                showAlways: true,
+                accept: accept,
+            }
+        ]);
+    }
+    async downloadFile(filename, buffer) {
+        const type = await fileTypeFromBuffer(buffer);
+        const data = buffer.toString("base64");
+        const content = `data:${type.mime};base64,${data}`;
+        this.client.emit("terminal-download", {
+            filename,
+            content
+        });
+    }
+    addFile(upload) {
+        if (upload.content) {
+            upload.buffer = Buffer.from(upload.content, "base64");
+        }
+        this.files$.next(this.files$.value.concat(upload));
+    }
+    input(data) {
+        this.input$.next(data);
+    }
+}
+
+let TerminalController = class TerminalController {
+    constructor(manager) {
+        this.manager = manager;
+        this.terminals = {};
+    }
+    async terminalInit(client) {
+        const terminal = new Terminal(client);
+        this.manager.loadAddons(terminal);
+        this.terminals[client.id] = terminal;
+        client.on("disconnect", () => terminal.dispose());
+    }
+    async terminalData(client, data) {
+        const terminal = this.terminals[client.id];
+        if (!terminal)
+            return;
+        terminal.input(data);
+    }
+    async terminalUpload(client, upload) {
+        const terminal = this.terminals[client.id];
+        if (!terminal || !upload)
+            return;
+        terminal.addFile(upload);
+    }
+};
+__decorate([
+    OnMessage("terminal-init"),
+    __param(0, ConnectedSocket())
+], TerminalController.prototype, "terminalInit", null);
+__decorate([
+    OnMessage("terminal-data"),
+    __param(0, ConnectedSocket()),
+    __param(1, MessageBody())
+], TerminalController.prototype, "terminalData", null);
+__decorate([
+    OnMessage("terminal-upload"),
+    __param(0, ConnectedSocket()),
+    __param(1, MessageBody())
+], TerminalController.prototype, "terminalUpload", null);
+TerminalController = __decorate([
+    singleton(),
+    SocketController()
+], TerminalController);
+
+let CompressionMiddleware = class CompressionMiddleware {
+    use(socket, next) {
+        next();
+    }
+};
+CompressionMiddleware = __decorate([
+    injectable(),
+    Middleware$1()
+], CompressionMiddleware);
+
+class Tree {
+    constructor(container, exists, path) {
+        this.container = container;
+        this.exists = exists;
+        this.path = path;
+        this.map = new Map();
+    }
+    get parentTree() {
+        return this.container.parent.tree;
+    }
+    resolveService() {
+        return !this.exists ? null : this.container.resolve(this.path);
+    }
+    resolveLeaves() {
+        let map;
+        try {
+            const parentTree = this.parentTree.resolvePath(this.path);
+            map = parentTree.resolveLeaves();
+        }
+        catch (e) {
+            map = new Map();
+        }
+        const visitor = (treeMap, path) => {
+            treeMap.forEach((tree, key) => {
+                const subKey = !path ? key : `${path}.${key}`;
+                if (tree.map.size == 0) {
+                    map.set(subKey, tree);
+                    return;
+                }
+                visitor(tree.map, subKey);
+            });
+        };
+        visitor(this.map, "");
+        return map;
+    }
+    resolveServices() {
+        const map = new Map();
+        this.resolveLeaves().forEach((leaf, key) => {
+            map.set(key, leaf.resolveService());
+        });
+        return map;
+    }
+    resolveAncestor(path) {
+        if (!isString(path) || path.length == 0) {
+            return this;
+        }
+        let parentTree;
+        try {
+            parentTree = this.parentTree.resolvePath(this.path);
+            parentTree = parentTree.resolveAncestor(path);
+        }
+        catch (e) {
+            parentTree = new Tree(this.container, false, "");
+        }
+        const pathParts = path.split(".");
+        let tree = this;
+        let previousTree = this;
+        for (let part of pathParts) {
+            tree = tree.map.get(part);
+            if (!tree) {
+                if (previousTree == this) {
+                    if (parentTree.path.length > 0) {
+                        return parentTree;
+                    }
+                    throw new Error(`Ancestor '${path}' not found in current tree: '${this.path}'`);
+                }
+                return previousTree;
+            }
+            previousTree = tree;
+        }
+        return parentTree.path.length > previousTree.path.length
+            ? parentTree : previousTree;
+    }
+    resolvePath(path, throwError = true) {
+        const absolutePath = !this.path ? path : `${this.path}.${path}`;
+        let tree = new Tree(this.container, false, absolutePath);
+        try {
+            tree = this.resolveAncestor(path);
+        }
+        catch (e) {
+            if (throwError) {
+                throw new Error(`Path '${path}' not found in current tree: '${this.path}'`);
+            }
+            return tree;
+        }
+        if (tree.path !== absolutePath) {
+            if (throwError) {
+                throw new Error(`Path '${path}' not found in current tree: '${this.path}'`);
+            }
+            return tree;
+        }
+        return tree;
+    }
+    addPath(path) {
+        if (!isString(path) || path.length == 0) {
+            return this;
+        }
+        const pathParts = path.split(".");
+        const maxIx = pathParts.length - 1;
+        let tree = this;
+        path = this.path;
+        for (let ix = 0; ix <= maxIx; ix++) {
+            const part = pathParts[ix];
+            if (!tree.map.has(part)) {
+                tree.map.set(part, new Tree(this.container, false, !path ? part : `${path}.${part}`));
+            }
+            tree = tree.map.get(part);
+            tree.exists = tree.exists || ix == maxIx;
+            path = tree.path;
+        }
+        return this;
+    }
+}
+
+class DiContainer {
+    constructor(container, parent = null) {
+        this.container = container;
+        this.parent = parent;
+        container["wrapperContainer"] = this;
+        this.tokens = [];
+        this.tokenSet = new Set();
+        this.root = new Tree(this, false, "");
+    }
+    get registeredTokens() {
+        return (this.parent?.registeredTokens || []).concat(this.tokens);
+    }
+    get tree() {
+        return this.root;
+    }
+    beforeResolution(token, callback, options) {
+        this.container.beforeResolution(token, callback, options);
+    }
+    afterResolution(token, callback, options) {
+        this.container.afterResolution(token, callback, options);
+    }
+    clearInstances() {
+        this.container.clearInstances();
+    }
+    createChildContainer() {
+        return new DiContainer(this.container.createChildContainer(), this);
+    }
+    isRegistered(token, recursive) {
+        return this.container.isRegistered(token, recursive);
+    }
+    register(token, provider, options) {
+        if (isFactoryProvider(provider)) {
+            this.container.register(token, {
+                useFactory: dc => {
+                    return provider.useFactory(dc["wrapperContainer"]);
+                }
+            });
+            return this.addToken(token);
+        }
+        this.container.register(token, provider);
+        return this.addToken(token);
+    }
+    registerInstance(token, instance) {
+        this.container.registerInstance(token, instance);
+        return this.addToken(token);
+    }
+    registerSingleton(from, to) {
+        this.container.registerSingleton(from, to);
+        return this.addToken(from);
+    }
+    registerType(from, to) {
+        this.container.registerType(from, to);
+        return this.addToken(from);
+    }
+    reset() {
+        this.tokens = [];
+        this.tokenSet = new Set();
+        this.container.reset();
+    }
+    resolve(token) {
+        return this.container.resolve(token);
+    }
+    resolveAll(token) {
+        return this.container.resolveAll(token);
+    }
+    get(token) {
+        return this.container.resolve(token);
+    }
+    addToken(token) {
+        if (this.tokenSet.has(token))
+            return this;
+        this.tokenSet.add(token);
+        this.tokens.push(token);
+        if (isString(token)) {
+            this.root.addPath(token);
+        }
+        return this;
+    }
+}
+
+let EmptyJob = class EmptyJob {
+    async process() {
+        return null;
+    }
+};
+EmptyJob = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], EmptyJob);
+
+async function setupStatic(rootFolder, container) {
+    const browserFolder = resolve(rootFolder || getDirName(), `public_html`);
+    const app = container.get(EXPRESS);
+    const ep = container.get(EndpointProvider);
+    console.log(browserFolder, existsSync(browserFolder));
+    if (existsSync(browserFolder)) {
+        console.log(`public_html exists. setting up static files serving...`);
+        app.use(static$1(browserFolder, {
+            maxAge: "1y"
+        }));
+    }
+    else {
+        console.log(`public_html does not exist on path: "${browserFolder}"`);
+    }
+    await ep.configure(app);
+}
+
+let ClearCommand = class ClearCommand {
+    constructor() {
+        this.name = "clear";
+    }
+    async execute(args, terminal) {
+        terminal.write(AnsiCodes.clear);
+    }
+};
+ClearCommand = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], ClearCommand);
+
+let FixturesCommand = class FixturesCommand {
+    constructor(fixtures) {
+        this.fixtures = fixtures;
+        this.name = "fixtures";
+    }
+    async execute(args, terminal) {
+        const output = {
+            write: text => terminal.writeln(text),
+            writeln: text => terminal.writeln(text)
+        };
+        await this.fixtures.load(output);
+        terminal.writeln(colorize(`Fixtures loaded`, ConsoleColor.FgGreen));
+    }
+};
+FixturesCommand = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], FixturesCommand);
+
+const commands = [
+    ClearCommand,
+    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
+     */
+    cast() {
+        return this;
+    }
+    /**
+     * Gets a pre-compiled model from typegoose cache by its class type
+     * @param type
+     */
+    model(type) {
+        return getModelForClass(type);
+    }
+}
+const PrimitiveArray = Types.Array;
+const DocumentArray = Types.DocumentArray;
+
+function IsDocumented(summary = null, paramDescriptions = {}) {
+    return OpenAPI(op => {
+        op.summary = summary || op.summary;
+        op.tags = ["Documented"].concat(op.tags || []);
+        op.parameters?.forEach(p => {
+            if (p.$ref)
+                return;
+            const schema = p;
+            schema.description = paramDescriptions[schema.name]
+                || schema.description
+                || `param.${op.operationId}.${schema.name}`.toLowerCase();
+        });
+        return op;
+    });
+}
+function JsonResponse(description = "Success", statusCode = null) {
+    return OpenAPI((op, route) => {
+        const status = statusCode ?? getStatusCode(route) + "";
+        op.responses = op.responses || {};
+        op.responses[status] = {
+            description,
+            content: {
+                "application/json": {}
+            }
+        };
+        return op;
+    });
+}
+function ResponseType(type, options = {}) {
+    return OpenAPI((op, route) => {
+        const contentType = "application/json";
+        const statusCode = options?.statusCode ?? getStatusCode(route) + "";
+        const reference = {
+            $ref: `#/components/schemas/${type.name}`,
+        };
+        const schema = options.isArray
+            ? { items: reference, type: "array" }
+            : reference;
+        op.responses = op.responses || {};
+        op.responses[statusCode] = {
+            description: options.description || "Success",
+            content: {
+                [contentType]: {
+                    schema
+                }
+            }
+        };
+        return op;
+    });
+}
+
+class LazyAssetGenerator {
+    constructor(assetResolver, progresses, lazyId) {
+        this.assetResolver = assetResolver;
+        this.progresses = progresses;
+        this.lazyId = lazyId;
+    }
+    get assets() {
+        return this.assetResolver.assets;
+    }
+    get lazyAssets() {
+        return this.assetResolver.lazyAssets;
+    }
+    async process(messaging) {
+        const lazyAsset = await this.lazyAssets.read(this.lazyId);
+        let progress = await this.progresses.get(lazyAsset.progressId);
+        if (!progress || progress.canceled)
+            return null;
+        progress.setMessageBridge(messaging);
+        try {
+            const asset = await this.generate(progress, messaging);
+            progress = await progress.load();
+            if (!progress || progress.canceled)
+                return null;
+            await lazyAsset.writeAsset(asset);
+        }
+        catch (e) {
+            await progress.setError(e.message || e);
+            throw e;
+        }
+        if (progress.remaining > 0) {
+            await progress.advance(progress.remaining);
+        }
+    }
+}
+
+const pluginsKey = "typegoose:plugins";
+/**
+ * A mongoose/typegoose plugin to inject services from the main di container to a schema as virtuals
+ * @param schema
+ * @param services
+ */
+function injectServices(schema, services) {
+    const serviceMap = {};
+    if (!isObject(services)) {
+        throw new Error(`services object should be defined to inject services to schema!`);
+    }
+    Object.keys(services).forEach(prop => {
+        schema
+            .virtual(prop)
+            .get(() => {
+            const diContainer = diContainers.appContainer;
+            serviceMap[prop] = serviceMap[prop] || (!diContainer ? {} : diContainer.resolve(services[prop]));
+            return serviceMap[prop];
+        });
+    });
+}
+/**
+ * Decorates a property to inject a service with the help of the injectServices mongoose/typegoose plugin
+ * @param token optional InjectionToken to use
+ * @return PropertyDecorator
+ */
+function service(token) {
+    return (target, propertyKey) => {
+        const propertyType = Reflect.getOwnMetadata("design:type", target, propertyKey);
+        const plugins = Array.from(Reflect.getMetadata(pluginsKey, target.constructor) ?? []);
+        let plugin = plugins.find(t => t.mongoosePlugin === injectServices);
+        if (!plugin) {
+            plugin = { mongoosePlugin: injectServices, options: {} };
+            plugins.push(plugin);
+        }
+        plugin.options = Object.assign(plugin.options || {}, { [propertyKey]: token ?? propertyType });
+        Reflect.defineMetadata(pluginsKey, plugins, target.constructor);
+    };
+}
+/**
+ * Paginate using a typegoose model using a simple where query and pagination params
+ * @param model Typegoose model
+ * @param where Simple query to filter the results
+ * @param params Pagination params
+ */
+function paginate(model, where, params) {
+    return model.countDocuments(where).then(count => {
+        let query = model.find(where);
+        if (isString(params.sort)) {
+            query = query.sort(params.sort);
+        }
+        if (isArray(params.populate)) {
+            params.populate.forEach(field => {
+                query = query.populate(field);
+            });
+        }
+        return (params.limit > 0 ? query.skip(params.page * params.limit).limit(params.limit) : query).then(items => {
+            const meta = { total: count };
+            return { count, items, meta };
+        });
+    });
+}
+function lookupStages(from, localField, as = null, foreignField = "_id", shouldUnwind = true) {
+    as = as || localField.replace("Id", "");
+    const stages = [
+        {
+            $lookup: {
+                from,
+                localField,
+                foreignField,
+                as
+            }
+        },
+        {
+            $unwind: {
+                path: `$${as}`,
+                preserveNullAndEmptyArrays: true
+            }
+        }
+    ];
+    if (!shouldUnwind) {
+        stages.splice(1, 1);
+    }
+    return stages;
+}
+function letsLookupStage(from, pipeline, as = null, letFields = null) {
+    as = as || from;
+    letFields = letFields || { id: "$_id" };
+    return {
+        $lookup: {
+            from,
+            let: letFields,
+            pipeline,
+            as
+        }
+    };
+}
+function matchStage(match) {
+    return { $match: match };
+}
+function matchField(field, filter, when) {
+    return { field, filter, when };
+}
+function matchFieldStages(...fields) {
+    const match = {};
+    fields.forEach(field => {
+        if (field.when) {
+            match[field.field] = field.filter;
+        }
+    });
+    return Object.keys(match).length > 0 ? [matchStage(match)] : [];
+}
+function projectStage(fields) {
+    return { $project: fields };
+}
+function unwindStage(fieldOrOpts) {
+    return { $unwind: fieldOrOpts };
+}
+function hydratePopulated(modelType, json) {
+    let object = modelType.hydrate(json);
+    for (const [path, obj] of Object.entries(modelType.schema.obj)) {
+        let { ref, type } = obj;
+        if (Array.isArray(type) && type.length > 0) {
+            ref = type[0].ref;
+        }
+        if (!ref)
+            continue;
+        const value = getValue$1(path, json);
+        const hydrateVal = val => {
+            if (val == null || val instanceof Types.ObjectId)
+                return val;
+            return hydratePopulated(model(ref), val);
+        };
+        if (Array.isArray(value)) {
+            setValue(path, value.map(hydrateVal), object);
+            continue;
+        }
+        setValue(path, hydrateVal(value), object);
+    }
+    return object;
+}
+async function paginateAggregations(model, aggregations, params, metaProjection = {}) {
+    const sortField = !isString(params.sort) || !params.sort ? null : (params.sort.startsWith("-") ? params.sort.substr(1) : params.sort);
+    const sortAggregation = !sortField ? [] : [{
+            $sort: { [sortField]: sortField == params.sort ? 1 : -1 }
+        }];
+    const result = await model.aggregate([
+        ...aggregations,
+        ...sortAggregation,
+        {
+            $group: {
+                _id: "results",
+                result: { $push: "$$CURRENT" }
+            }
+        },
+        {
+            $project: {
+                _id: 0,
+                items: params.limit > 0 ? { $slice: ["$result", params.page * params.limit, params.limit] } : "$result",
+                count: { $size: "$result" },
+                meta: {
+                    total: { $size: "$result" },
+                    ...metaProjection
+                }
+            }
+        }
+    ]);
+    const pagination = result[0];
+    if (!pagination) {
+        return { items: [], count: 0, meta: { total: 0 } };
+    }
+    pagination.items = pagination.items.map(i => hydratePopulated(model, i));
+    return pagination;
+}
+function ResolveEntity(model, extraCheck) {
+    const modelName = model.modelName;
+    const paramName = modelName.toLowerCase();
+    return createParamDecorator({
+        required: false,
+        value: async (action) => {
+            const req = action.request;
+            const token = req.header(`x-${paramName}-token`);
+            const id = req.params[`${paramName}Id`];
+            if (!id && !token) {
+                throw new BadRequestError(`${modelName} id or token should be defined!`);
+            }
+            const query = !token
+                ? model.findById(id)
+                : model.findOne({ token });
+            let doc = null;
+            if (isFunction(extraCheck)) {
+                try {
+                    doc = await valueToPromise(extraCheck(query, action));
+                }
+                catch (e) {
+                    throw new BadRequestError(`${modelName} check error: ${e.message || e}`);
+                }
+            }
+            else {
+                doc = await query;
+            }
+            if (!doc) {
+                throw new HttpError(404, !token
+                    ? `${modelName} could not be found with id: ${id}`
+                    : `${modelName} could not be found with token: ${token}`);
+            }
+            action.request[paramName] = doc;
+            return doc;
+        }
+    });
+}
+
+async function resolveUser(req) {
+    if (req.user)
+        return req.user;
+    const container = req.container;
+    const auth = req.header("Authorization") || "";
+    let payload = null;
+    try {
+        const config = container.resolve(Configuration);
+        payload = webToken.verify(auth.split(" ")[1], config.resolve("jwtSecret"));
+    }
+    catch (e) {
+        throw new HttpError(401, `Authentication failed. (${e.message})`);
+    }
+    if (!payload) {
+        throw new HttpError(401, `Authentication failed. (Maybe invalid token)`);
+    }
+    req.user = await container.resolve(UserManager).getById(payload.id);
+    return req.user;
+}
+function createServices() {
+    // List of parameters
+    const dirName = getDirName();
+    const params = [
+        new Parameter("serviceName", "Backend"),
+        new Parameter("servicePassword", Math.random().toString(36).substring(7)),
+        new Parameter("serviceUrl", "http://localhost:3000", (value, helper) => {
+            // Replace port number to empty string
+            const url = prepareUrlEmpty(`${value}`.replace(/:[0-9]+$/, ""), helper);
+            const port = helper("appPort");
+            return (!port || port === 80 || port === 443) ? url : `${url}:${port}`;
+        }),
+        new Parameter("templatesDir", join(dirName, "templates")),
+        new Parameter("galleryDir", join(dirName, "gallery")),
+        new Parameter("cacheDir", join(dirName, "cache")),
+        new Parameter("defaultLanguage", "en"),
+        new Parameter("smtpHost", "smtp.sendgrid.net"),
+        new Parameter("smtpPort", 587),
+        new Parameter("smtpUser", "apikey"),
+        new Parameter("smtpPassword", ""),
+        new Parameter("mailSenderAddress", "info@stemy.hu"),
+        new Parameter("translationsTemplate", "https://translation.service/[lang]"),
+        new Parameter("jwtSecret", "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9"),
+        new Parameter("mongoUri", ""),
+        new Parameter("mongoDb", "node-backend"),
+        new Parameter("mongoUser", null),
+        new Parameter("mongoPassword", null),
+        new Parameter("nodeEnv", "production"),
+        new Parameter("appPort", 80),
+        new Parameter("zmqPort", 3000),
+        new Parameter("zmqBackPort", 3100),
+        new Parameter("zmqRemoteHost", "tcp://127.0.0.1"),
+        new Parameter("isWorker", false),
+        new Parameter("mainEndpoint", ""),
+        new Parameter("idChars", "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"),
+        new Parameter("idSeparator", "-"),
+        new Parameter("idPrefix", "ID-"),
+        new Parameter("idParts", [4, 4]),
+        new Parameter("jsonLimit", "250mb"),
+        new Parameter("jobTimeout", 5 * 60 * 1000),
+        new Parameter("cacheCollection", "cache"),
+        new Parameter("logTags", []),
+        new Parameter("ignoredLogTags", []),
+    ];
+    // Convert parameters to providers
+    const paramProviders = params.map(p => {
+        return {
+            provide: PARAMETER,
+            useValue: p
+        };
+    });
+    // List of services
+    const services = [
+        AssetProcessor,
+        AssetResolver,
+        Assets,
+        BackendProvider,
+        Cache,
+        CacheProcessor,
+        Configuration,
+        EndpointProvider,
+        Fixtures,
+        Gallery,
+        GalleryCache,
+        IdGenerator,
+        JobManager,
+        LazyAssets,
+        Logger,
+        MailSender,
+        MemoryCache,
+        MongoConnector,
+        OpenApi,
+        Progresses,
+        TemplateRenderer,
+        TerminalManager,
+        TokenGenerator,
+        TranslationProvider,
+        Translator,
+        UserManager
+    ];
+    // Create container
+    const diContainer = new DiContainer(container.createChildContainer());
+    paramProviders.forEach(provider => {
+        diContainer.register(provider.provide, provider);
+    });
+    services.forEach(service => {
+        if (!container.isRegistered(service))
+            diContainer.register(service, service);
+    });
+    return diContainer;
+}
+async function setupBackend(config, providers, parent) {
+    providers = Array.isArray(providers) ? providers : [];
+    parent = parent || createServices();
+    // Create fixtures
+    const fixtureTypes = (config.fixtures || []);
+    const fixtureProviders = fixtureTypes.map(fixture => {
+        return {
+            provide: FIXTURE,
+            useClass: fixture
+        };
+    });
+    // Create params
+    const paramProviders = (config.params || []).map(p => {
+        return {
+            provide: PARAMETER,
+            useValue: p
+        };
+    });
+    // Create jobs
+    const jobProviders = [EmptyJob].concat(config.jobs || []).map(jobType => {
+        return {
+            provide: JOB,
+            useValue: jobType
+        };
+    });
+    // Create commands
+    const commandProviders = commands.concat(config.commands || []).map(commandType => {
+        return {
+            provide: TERMINAL_COMMAND,
+            useClass: commandType
+        };
+    });
+    // Create DI container
+    const diContainer = parent.createChildContainer();
+    // Setup rest API
+    const restOptions = {
+        routePrefix: config.routePrefix || "/api",
+        defaultErrorHandler: false,
+        ...(config.restOptions || {})
+    };
+    restOptions.cors = Object.assign({
+        credentials: true,
+        exposedHeaders: ["content-disposition"],
+        origin: (origin, callback) => {
+            callback(null, true);
+        }
+    }, restOptions.cors || {});
+    restOptions.routePrefix = restOptions.routePrefix == "/" ? "" : restOptions.routePrefix;
+    restOptions.middlewares = [ErrorHandlerMiddleware, ContainerMiddleware, LanguageMiddleware, RequestStartedMiddleware, RequestEndedMiddleware]
+        .concat(restOptions.middlewares || []);
+    restOptions.controllers = [AssetsController, AuthController, GalleryController, ProgressesController, TerminalController$1]
+        .concat(restOptions.controllers || []);
+    // Setup socket API
+    const socketOptions = {
+        container: {
+            get(someClass) {
+                return diContainer.get(someClass);
+            }
+        },
+        ...(config.socketOptions || {})
+    };
+    socketOptions.middlewares = [CompressionMiddleware].concat(socketOptions.middlewares || []);
+    socketOptions.controllers = [ProgressController, TerminalController].concat(socketOptions.controllers || []);
+    // Create providers
+    const allProviders = [];
+    // Add multi tokens to sub container
+    [PARAMETER].forEach(provide => {
+        const values = parent.resolveAll(provide);
+        values.forEach(useValue => {
+            allProviders.push({ provide, useValue });
+        });
+    });
+    // Add other providers
+    allProviders.push(...fixtureTypes, ...fixtureProviders, ...paramProviders, ...jobProviders, ...commandProviders, ...restOptions.middlewares, ...restOptions.controllers, ...socketOptions.middlewares, ...socketOptions.controllers, ...providers, {
+        provide: EXPRESS,
+        useFactory: (container) => {
+            return container.resolve(BackendProvider).express;
+        }
+    }, {
+        provide: HTTP_SERVER,
+        useFactory: (container) => {
+            return container.resolve(BackendProvider).server;
+        }
+    }, {
+        provide: SOCKET_SERVER,
+        useFactory: (container) => {
+            return container.resolve(BackendProvider).io;
+        }
+    });
+    allProviders.forEach(provider => {
+        if (isType(provider)) {
+            if (container.isRegistered(provider))
+                return;
+            diContainer.register(provider, provider);
+            return;
+        }
+        diContainer.register(provider.provide, provider);
+    });
+    diContainer.register(DI_CONTAINER, {
+        useValue: diContainer
+    });
+    diContainer.register(OPENAPI_VALIDATION, {
+        useValue: config.customValidation || (() => null)
+    });
+    diContainers.appContainer = diContainers.appContainer || diContainer;
+    // Authentication
+    restOptions.authorizationChecker = async (action, roles) => {
+        const user = await resolveUser(action.request);
+        if (!user) {
+            throw new HttpError(401, "Authentication failed. (User can't be found.)");
+        }
+        const userRoles = Array.isArray(user.roles) ? user.roles : [];
+        if (Array.isArray(roles) && roles.length > 0) {
+            let lastError = null;
+            for (let role of roles) {
+                if (isFunction(role)) {
+                    try {
+                        if (await valueToPromise(role(user, action))) {
+                            return true;
+                        }
+                    }
+                    catch (e) {
+                        lastError = e;
+                    }
+                }
+                if (userRoles.indexOf(role) >= 0)
+                    return true;
+            }
+            const error = !lastError || (!lastError.message && !isString(lastError))
+                ? "User doesn't have access to this resource"
+                : lastError.message || lastError;
+            throw new HttpError(401, `Authentication failed. (${error})`);
+        }
+        return true;
+    };
+    restOptions.currentUserChecker = async (action) => {
+        try {
+            return await resolveUser(action.request);
+        }
+        catch (e) {
+            return null;
+        }
+    };
+    // Final setup
+    const configuration = diContainer.resolve(Configuration);
+    const bp = diContainer.resolve(BackendProvider);
+    if (config.restOptions) {
+        bp.express.use(bodyParser.json({
+            limit: configuration.hasParam("jsonLimit")
+                ? configuration.resolve("jsonLimit")
+                : "250mb"
+        }));
+        useContainer(diContainer);
+        useExpressServer(bp.express, restOptions);
+        // Setup rest ai docs
+        let openApi = null;
+        bp.express.get("/api-docs", (req, res) => {
+            openApi = openApi || diContainer.get(OpenApi);
+            res.header("Content-Type", "application/json")
+                .status(200)
+                .end(openApi.apiDocsStr);
+        });
+    }
+    diContainer.register(SOCKET_CONTROLLERS, {
+        useValue: new SocketControllers({
+            io: bp.io,
+            ...socketOptions,
+        })
+    });
+    // Connect to mongo if necessary
+    if (configuration.hasParam("mongoUri") && configuration.resolve("mongoUri")) {
+        console.log("Connecting to MongoDB...");
+        const connector = diContainer.resolve(MongoConnector);
+        await connector.connect();
+        console.log("Successfully connected to MongoDB.");
+    }
+    await setupStatic(config.rootFolder, diContainer);
+    return diContainer;
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AssetImageParams, AssetProcessor, AssetResolver, Assets, AuthController, BackendProvider, BaseDoc, Cache, CacheProcessor, Configuration, ConsoleColor, DI_CONTAINER, DocumentArray, EXPRESS, EndpointProvider, ErrorHandlerMiddleware, FIXTURE, Fixtures, Gallery, GalleryCache, GalleryController, HTTP_SERVER, IdGenerator, IsDocumented, IsFile, IsObjectId, JOB, JobManager, JsonResponse, LanguageMiddleware, LazyAssetGenerator, LazyAssets, Logger, MailSender, MemoryCache, MongoConnector, OPENAPI_VALIDATION, OpenApi, PARAMETER, Parameter, PrimitiveArray, Progresses, ResolveEntity, ResponseType, SOCKET_CONTROLLERS, SOCKET_SERVER, TERMINAL_COMMAND, TemplateRenderer, TerminalManager, TokenGenerator, TranslationProvider, Translator, Type, UserManager, assign, broadcast, bufferToStream, camelCaseToDash, colorize, convertValue, copy, copyStream, createIdString, createServices, createTransformer, deleteFile, deleteFromBucket, fileTypeFromBuffer, filter, firstItem, flatten, getConstructorName, getDirName, getExtension, getFileName, getFunctionParams, getType, getValue, groupBy, hydratePopulated, idToString, injectServices, isArray, isBoolean, isBuffer, isConstructor, isDate, isDefined, isFunction, isInterface, isNullOrUndefined, isObject, isObjectId, isPrimitive, isString, isType, jsonHighlight, lastItem, lcFirst, letsLookupStage, lookupStages, matchField, matchFieldStages, matchStage, md5, mkdirRecursive, multiSubscription, observableFromFunction, padLeft, padRight, paginate, paginateAggregations, prepareUrl, prepareUrlEmpty, prepareUrlSlash, projectStage, promiseTimeout, rand, random, readAndDeleteFile, readFile, regexEscape, regroup, replaceSpecialChars, resolveUser, runCommand, service, setupBackend, streamToBuffer, toImage, ucFirst, uniqueItems, unwindStage, valueToPromise, wrapError, writeFile };
+//# sourceMappingURL=stemy-backend.mjs.map