@stemy/backend 5.2.1 → 6.0.0

package/esm2022/rest-middlewares/error-handler.middleware.mjs

@@ -0,0 +1,79 @@
+import { __decorate, __metadata } from "tslib";
+import { injectable } from "tsyringe";
+import { BadRequestError, Middleware } from "routing-controllers";
+import axios from "axios";
+import { Translator } from "../services/translator";
+import { Configuration } from "../services/configuration";
+let ErrorHandlerMiddleware = class ErrorHandlerMiddleware {
+    configuration;
+    translator;
+    get isDev() {
+        return this.configuration.resolve("nodeEnv") === "development";
+    }
+    constructor(configuration, translator) {
+        this.configuration = configuration;
+        this.translator = translator;
+    }
+    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" }),
+    __metadata("design:paramtypes", [Configuration, Translator])
+], ErrorHandlerMiddleware);
+export { ErrorHandlerMiddleware };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/rest-middlewares/language.middleware.mjs

@@ -0,0 +1,21 @@
+import { __decorate, __metadata } from "tslib";
+import { injectable } from "tsyringe";
+import { Middleware } from "routing-controllers";
+import { Configuration } from "../services/configuration";
+let LanguageMiddleware = class LanguageMiddleware {
+    config;
+    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" }),
+    __metadata("design:paramtypes", [Configuration])
+], LanguageMiddleware);
+export { LanguageMiddleware };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFuZ3VhZ2UubWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9yZXN0LW1pZGRsZXdhcmVzL2xhbmd1YWdlLm1pZGRsZXdhcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxVQUFVLENBQUM7QUFDcEMsT0FBTyxFQUE2QixVQUFVLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUUzRSxPQUFPLEVBQUMsYUFBYSxFQUFDLE1BQU0sMkJBQTJCLENBQUM7QUFJakQsSUFBTSxrQkFBa0IsR0FBeEIsTUFBTSxrQkFBa0I7SUFFTjtJQUFyQixZQUFxQixNQUFxQjtRQUFyQixXQUFNLEdBQU4sTUFBTSxDQUFlO0lBRTFDLENBQUM7SUFFRCxHQUFHLENBQUMsT0FBaUIsRUFBRSxRQUFhLEVBQUUsSUFBd0I7UUFDMUQsT0FBTyxDQUFDLFFBQVEsR0FBRyxPQUFPLENBQUMsS0FBSyxDQUFDLFFBQWtCLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsaUJBQWlCLENBQUMsQ0FBQztRQUM5RixJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDZixDQUFDO0NBRUosQ0FBQTtBQVhZLGtCQUFrQjtJQUY5QixVQUFVLEVBQUU7SUFDWixVQUFVLENBQUMsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLENBQUM7cUNBR0UsYUFBYTtHQUZqQyxrQkFBa0IsQ0FXOUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2luamVjdGFibGV9IGZyb20gXCJ0c3lyaW5nZVwiO1xyXG5pbXBvcnQge0V4cHJlc3NNaWRkbGV3YXJlSW50ZXJmYWNlLCBNaWRkbGV3YXJlfSBmcm9tIFwicm91dGluZy1jb250cm9sbGVyc1wiO1xyXG5pbXBvcnQge0lSZXF1ZXN0fSBmcm9tIFwiLi4vY29tbW9uLXR5cGVzXCI7XHJcbmltcG9ydCB7Q29uZmlndXJhdGlvbn0gZnJvbSBcIi4uL3NlcnZpY2VzL2NvbmZpZ3VyYXRpb25cIjtcclxuXHJcbkBpbmplY3RhYmxlKClcclxuQE1pZGRsZXdhcmUoeyB0eXBlOiBcImJlZm9yZVwiIH0pXHJcbmV4cG9ydCBjbGFzcyBMYW5ndWFnZU1pZGRsZXdhcmUgaW1wbGVtZW50cyBFeHByZXNzTWlkZGxld2FyZUludGVyZmFjZSB7XHJcblxyXG4gICAgY29uc3RydWN0b3IocmVhZG9ubHkgY29uZmlnOiBDb25maWd1cmF0aW9uKSB7XHJcblxyXG4gICAgfVxyXG5cclxuICAgIHVzZShyZXF1ZXN0OiBJUmVxdWVzdCwgcmVzcG9uc2U6IGFueSwgbmV4dDogKGVycj86IGFueSkgPT4gYW55KTogdm9pZCB7XHJcbiAgICAgICAgcmVxdWVzdC5sYW5ndWFnZSA9IHJlcXVlc3QucXVlcnkubGFuZ3VhZ2UgYXMgc3RyaW5nIHx8IHRoaXMuY29uZmlnLnJlc29sdmUoXCJkZWZhdWx0TGFuZ3VhZ2VcIik7XHJcbiAgICAgICAgbmV4dChudWxsKTtcclxuICAgIH1cclxuXHJcbn1cclxuIl19

