@stemy/backend 3.6.0 → 4.0.0

package/esm2020/rest-controllers/assets.controller.mjs

@@ -0,0 +1,126 @@
+import { __decorate, __param } from "tslib";
+import { injectable } from "tsyringe";
+import { Authorized, Body, Controller, Get, HttpError, Param, Post, QueryParam, QueryParams, Res, UploadedFile } from "routing-controllers";
+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);
+export { AssetsController };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assets.controller.js","sourceRoot":"","sources":["../../../src/rest-controllers/assets.controller.ts"],"names":[],"mappings":"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","sourcesContent":["import {Readable} from \"stream\";\r\nimport {Response} from \"express\";\r\nimport {injectable} from \"tsyringe\";\r\nimport {\r\n    Authorized,\r\n    Body,\r\n    Controller,\r\n    Get,\r\n    HttpError,\r\n    Param,\r\n    Post,\r\n    QueryParam,\r\n    QueryParams,\r\n    Res,\r\n    UploadedFile\r\n} from \"routing-controllers\";\r\nimport {IAsset} from \"../common-types\";\r\nimport {Assets} from \"../services/assets\";\r\nimport {AssetResolver} from \"../services/asset-resolver\";\r\nimport {AssetImageParams} from \"../requests/asset-image-params\";\r\n\r\n@injectable()\r\n@Controller(\"/assets\")\r\nexport class AssetsController {\r\n\r\n    constructor(readonly assets: Assets, readonly assetResolver: AssetResolver) {\r\n\r\n    }\r\n\r\n    @Authorized()\r\n    @Post(\"\")\r\n    async upload(@UploadedFile(\"file\") file: Express.Multer.File) {\r\n        try {\r\n            const contentType = file.mimetype === \"application/octet-stream\" ? null : file.mimetype;\r\n            const asset = await this.assets.writeBuffer(file.buffer, {filename: file.filename}, contentType);\r\n            return asset.toJSON();\r\n        } catch (e) {\r\n            const msg = e?.message || e || \"Unknown error\";\r\n            throw new HttpError(400, `Asset can't be uploaded.\\n${msg}`);\r\n        }\r\n    }\r\n\r\n    @Authorized()\r\n    @Post(\"url\")\r\n    async uploadUrl(@Body() body: any) {\r\n        try {\r\n            const asset = await this.assets.writeUrl(body.url, body);\r\n            return asset.toJSON();\r\n        } catch (e) {\r\n            const msg = e?.message || e || \"Unknown error\";\r\n            throw new HttpError(400, `Asset can't be uploaded.\\n${msg}`);\r\n        }\r\n    }\r\n\r\n    @Get(\"/:id\")\r\n    async getFile(@Param(\"id\") id: string, @QueryParam(\"lazy\") lazy: boolean, @Res() res: Response): Promise<Readable> {\r\n        const asset = await this.getAsset(\"Asset\", id, lazy, res);\r\n        return asset.download();\r\n    }\r\n\r\n    @Get(\"/image/:id/:rotation\")\r\n    async getImageRotation(@Param(\"id\") id: string, @QueryParams() params: AssetImageParams, @Res() res: Response, @Param(\"rotation\") rotation: number = 0): Promise<Readable> {\r\n        const asset = await this.getAsset(\"Image\", id, params.lazy, res);\r\n        if (rotation !== 0) {\r\n            params.rotation = params.rotation || rotation;\r\n        }\r\n        return asset.downloadImage(params);\r\n    }\r\n\r\n    @Get(\"/image/:id\")\r\n    async getImage(@Param(\"id\") id: string, @QueryParams() params: AssetImageParams, @Res() res: Response): Promise<Readable> {\r\n        return this.getImageRotation(id, params, res);\r\n    }\r\n\r\n    @Get(\"/by-name/:name\")\r\n    async getFileByName(@Param(\"name\") name: string, @Res() res: Response): Promise<Readable> {\r\n        const asset = await this.getAssetByName(\"Asset\", name, res);\r\n        return asset.download();\r\n    }\r\n\r\n    @Get(\"/by-name/image/:name\")\r\n    async getImageByName(@Param(\"name\") name: string, @QueryParams() params: AssetImageParams, @Res() res: Response): Promise<Readable> {\r\n        const asset = await this.getAssetByName(\"Image\", name, res);\r\n        return asset.downloadImage(params);\r\n    }\r\n\r\n    protected setAssetHeaders(type: string, asset: IAsset, res: Response): void {\r\n        if (asset.metadata?.classified) {\r\n            throw new HttpError(403, `${type} is classified, and can be only downloaded from a custom url.`);\r\n        }\r\n        const ext = asset.metadata?.extension;\r\n        if (ext) {\r\n            res.header(\"content-disposition\", `inline; filename=${asset.filename}.${ext}`);\r\n        }\r\n        if (asset.contentType) {\r\n            res.header(\"content-type\", asset.contentType);\r\n        }\r\n    }\r\n\r\n    protected async getAsset(type: string, id: string, lazy: boolean, res: Response): Promise<IAsset> {\r\n        const asset = await this.assetResolver.resolve(id, lazy);\r\n        if (!asset) {\r\n            throw new HttpError(404, `${type} with id: '${id}' not found.`);\r\n        }\r\n        this.setAssetHeaders(type, asset, res);\r\n        return asset;\r\n    }\r\n\r\n    protected async getAssetByName(type: string, filename: string, res: Response): Promise<IAsset> {\r\n        const asset = await this.assets.find({filename});\r\n        if (!asset) {\r\n            throw new HttpError(404, `${type} with filename: '${filename}' not found.`);\r\n        }\r\n        this.setAssetHeaders(type, asset, res);\r\n        return asset;\r\n    }\r\n}\r\n"]}

package/esm2020/rest-controllers/auth.controller.mjs

@@ -0,0 +1,46 @@
+import { __decorate, __param } from "tslib";
+import webToken from "jsonwebtoken";
+import { injectable } from "tsyringe";
+import { Authorized, Body, Controller, CurrentUser, Get, HttpError, Post, Res, UnauthorizedError } from "routing-controllers";
+import { compare } from "bcrypt";
+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);
+export { AuthController };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/rest-controllers/gallery.controller.mjs

@@ -0,0 +1,21 @@
+import { __decorate, __param } from "tslib";
+import { injectable } from "tsyringe";
+import { Controller, Get, Param } from "routing-controllers";
+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);
+export { GalleryController };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2FsbGVyeS5jb250cm9sbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Jlc3QtY29udHJvbGxlcnMvZ2FsbGVyeS5jb250cm9sbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sVUFBVSxDQUFDO0FBQ3BDLE9BQU8sRUFBQyxVQUFVLEVBQUUsR0FBRyxFQUFFLEtBQUssRUFBQyxNQUFNLHFCQUFxQixDQUFDO0FBS3BELElBQU0saUJBQWlCLEdBQXZCLE1BQU0saUJBQWlCO0lBRTFCLFlBQXFCLFlBQTBCO1FBQTFCLGlCQUFZLEdBQVosWUFBWSxDQUFjO0lBQUksQ0FBQztJQUdwRCxPQUFPLENBQWMsRUFBVTtRQUMzQixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ3ZDLENBQUM7Q0FDSixDQUFBO0FBSkc7SUFBQyxHQUFHLENBQUMsTUFBTSxDQUFDO0lBQ0gsV0FBQSxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUE7Z0RBRW5CO0FBUFEsaUJBQWlCO0lBRjdCLFVBQVUsRUFBRTtJQUNaLFVBQVUsQ0FBQyxVQUFVLENBQUM7R0FDVixpQkFBaUIsQ0FRN0I7U0FSWSxpQkFBaUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2luamVjdGFibGV9IGZyb20gXCJ0c3lyaW5nZVwiO1xyXG5pbXBvcnQge0NvbnRyb2xsZXIsIEdldCwgUGFyYW19IGZyb20gXCJyb3V0aW5nLWNvbnRyb2xsZXJzXCI7XHJcbmltcG9ydCB7R2FsbGVyeUNhY2hlfSBmcm9tIFwiLi4vc2VydmljZXMvZ2FsbGVyeS1jYWNoZVwiO1xyXG5cclxuQGluamVjdGFibGUoKVxyXG5AQ29udHJvbGxlcihcIi9nYWxsZXJ5XCIpXHJcbmV4cG9ydCBjbGFzcyBHYWxsZXJ5Q29udHJvbGxlciB7XHJcblxyXG4gICAgY29uc3RydWN0b3IocmVhZG9ubHkgZ2FsbGVyeUNhY2hlOiBHYWxsZXJ5Q2FjaGUpIHsgfVxyXG5cclxuICAgIEBHZXQoXCIvOmlkXCIpXHJcbiAgICBnZXRGaWxlKEBQYXJhbShcImlkXCIpIGlkOiBzdHJpbmcpIHtcclxuICAgICAgICByZXR1cm4gdGhpcy5nYWxsZXJ5Q2FjaGUuc2VydmUoaWQpO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2020/rest-controllers/progresses.controller.mjs