package/esm2022/rest-middlewares/request-ended.middleware.mjs

@@ -0,0 +1,26 @@
+import { __decorate, __metadata } from "tslib";
+import { injectable } from "tsyringe";
+import { Middleware } from "routing-controllers";
+import moment from "moment";
+import { Logger } from "../services/logger";
+let RequestEndedMiddleware = class RequestEndedMiddleware {
+    logger;
+    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" }),
+    __metadata("design:paramtypes", [Logger])
+], RequestEndedMiddleware);
+export { RequestEndedMiddleware };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWVzdC1lbmRlZC5taWRkbGV3YXJlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Jlc3QtbWlkZGxld2FyZXMvcmVxdWVzdC1lbmRlZC5taWRkbGV3YXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sVUFBVSxDQUFDO0FBQ3BDLE9BQU8sRUFBNkIsVUFBVSxFQUFDLE1BQU0scUJBQXFCLENBQUM7QUFDM0UsT0FBTyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBRTVCLE9BQU8sRUFBQyxNQUFNLEVBQUMsTUFBTSxvQkFBb0IsQ0FBQztBQUluQyxJQUFNLHNCQUFzQixHQUE1QixNQUFNLHNCQUFzQjtJQUVWO0lBQXJCLFlBQXFCLE1BQWM7UUFBZCxXQUFNLEdBQU4sTUFBTSxDQUFRO0lBQ25DLENBQUM7SUFFRCxHQUFHLENBQUMsT0FBaUIsRUFBRSxRQUFhLEVBQUUsSUFBd0I7UUFDMUQsT0FBTyxDQUFDLEtBQUssR0FBRyxNQUFNLEVBQUUsQ0FBQztRQUN6QixNQUFNLElBQUksR0FBRyxPQUFPLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDakQsTUFBTSxRQUFRLEdBQUcsTUFBTSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN2QyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FDWCxjQUFjLEVBQ2QsWUFBWSxPQUFPLENBQUMsRUFBRSxlQUFlLE9BQU8sQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLHFCQUFxQixDQUFDLEtBQUssT0FBTyxDQUFDLE1BQU0sS0FBSyxPQUFPLENBQUMsR0FBRyxFQUFFLENBQ3hILENBQUM7UUFDRixJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FDWCxjQUFjLEVBQ2QsWUFBWSxPQUFPLENBQUMsRUFBRSxhQUFhLFFBQVEsQ0FBQyxjQUFjLEVBQUUsSUFBSSxDQUNuRSxDQUFDO1FBQ0YsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2YsQ0FBQztDQUVKLENBQUE7QUFwQlksc0JBQXNCO0lBRmxDLFVBQVUsRUFBRTtJQUNaLFVBQVUsQ0FBQyxFQUFFLElBQUksRUFBRSxPQUFPLEVBQUUsQ0FBQztxQ0FHRyxNQUFNO0dBRjFCLHNCQUFzQixDQW9CbEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2luamVjdGFibGV9IGZyb20gXCJ0c3lyaW5nZVwiO1xyXG5pbXBvcnQge0V4cHJlc3NNaWRkbGV3YXJlSW50ZXJmYWNlLCBNaWRkbGV3YXJlfSBmcm9tIFwicm91dGluZy1jb250cm9sbGVyc1wiO1xyXG5pbXBvcnQgbW9tZW50IGZyb20gXCJtb21lbnRcIjtcclxuaW1wb3J0IHtJUmVxdWVzdH0gZnJvbSBcIi4uL2NvbW1vbi10eXBlc1wiO1xyXG5pbXBvcnQge0xvZ2dlcn0gZnJvbSBcIi4uL3NlcnZpY2VzL2xvZ2dlclwiO1xyXG5cclxuQGluamVjdGFibGUoKVxyXG5ATWlkZGxld2FyZSh7IHR5cGU6IFwiYWZ0ZXJcIiB9KVxyXG5leHBvcnQgY2xhc3MgUmVxdWVzdEVuZGVkTWlkZGxld2FyZSBpbXBsZW1lbnRzIEV4cHJlc3NNaWRkbGV3YXJlSW50ZXJmYWNlIHtcclxuXHJcbiAgICBjb25zdHJ1Y3RvcihyZWFkb25seSBsb2dnZXI6IExvZ2dlcikge1xyXG4gICAgfVxyXG5cclxuICAgIHVzZShyZXF1ZXN0OiBJUmVxdWVzdCwgcmVzcG9uc2U6IGFueSwgbmV4dDogKGVycj86IGFueSkgPT4gYW55KTogdm9pZCB7XHJcbiAgICAgICAgcmVxdWVzdC5lbmRlZCA9IG1vbWVudCgpO1xyXG4gICAgICAgIGNvbnN0IGRpZmYgPSByZXF1ZXN0LmVuZGVkLmRpZmYocmVxdWVzdC5zdGFydGVkKTtcclxuICAgICAgICBjb25zdCBkdXJhdGlvbiA9IG1vbWVudC5kdXJhdGlvbihkaWZmKTtcclxuICAgICAgICB0aGlzLmxvZ2dlci5sb2coXHJcbiAgICAgICAgICAgIFwicmVxdWVzdC10aW1lXCIsXHJcbiAgICAgICAgICAgIGBSZXF1ZXN0ICcke3JlcXVlc3QuaWR9JyBlbmRlZCBhdDogJHtyZXF1ZXN0LmVuZGVkLmZvcm1hdChcIllZWVktTU0tREQgSEg6bW06c3NcIil9IFske3JlcXVlc3QubWV0aG9kfV0gJHtyZXF1ZXN0LnVybH1gXHJcbiAgICAgICAgKTtcclxuICAgICAgICB0aGlzLmxvZ2dlci5sb2coXHJcbiAgICAgICAgICAgIFwicmVxdWVzdC10aW1lXCIsXHJcbiAgICAgICAgICAgIGBSZXF1ZXN0ICcke3JlcXVlc3QuaWR9JyBsYXN0ZWQ6ICR7ZHVyYXRpb24uYXNNaWxsaXNlY29uZHMoKX1tc2BcclxuICAgICAgICApO1xyXG4gICAgICAgIG5leHQobnVsbCk7XHJcbiAgICB9XHJcblxyXG59XHJcbiJdfQ==