@@ -0,0 +1,29 @@
+import { __decorate, __param } from "tslib";
+import { injectable } from "tsyringe";
+import { Controller, Get, Param } from "routing-controllers";
+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);
+export { ProgressesController };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZ3Jlc3Nlcy5jb250cm9sbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Jlc3QtY29udHJvbGxlcnMvcHJvZ3Jlc3Nlcy5jb250cm9sbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sVUFBVSxDQUFDO0FBQ3BDLE9BQU8sRUFBQyxVQUFVLEVBQUUsR0FBRyxFQUFFLEtBQUssRUFBQyxNQUFNLHFCQUFxQixDQUFDO0FBTXBELElBQU0sb0JBQW9CLEdBQTFCLE1BQU0sb0JBQW9CO0lBSTdCLFlBQXFCLFVBQXNCLEVBQVcsTUFBcUI7UUFBdEQsZUFBVSxHQUFWLFVBQVUsQ0FBWTtRQUFXLFdBQU0sR0FBTixNQUFNLENBQWU7UUFDdkUsTUFBTSxZQUFZLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDekQsSUFBSSxDQUFDLGNBQWMsR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUM7SUFDL0QsQ0FBQztJQUdLLEFBQU4sS0FBSyxDQUFDLFdBQVcsQ0FBYyxFQUFVO1FBQ3JDLE1BQU0sUUFBUSxHQUFHLE1BQU0sSUFBSSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDL0MsSUFBSSxDQUFDLFFBQVE7WUFBRSxPQUFPLElBQUksQ0FBQztRQUMzQixNQUFNLElBQUksR0FBRyxRQUFRLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDL0IsSUFBSSxDQUFDLGNBQWMsR0FBRyxJQUFJLENBQUMsY0FBYyxDQUFDO1FBQzFDLE9BQU8sSUFBSSxDQUFDO0lBQ2hCLENBQUM7Q0FDSixDQUFBO0FBUFM7SUFETCxHQUFHLENBQUMsTUFBTSxDQUFDO0lBQ08sV0FBQSxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUE7dURBTTdCO0FBaEJRLG9CQUFvQjtJQUZoQyxVQUFVLEVBQUU7SUFDWixVQUFVLENBQUMsYUFBYSxDQUFDO0dBQ2Isb0JBQW9CLENBaUJoQztTQWpCWSxvQkFBb0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2luamVjdGFibGV9IGZyb20gXCJ0c3lyaW5nZVwiO1xyXG5pbXBvcnQge0NvbnRyb2xsZXIsIEdldCwgUGFyYW19IGZyb20gXCJyb3V0aW5nLWNvbnRyb2xsZXJzXCI7XHJcbmltcG9ydCB7UHJvZ3Jlc3Nlc30gZnJvbSBcIi4uL3NlcnZpY2VzL3Byb2dyZXNzZXNcIjtcclxuaW1wb3J0IHtDb25maWd1cmF0aW9ufSBmcm9tIFwiLi4vc2VydmljZXMvY29uZmlndXJhdGlvblwiO1xyXG5cclxuQGluamVjdGFibGUoKVxyXG5AQ29udHJvbGxlcihcIi9wcm9ncmVzc2VzXCIpXHJcbmV4cG9ydCBjbGFzcyBQcm9ncmVzc2VzQ29udHJvbGxlciB7XHJcblxyXG4gICAgcHJvdGVjdGVkIGNvbm5lY3Rpb25UeXBlOiBzdHJpbmc7XHJcblxyXG4gICAgY29uc3RydWN0b3IocmVhZG9ubHkgcHJvZ3Jlc3NlczogUHJvZ3Jlc3NlcywgcmVhZG9ubHkgY29uZmlnOiBDb25maWd1cmF0aW9uKSB7XHJcbiAgICAgICAgY29uc3QgbWFpbkVuZHBvaW50ID0gdGhpcy5jb25maWcucmVzb2x2ZShcIm1haW5FbmRwb2ludFwiKTtcclxuICAgICAgICB0aGlzLmNvbm5lY3Rpb25UeXBlID0gIW1haW5FbmRwb2ludCA/IFwicG9sbGluZ1wiIDogXCJzb2NrZXRcIjtcclxuICAgIH1cclxuXHJcbiAgICBAR2V0KFwiLzppZFwiKVxyXG4gICAgYXN5bmMgZ2V0UHJvZ3Jlc3MoQFBhcmFtKFwiaWRcIikgaWQ6IHN0cmluZykge1xyXG4gICAgICAgIGNvbnN0IHByb2dyZXNzID0gYXdhaXQgdGhpcy5wcm9ncmVzc2VzLmdldChpZCk7XHJcbiAgICAgICAgaWYgKCFwcm9ncmVzcykgcmV0dXJuIG51bGw7XHJcbiAgICAgICAgY29uc3QganNvbiA9IHByb2dyZXNzLnRvSlNPTigpO1xyXG4gICAgICAgIGpzb24uY29ubmVjdGlvblR5cGUgPSB0aGlzLmNvbm5lY3Rpb25UeXBlO1xyXG4gICAgICAgIHJldHVybiBqc29uO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2020/rest-controllers/terminal-styles.mjs