package/esm2022/rest-middlewares/request-started.middleware.mjs

@@ -0,0 +1,25 @@
+import { __decorate, __metadata } from "tslib";
+import { injectable } from "tsyringe";
+import { Middleware } from "routing-controllers";
+import { ObjectId } from "bson";
+import moment from "moment";
+import { Logger } from "../services/logger";
+let RequestStartedMiddleware = class RequestStartedMiddleware {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    use(request, response, next) {
+        request.id = new ObjectId().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" }),
+    __metadata("design:paramtypes", [Logger])
+], RequestStartedMiddleware);
+export { RequestStartedMiddleware };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/asset-processor.mjs

@@ -0,0 +1,90 @@
+var AssetProcessor_1;
+import { __decorate } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+import fontKit_ from "fontkit";
+import sharp_ from "sharp";
+const sharp = 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(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);
+export { AssetProcessor };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asset-processor.js","sourceRoot":"","sources":["../../../src/services/asset-processor.ts"],"names":[],"mappings":"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","sourcesContent":["import {injectable, Lifecycle, scoped} from \"tsyringe\";\r\nimport fontKit_, {Font} from \"fontkit\";\r\nimport sharp_ from \"sharp\";\r\nimport {FontFormat, IAssetMeta, IFileType} from \"../common-types\";\r\n\r\nconst sharp = sharp_;\r\nconst fontKit = fontKit_;\r\n\r\nconst fontTypes = [\r\n    \"application/font-woff\", \"application/font-woff2\", \"application/x-font-opentype\", \"application/x-font-truetype\", \"application/x-font-datafork\",\r\n    \"font/woff\", \"font/woff2\", \"font/otf\", \"font/ttf\", \"font/datafork\"\r\n];\r\n\r\nconst imageTypes = [\"image/jpeg\", \"image/jpg\", \"image/png\", \"image/svg+xml\"];\r\n\r\nconst fontProps = [\r\n    \"postscriptName\", \"fullName\", \"familyName\", \"subfamilyName\",\r\n    \"copyright\", \"version\", \"unitsPerEm\", \"ascent\", \"descent\", \"lineGap\",\r\n    \"underlinePosition\", \"underlineThickness\", \"italicAngle\", \"capHeight\",\r\n    \"xHeight\", \"numGlyphs\", \"characterSet\", \"availableFeatures\"\r\n];\r\n\r\n@injectable()\r\n@scoped(Lifecycle.ContainerScoped)\r\nexport class AssetProcessor {\r\n\r\n    static extractFontFormat(font: Font): FontFormat {\r\n        const name: string = font.constructor.name;\r\n        const tag: string  = font[\"directory\"].tag;\r\n        switch (name) {\r\n            case \"TTFFont\":\r\n                return tag === \"OTTO\" ? \"opentype\" : \"truetype\";\r\n            case \"WOFF2Font\":\r\n                return \"woff2\";\r\n            case \"WOFFFont\":\r\n                return \"woff\";\r\n            case \"DFont\":\r\n                return \"datafork\";\r\n        }\r\n        return null;\r\n    }\r\n\r\n    static isImage(contentType: string): boolean {\r\n        return imageTypes.indexOf(contentType) >= 0;\r\n    }\r\n\r\n    static async copyImageMeta(buffer: Buffer, metadata: IAssetMeta, fileType: IFileType): Promise<Buffer> {\r\n        if (fileType.mime === \"image/svg+xml\") {\r\n            const match = /<svg([^<>]+)>/gi.exec(buffer.toString(\"utf8\"));\r\n            if (match && match.length > 1) {\r\n                const attrs = match[1].match(/([a-z]+)=\"([^\"]+)\"/gi);\r\n                attrs.forEach(attr => {\r\n                    if (attr.length < 5) return;\r\n                    const [name, value] = attr.split(\"=\");\r\n                    const val = value.replace(/\"/gi, \"\") as any;\r\n                    metadata[name] = isNaN(val) ? val : Number(val);\r\n                });\r\n                if (metadata.viewBox && (isNaN(metadata.width) || isNaN(metadata.height))) {\r\n                    const parts = (metadata.viewBox as string).split(\" \");\r\n                    metadata.width = Number(parts[0]) + Number(parts[2]);\r\n                    metadata.height = Number(parts[1]) + Number(parts[3]);\r\n                }\r\n                if (!isNaN(metadata.width) && !isNaN(metadata.height)) {\r\n                    metadata.svgSize = {x: metadata.width, y: metadata.height};\r\n                }\r\n            }\r\n            return buffer;\r\n        }\r\n        const output = await sharp(buffer).rotate().toBuffer({resolveWithObject: true});\r\n        Object.assign(metadata, output.info);\r\n        return output.data;\r\n    }\r\n\r\n    static isFont(contentType: string): boolean {\r\n        return fontTypes.indexOf(contentType) >= 0;\r\n    }\r\n\r\n    static copyFontMeta(buffer: Buffer, metadata: IAssetMeta): void {\r\n        const font = fontKit.create(buffer) as Font;\r\n        metadata.format = AssetProcessor.extractFontFormat(font);\r\n        fontProps.forEach(prop => {\r\n            metadata[prop] = font[prop];\r\n        });\r\n    }\r\n\r\n    async process(buffer: Buffer, metadata: IAssetMeta, fileType: IFileType): Promise<Buffer> {\r\n        if (AssetProcessor.isImage(fileType.mime)) {\r\n            buffer = await AssetProcessor.copyImageMeta(buffer, metadata, fileType);\r\n        }\r\n        if (AssetProcessor.isFont(fileType.mime)) {\r\n            AssetProcessor.copyFontMeta(buffer, metadata);\r\n        }\r\n        return buffer;\r\n    }\r\n}\r\n"]}