@@ -0,0 +1,67 @@
+// Add a comment hint for webstorm to style the string as css
+export default `
+
+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";
+}
+
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/rest-controllers/terminal.controller.mjs

@@ -0,0 +1,125 @@
+import { __decorate } from "tslib";
+import { injectable } from "tsyringe";
+import { Controller, Get, Header } from "routing-controllers";
+import styles from "./terminal-styles";
+let TerminalController = 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.prototype, "terminal", null);
+__decorate([
+    Get("/console"),
+    Header("Content-Type", "text/html")
+], TerminalController.prototype, "console", null);
+__decorate([
+    Get(),
+    Header("Content-Type", "text/html")
+], TerminalController.prototype, "generateClient", null);
+TerminalController = __decorate([
+    injectable(),
+    Controller()
+], TerminalController);
+export { TerminalController };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"terminal.controller.js","sourceRoot":"","sources":["../../../src/rest-controllers/terminal.controller.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AACpC,OAAO,EAAC,UAAU,EAAE,GAAG,EAAE,MAAM,EAAC,MAAM,qBAAqB,CAAC;AAE5D,OAAO,MAAM,MAAM,mBAAmB,CAAC;AAIhC,IAAM,kBAAkB,GAAxB,MAAM,kBAAkB;IAM3B,YAAqB,MAAqB;QAArB,WAAM,GAAN,MAAM,CAAe;QACtC,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;QACjD,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;IACnD,CAAC;IAID,QAAQ;QACJ,OAAO,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IAC3C,CAAC;IAID,OAAO;QACH,OAAO,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;IAC1C,CAAC;IAIS,cAAc,CAAC,KAAa;QAClC,OAAO;;;;;qBAKM,IAAI,CAAC,WAAW,IAAI,KAAK;;kDAEI,IAAI,CAAC,UAAU;;kBAE/C,MAAM;;;;;;;;;;;;mCAYW,IAAI,CAAC,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDAwDC,IAAI,CAAC,WAAW,cAAc,KAAK;;;;;0DAK5B,IAAI,CAAC,WAAW,cAAc,KAAK;;;;;SAKpF,CAAC;IACN,CAAC;CACJ,CAAA;AAtGG;IAFC,GAAG,CAAC,WAAW,CAAC;IAChB,MAAM,CAAC,cAAc,EAAE,WAAW,CAAC;kDAGnC;AAID;IAFC,GAAG,CAAC,UAAU,CAAC;IACf,MAAM,CAAC,cAAc,EAAE,WAAW,CAAC;iDAGnC;AAID;IAFC,GAAG,EAAE;IACL,MAAM,CAAC,cAAc,EAAE,WAAW,CAAC;wDA0FnC;AAlHQ,kBAAkB;IAF9B,UAAU,EAAE;IACZ,UAAU,EAAE;GACA,kBAAkB,CAmH9B;SAnHY,kBAAkB","sourcesContent":["import {injectable} from \"tsyringe\";\r\nimport {Controller, Get, Header} from \"routing-controllers\";\r\nimport {Configuration} from \"../services/configuration\";\r\nimport styles from \"./terminal-styles\";\r\n\r\n@injectable()\r\n@Controller()\r\nexport class TerminalController {\r\n\r\n    protected serviceName: string;\r\n\r\n    protected serviceUrl: string;\r\n\r\n    constructor(readonly config: Configuration) {\r\n        this.serviceName = config.resolve(\"serviceName\");\r\n        this.serviceUrl = config.resolve(\"serviceUrl\");\r\n    }\r\n\r\n    @Get(\"/terminal\")\r\n    @Header(\"Content-Type\", \"text/html\")\r\n    terminal() {\r\n        return this.generateClient(\"terminal\");\r\n    }\r\n\r\n    @Get(\"/console\")\r\n    @Header(\"Content-Type\", \"text/html\")\r\n    console() {\r\n        return this.generateClient(\"console\");\r\n    }\r\n\r\n    @Get()\r\n    @Header(\"Content-Type\", \"text/html\")\r\n    protected generateClient(alias: string): string {\r\n        return `\r\n        <!DOCTYPE html>\r\n        <html>\r\n        <head>\r\n            <meta charset=\"utf-8\">\r\n            <title>${this.serviceName} ${alias}</title>\r\n            <link rel=\"stylesheet\" href=\"https://cdn.jsdelivr.net/npm/xterm@5.1.0/css/xterm.min.css\"/>\r\n            <script type=\"text/javascript\" src=\"${this.serviceUrl}/socket/socket.io.js\"></script>\r\n            <style>\r\n                ${styles}\r\n            </style>\r\n        </head>\r\n        <body>\r\n            <div id=\"terminal\"></div>\r\n            <script type=\"module\">\r\n                // Import terminal modules\r\n                import xterm from 'https://cdn.jsdelivr.net/npm/xterm@5.1.0/+esm';\r\n                import xtermFit from 'https://cdn.jsdelivr.net/npm/xterm-addon-fit@0.7.0/+esm';\r\n                // Initialize variables\r\n                var terminal = new xterm.Terminal();\r\n                var fitAddon = new xtermFit.FitAddon();\r\n                var socket = io(\"${this.serviceUrl}\", {path: \"/socket\"});\r\n                var clear = function () {\r\n                    terminal.clear();\r\n                    terminal.reset();\r\n                    // Prev line\r\n                    terminal.write(\"\\u001B[F\");\r\n                }\r\n                // Initialize terminal\r\n                terminal.loadAddon(fitAddon);\r\n                terminal.open(document.getElementById('terminal'));\r\n                terminal.onData(function (data) {\r\n                    socket.emit(\"terminal-data\", data.charCodeAt(0) === 127 ? \"\\b\" : data);\r\n                });\r\n                // Socket listeners\r\n                socket.on(\"terminal-data\", function (data) {\r\n                    if (data === \"\\x1bc\") {\r\n                        clear();\r\n                        return;\r\n                    }\r\n                    terminal.write(data);\r\n                });\r\n                socket.on(\"terminal-upload\", function (data) {\r\n                    var input = document.createElement(\"input\");\r\n                    input.type = \"file\";\r\n                    input.accept = data.accept;\r\n                    input.onchange = function () {\r\n                        var file = input.files[0];\r\n                        var reader = new FileReader();\r\n                        reader.onload = function () {\r\n                            socket.emit(\"terminal-upload\", {\r\n                                id: data.id,\r\n                                label: file.name,\r\n                                content: reader.result,\r\n                                accept: data.accept\r\n                            });\r\n                        };\r\n                        reader.onerror = function () {\r\n                            socket.emit(\"terminal-upload\", {\r\n                                id: data.id,\r\n                                label: file.name,\r\n                                error: reader.error,\r\n                                accept: data.accept\r\n                            });\r\n                        };\r\n                        reader.readAsDataURL(file);\r\n                    };\r\n                    input.click();\r\n                });\r\n                socket.on(\"terminal-download\", function (data) {\r\n                    var link = document.createElement(\"a\");\r\n                    link.href = data.content;\r\n                    link.download = data.filename;\r\n                    link.click();\r\n                });\r\n                socket.on(\"connect\", function () {\r\n                    clear();\r\n                    terminal.writeln(\"Welcome to ${this.serviceName} service's ${alias}!\");\r\n                    socket.emit(\"terminal-init\");\r\n                });\r\n                socket.on(\"disconnect\", function () {\r\n                    clear();\r\n                    terminal.writeln(\"Disconnected from ${this.serviceName} service's ${alias}.\");\r\n                });\r\n            </script>\r\n        </body>\r\n        </html>\r\n        `;\r\n    }\r\n}\r\n"]}