package/esm2022/services/asset-resolver.mjs

@@ -0,0 +1,36 @@
+import { __decorate, __metadata } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+import { Assets } from "./assets";
+import { LazyAssets } from "./lazy-assets";
+let AssetResolver = class AssetResolver {
+    assets;
+    lazyAssets;
+    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),
+    __metadata("design:paramtypes", [Assets, LazyAssets])
+], AssetResolver);
+export { AssetResolver };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/assets.mjs

@@ -0,0 +1,154 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { inject, injectable, Lifecycle, scoped } from "tsyringe";
+import { ObjectId } from "bson";
+import axios from "axios";
+import { bufferToStream, copyStream, fileTypeFromBuffer, streamToBuffer } from "../utils";
+import { ASSET_DRIVER } from "../common-types";
+import { MongoConnector } from "./mongo-connector";
+import { AssetProcessor } from "./asset-processor";
+import { Asset } from "./entities/asset";
+import { TempAsset } from "./entities/temp-asset";
+let Assets = class Assets {
+    connector;
+    assetProcessor;
+    driver;
+    collection;
+    constructor(connector, assetProcessor, driver) {
+        this.connector = connector;
+        this.assetProcessor = assetProcessor;
+        this.driver = driver;
+        this.collection = connector.database?.collection("assets.metadata");
+    }
+    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(id) });
+    }
+    async find(where) {
+        const data = await this.collection.findOne(where);
+        return !data ? null : new Asset(data._id, data, this.collection, this.driver);
+    }
+    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.driver));
+        }
+        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().toHexString();
+        metadata.extension = (fileType.ext || "").trim();
+        return new Promise(((resolve, reject) => {
+            const uploaderStream = this.driver.openUploadStream(metadata.filename, {
+                chunkSizeBytes: 1048576,
+                metadata,
+                contentType: fileType.mime
+            });
+            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.driver);
+                asset.save().then(() => {
+                    resolve(asset);
+                }, error => {
+                    reject(error.message || error);
+                });
+            });
+        }));
+    }
+};
+Assets = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __param(2, inject(ASSET_DRIVER)),
+    __metadata("design:paramtypes", [MongoConnector,
+        AssetProcessor, Object])
+], Assets);
+export { Assets };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assets.js","sourceRoot":"","sources":["../../../src/services/assets.ts"],"names":[],"mappings":"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","sourcesContent":["import {inject, injectable, Lifecycle, scoped} from \"tsyringe\";\nimport {Readable} from \"stream\";\nimport {ObjectId} from \"bson\";\nimport {Collection} from \"mongodb\";\nimport {FilterQuery} from \"mongoose\";\nimport axios from \"axios\";\n\nimport {bufferToStream, copyStream, fileTypeFromBuffer, streamToBuffer} from \"../utils\";\nimport {ASSET_DRIVER, IAsset, IAssetDriver, IAssetMeta, IFileType} from \"../common-types\";\nimport {MongoConnector} from \"./mongo-connector\";\nimport {AssetProcessor} from \"./asset-processor\";\nimport {Asset} from \"./entities/asset\";\nimport {TempAsset} from \"./entities/temp-asset\";\n\n@injectable()\n@scoped(Lifecycle.ContainerScoped)\nexport class Assets {\n\n    readonly collection: Collection<Partial<IAsset>>;\n\n    constructor(readonly connector: MongoConnector,\n                readonly assetProcessor: AssetProcessor,\n                @inject(ASSET_DRIVER) readonly driver: IAssetDriver) {\n        this.collection = connector.database?.collection(\"assets.metadata\");\n    }\n\n    async write(stream: Readable, contentType: string = null, metadata: IAssetMeta = null): Promise<IAsset> {\n        const uploadStream = copyStream(stream);\n        const buffer = await streamToBuffer(stream);\n        let fileType = {ext: \"\", mime: contentType} as IFileType;\n        try {\n            fileType = await fileTypeFromBuffer(buffer);\n        } catch (e) {\n            if (!fileType.mime) {\n                throw new Error(`Can't determine mime type: ${e}`);\n            }\n            console.log(`Can't determine mime type`, e);\n        }\n        metadata = metadata || {};\n        return this.upload(uploadStream, fileType, metadata);\n    }\n\n    async writeBuffer(buffer: Buffer, metadata: IAssetMeta = null, contentType: string = null): Promise<IAsset> {\n        let fileType = {ext: \"\", mime: contentType} as IFileType;\n        try {\n            fileType = await fileTypeFromBuffer(buffer);\n        } catch (e) {\n            if (!fileType.mime) {\n                throw `Can't determine mime type`;\n            }\n            console.log(`Can't determine mime type`, e);\n        }\n        metadata = metadata || {};\n        buffer = await this.assetProcessor.process(buffer, metadata, fileType);\n        return this.upload(bufferToStream(buffer), fileType, metadata);\n    }\n\n    async writeUrl(url: string, metadata: IAssetMeta = null): Promise<IAsset> {\n        metadata = metadata || {};\n        metadata.filename = metadata.filename || url;\n        metadata.url = url;\n        metadata.uploadTime = new Date().getTime();\n        const oneWeek = 1000 * 3600 * 24 * 7;\n        const asset = await this.find({\"metadata.url\": url, \"metadata.uploadTime\": {$gt: metadata.uploadTime - oneWeek}});\n        if (asset) return asset;\n        const buffer = (await axios({ url, responseType: \"arraybuffer\" })).data as Buffer;\n        return this.writeBuffer(buffer, metadata);\n    }\n\n    async download(url: string, contentType: string = null): Promise<IAsset> {\n        let buffer = (await axios({ url, responseType: \"arraybuffer\" })).data as Buffer;\n        let fileType = {ext: \"\", mime: contentType} as IFileType;\n        try {\n            fileType = await fileTypeFromBuffer(buffer);\n        } catch (e) {\n            if (!fileType.mime) {\n                throw `Can't determine mime type`;\n            }\n            console.log(`Can't determine mime type`, e);\n        }\n        const metadata: IAssetMeta = {\n            filename: url,\n            extension: (fileType.ext || \"\").trim()\n        };\n        buffer = await this.assetProcessor.process(buffer, metadata, fileType);\n        return new TempAsset(buffer, url, fileType.mime, metadata);\n    }\n\n    async read(id: string | ObjectId): Promise<IAsset> {\n        return !id ? null : this.find({_id: new ObjectId(id)});\n    }\n\n    async find(where: FilterQuery<IAsset>): Promise<IAsset> {\n        const data = await this.collection.findOne(where);\n        return !data ? null : new Asset(data._id, data, this.collection, this.driver);\n    }\n\n    async findMany(where: FilterQuery<IAsset>): Promise<ReadonlyArray<IAsset>> {\n        const cursor = this.collection.find(where);\n        const items = await cursor.toArray() || [];\n        const result: IAsset[] = [];\n        for (let item of items) {\n            if (!item) continue;\n            result.push(new Asset(item._id, item, this.collection, this.driver));\n        }\n        return result;\n    }\n\n    async deleteMany(where: FilterQuery<IAsset>): Promise<ReadonlyArray<string>> {\n        const assets = await this.findMany(where);\n        return Promise.all(assets.map(a => a.unlink()));\n    }\n\n    async unlink(id: string): Promise<any> {\n        const asset = await this.read(id);\n        if (!asset) return null;\n        return asset.unlink();\n    }\n\n    protected async upload(stream: Readable, fileType: IFileType, metadata: IAssetMeta): Promise<IAsset> {\n        const contentType = fileType.mime.trim();\n        metadata = Object.assign({\n            downloadCount: 0,\n            firstDownload: null,\n            lastDownload: null\n        }, metadata || {});\n        metadata.filename = metadata.filename || new ObjectId().toHexString();\n        metadata.extension = (fileType.ext || \"\").trim();\n        return new Promise<IAsset>(((resolve, reject) => {\n            const uploaderStream = this.driver.openUploadStream(metadata.filename, {\n                chunkSizeBytes: 1048576,\n                metadata,\n                contentType: fileType.mime\n            });\n            stream.pipe(uploaderStream)\n                .on(\"error\", error => {\n                    reject(error.message || error);\n                })\n                .on(\"finish\", () => {\n                    const asset = new Asset(uploaderStream.id as ObjectId, {\n                        filename: metadata.filename,\n                        contentType,\n                        metadata\n                    }, this.collection, this.driver);\n                    asset.save().then(() => {\n                        resolve(asset);\n                    }, error => {\n                        reject(error.message || error);\n                    });\n                });\n        }));\n    }\n}\n"]}

package/esm2022/services/backend-provider.mjs

@@ -0,0 +1,83 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { createServer } from "http";
+import { Server as SocketServer } from "socket.io";
+import cors from "cors";
+import express_ from "express";
+import { inject, singleton } from "tsyringe";
+import bodyParser from 'body-parser';
+import { Configuration } from './configuration';
+import { DI_CONTAINER } from '../common-types';
+import { OpenApi } from './open-api';
+import { JobManager } from './job-manager';
+import { Fixtures } from './fixtures';
+const express = express_;
+let BackendProvider = class BackendProvider {
+    config;
+    container;
+    get io() {
+        this.ioServer = this.ioServer || new SocketServer(this.server, {
+            path: "/socket",
+            cors: {
+                credentials: true,
+                exposedHeaders: ["content-disposition"],
+                origin: (origin, callback) => {
+                    callback(null, true);
+                }
+            }
+        });
+        return this.ioServer;
+    }
+    get express() {
+        if (!this.expressApp) {
+            this.expressApp = express();
+            this.expressApp.set("trust proxy", true);
+            this.expressApp.use(bodyParser.json({
+                limit: this.config.resolve("jsonLimit")
+            }));
+            this.expressApp.options("*", cors());
+            this.expressApp.get("/api-docs", (req, res) => {
+                this.openApi = this.openApi || this.container.get(OpenApi);
+                res.header("Content-Type", "application/json")
+                    .status(200)
+                    .end(this.openApi.apiDocsStr);
+            });
+        }
+        return this.expressApp;
+    }
+    get server() {
+        this.httpServer = this.httpServer || createServer(this.express);
+        return this.httpServer;
+    }
+    ioServer;
+    httpServer;
+    expressApp;
+    openApi;
+    constructor(config, container) {
+        this.config = config;
+        this.container = container;
+    }
+    async quickStart() {
+        const port = this.config.resolve("appPort");
+        const isWorker = this.config.resolve("isWorker");
+        if (isWorker || this.config.resolve("startWorker")) {
+            await this.container.resolve(JobManager).startProcessing();
+            if (isWorker) {
+                return;
+            }
+        }
+        if (this.config.resolve("fixtures")) {
+            const fixtures = this.container.resolve(Fixtures);
+            await fixtures.load();
+        }
+        return new Promise(resolve => {
+            this.server.listen(port, () => resolve(`Service listening on port ${port}!`));
+        });
+    }
+};
+BackendProvider = __decorate([
+    singleton(),
+    __param(1, inject(DI_CONTAINER)),
+    __metadata("design:paramtypes", [Configuration, Object])
+], BackendProvider);
+export { BackendProvider };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/cache-processor.mjs