package/esm2020/rest-middlewares/container.middleware.mjs

@@ -0,0 +1,20 @@
+import { __decorate, __param } from "tslib";
+import { inject, injectable } from "tsyringe";
+import { Middleware } from "routing-controllers";
+import { DI_CONTAINER } from "../common-types";
+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);
+export { ContainerMiddleware };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGFpbmVyLm1pZGRsZXdhcmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmVzdC1taWRkbGV3YXJlcy9jb250YWluZXIubWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFDLE1BQU0sRUFBRSxVQUFVLEVBQUMsTUFBTSxVQUFVLENBQUM7QUFDNUMsT0FBTyxFQUE2QixVQUFVLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUMzRSxPQUFPLEVBQUMsWUFBWSxFQUFXLE1BQU0saUJBQWlCLENBQUM7QUFLaEQsSUFBTSxtQkFBbUIsR0FBekIsTUFBTSxtQkFBbUI7SUFFNUIsWUFBMkMsU0FBOEI7UUFBOUIsY0FBUyxHQUFULFNBQVMsQ0FBcUI7SUFFekUsQ0FBQztJQUVELEdBQUcsQ0FBQyxPQUFpQixFQUFFLFFBQWEsRUFBRSxJQUF3QjtRQUMxRCxPQUFPLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUM7UUFDbkMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2YsQ0FBQztDQUNKLENBQUE7QUFWWSxtQkFBbUI7SUFGL0IsVUFBVSxFQUFFO0lBQ1osVUFBVSxDQUFDLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxDQUFDO0lBR2QsV0FBQSxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUE7R0FGeEIsbUJBQW1CLENBVS9CO1NBVlksbUJBQW1CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtpbmplY3QsIGluamVjdGFibGV9IGZyb20gXCJ0c3lyaW5nZVwiO1xyXG5pbXBvcnQge0V4cHJlc3NNaWRkbGV3YXJlSW50ZXJmYWNlLCBNaWRkbGV3YXJlfSBmcm9tIFwicm91dGluZy1jb250cm9sbGVyc1wiO1xyXG5pbXBvcnQge0RJX0NPTlRBSU5FUiwgSVJlcXVlc3R9IGZyb20gXCIuLi9jb21tb24tdHlwZXNcIjtcclxuaW1wb3J0IHtEZXBlbmRlbmN5Q29udGFpbmVyfSBmcm9tIFwidHN5cmluZ2VcIjtcclxuXHJcbkBpbmplY3RhYmxlKClcclxuQE1pZGRsZXdhcmUoeyB0eXBlOiBcImJlZm9yZVwiIH0pXHJcbmV4cG9ydCBjbGFzcyBDb250YWluZXJNaWRkbGV3YXJlIGltcGxlbWVudHMgRXhwcmVzc01pZGRsZXdhcmVJbnRlcmZhY2Uge1xyXG5cclxuICAgIGNvbnN0cnVjdG9yKEBpbmplY3QoRElfQ09OVEFJTkVSKSByZWFkb25seSBjb250YWluZXI6IERlcGVuZGVuY3lDb250YWluZXIpIHtcclxuXHJcbiAgICB9XHJcblxyXG4gICAgdXNlKHJlcXVlc3Q6IElSZXF1ZXN0LCByZXNwb25zZTogYW55LCBuZXh0OiAoZXJyPzogYW55KSA9PiBhbnkpOiB2b2lkIHtcclxuICAgICAgICByZXF1ZXN0LmNvbnRhaW5lciA9IHRoaXMuY29udGFpbmVyO1xyXG4gICAgICAgIG5leHQobnVsbCk7XHJcbiAgICB9XHJcbn1cclxuIl19

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