@@ -0,0 +1,16 @@
+import { __decorate } from "tslib";
+import { injectable, scoped, Lifecycle } from "tsyringe";
+let CacheProcessor = class CacheProcessor {
+    async serialize(data) {
+        return data;
+    }
+    async deserialize(data) {
+        return data;
+    }
+};
+CacheProcessor = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], CacheProcessor);
+export { CacheProcessor };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUtcHJvY2Vzc29yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NlcnZpY2VzL2NhY2hlLXByb2Nlc3Nvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFDLFVBQVUsRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFDLE1BQU0sVUFBVSxDQUFDO0FBSWhELElBQU0sY0FBYyxHQUFwQixNQUFNLGNBQWM7SUFDdkIsS0FBSyxDQUFDLFNBQVMsQ0FBQyxJQUFTO1FBQ3JCLE9BQU8sSUFBSSxDQUFDO0lBQ2hCLENBQUM7SUFFRCxLQUFLLENBQUMsV0FBVyxDQUFDLElBQVM7UUFDdkIsT0FBTyxJQUFJLENBQUM7SUFDaEIsQ0FBQztDQUNKLENBQUE7QUFSWSxjQUFjO0lBRjFCLFVBQVUsRUFBRTtJQUNaLE1BQU0sQ0FBQyxTQUFTLENBQUMsZUFBZSxDQUFDO0dBQ3JCLGNBQWMsQ0FRMUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2luamVjdGFibGUsIHNjb3BlZCwgTGlmZWN5Y2xlfSBmcm9tIFwidHN5cmluZ2VcIjtcclxuXHJcbkBpbmplY3RhYmxlKClcclxuQHNjb3BlZChMaWZlY3ljbGUuQ29udGFpbmVyU2NvcGVkKVxyXG5leHBvcnQgY2xhc3MgQ2FjaGVQcm9jZXNzb3Ige1xyXG4gICAgYXN5bmMgc2VyaWFsaXplKGRhdGE6IGFueSk6IFByb21pc2U8YW55PiB7XHJcbiAgICAgICAgcmV0dXJuIGRhdGE7XHJcbiAgICB9XHJcblxyXG4gICAgYXN5bmMgZGVzZXJpYWxpemUoZGF0YTogYW55KTogUHJvbWlzZTxhbnk+IHtcclxuICAgICAgICByZXR1cm4gZGF0YTtcclxuICAgIH1cclxufVxyXG4iXX0=