@@ -0,0 +1,74 @@
+import { __decorate } from "tslib";
+import { injectable } from "tsyringe";
+import { BadRequestError, Middleware } from "routing-controllers";
+import axios from "axios";
+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);
+export { ErrorHandlerMiddleware };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,18 @@
+import { __decorate } from "tslib";
+import { injectable } from "tsyringe";
+import { Middleware } from "routing-controllers";
+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);
+export { LanguageMiddleware };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFuZ3VhZ2UubWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9yZXN0LW1pZGRsZXdhcmVzL2xhbmd1YWdlLm1pZGRsZXdhcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxVQUFVLENBQUM7QUFDcEMsT0FBTyxFQUE2QixVQUFVLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQU1wRSxJQUFNLGtCQUFrQixHQUF4QixNQUFNLGtCQUFrQjtJQUUzQixZQUFxQixNQUFxQjtRQUFyQixXQUFNLEdBQU4sTUFBTSxDQUFlO0lBRTFDLENBQUM7SUFFRCxHQUFHLENBQUMsT0FBaUIsRUFBRSxRQUFhLEVBQUUsSUFBd0I7UUFDMUQsT0FBTyxDQUFDLFFBQVEsR0FBRyxPQUFPLENBQUMsS0FBSyxDQUFDLFFBQWtCLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsaUJBQWlCLENBQUMsQ0FBQztRQUM5RixJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDZixDQUFDO0NBRUosQ0FBQTtBQVhZLGtCQUFrQjtJQUY5QixVQUFVLEVBQUU7SUFDWixVQUFVLENBQUMsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLENBQUM7R0FDbEIsa0JBQWtCLENBVzlCO1NBWFksa0JBQWtCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtpbmplY3RhYmxlfSBmcm9tIFwidHN5cmluZ2VcIjtcclxuaW1wb3J0IHtFeHByZXNzTWlkZGxld2FyZUludGVyZmFjZSwgTWlkZGxld2FyZX0gZnJvbSBcInJvdXRpbmctY29udHJvbGxlcnNcIjtcclxuaW1wb3J0IHtJUmVxdWVzdH0gZnJvbSBcIi4uL2NvbW1vbi10eXBlc1wiO1xyXG5pbXBvcnQge0NvbmZpZ3VyYXRpb259IGZyb20gXCIuLi9zZXJ2aWNlcy9jb25maWd1cmF0aW9uXCI7XHJcblxyXG5AaW5qZWN0YWJsZSgpXHJcbkBNaWRkbGV3YXJlKHsgdHlwZTogXCJiZWZvcmVcIiB9KVxyXG5leHBvcnQgY2xhc3MgTGFuZ3VhZ2VNaWRkbGV3YXJlIGltcGxlbWVudHMgRXhwcmVzc01pZGRsZXdhcmVJbnRlcmZhY2Uge1xyXG5cclxuICAgIGNvbnN0cnVjdG9yKHJlYWRvbmx5IGNvbmZpZzogQ29uZmlndXJhdGlvbikge1xyXG5cclxuICAgIH1cclxuXHJcbiAgICB1c2UocmVxdWVzdDogSVJlcXVlc3QsIHJlc3BvbnNlOiBhbnksIG5leHQ6IChlcnI/OiBhbnkpID0+IGFueSk6IHZvaWQge1xyXG4gICAgICAgIHJlcXVlc3QubGFuZ3VhZ2UgPSByZXF1ZXN0LnF1ZXJ5Lmxhbmd1YWdlIGFzIHN0cmluZyB8fCB0aGlzLmNvbmZpZy5yZXNvbHZlKFwiZGVmYXVsdExhbmd1YWdlXCIpO1xyXG4gICAgICAgIG5leHQobnVsbCk7XHJcbiAgICB9XHJcblxyXG59XHJcbiJdfQ==

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

@@ -0,0 +1,23 @@
+import { __decorate } from "tslib";
+import { injectable } from "tsyringe";
+import { Middleware } from "routing-controllers";
+import moment from "moment";
+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);
+export { RequestEndedMiddleware };
+//# sourceMappingURL=data:application/json;base64,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