@stemy/backend 5.2.2 → 6.0.0

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

@@ -0,0 +1,177 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { injectable } from "tsyringe";
+import { Authorized, Body, Controller, Get, HttpError, Param, Post, QueryParam, QueryParams, Res, UploadedFile } from "routing-controllers";
+import { Assets } from "../services/assets";
+import { AssetResolver } from "../services/asset-resolver";
+import { AssetImageParams } from "../requests/asset-image-params";
+let AssetsController = class AssetsController {
+    assets;
+    assetResolver;
+    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 getMetadata(id, lazy, res) {
+        const asset = await this.assetResolver.resolve(id, lazy);
+        if (!asset) {
+            throw new HttpError(404, `Asset with id: '${id}' not found.`);
+        }
+        return asset.metadata;
+    }
+    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(asset, res) {
+        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) {
+        let asset = await this.assetResolver.resolve(id, lazy);
+        if (!asset) {
+            throw new HttpError(404, `${type} with id: '${id}' not found.`);
+        }
+        asset = await this.resolveFinalAsset(type, asset);
+        this.setAssetHeaders(asset, res);
+        return asset;
+    }
+    async getAssetByName(type, filename, res) {
+        let asset = await this.assets.find({ filename });
+        if (!asset) {
+            throw new HttpError(404, `${type} with filename: '${filename}' not found.`);
+        }
+        asset = await this.resolveFinalAsset(type, asset);
+        this.setAssetHeaders(asset, res);
+        return asset;
+    }
+    async resolveFinalAsset(type, asset) {
+        if (asset.metadata?.classified) {
+            throw new HttpError(403, `${type} is classified, and can be only downloaded from a custom url.`);
+        }
+        if (type == 'Image' && asset.metadata.preview) {
+            return this.resolveFinalAsset(type, await this.assetResolver.resolve(asset.metadata.preview));
+        }
+        return asset;
+    }
+};
+__decorate([
+    Authorized(),
+    Post(""),
+    __param(0, UploadedFile("file")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], AssetsController.prototype, "upload", null);
+__decorate([
+    Authorized(),
+    Post("url"),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], AssetsController.prototype, "uploadUrl", null);
+__decorate([
+    Get("/:id"),
+    __param(0, Param("id")),
+    __param(1, QueryParam("lazy")),
+    __param(2, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Boolean, Object]),
+    __metadata("design:returntype", Promise)
+], AssetsController.prototype, "getFile", null);
+__decorate([
+    Get("/metadata/:id"),
+    __param(0, Param("id")),
+    __param(1, QueryParam("lazy")),
+    __param(2, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Boolean, Object]),
+    __metadata("design:returntype", Promise)
+], AssetsController.prototype, "getMetadata", null);
+__decorate([
+    Get("/image/:id/:rotation"),
+    __param(0, Param("id")),
+    __param(1, QueryParams()),
+    __param(2, Res()),
+    __param(3, Param("rotation")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, AssetImageParams, Object, Number]),
+    __metadata("design:returntype", Promise)
+], AssetsController.prototype, "getImageRotation", null);
+__decorate([
+    Get("/image/:id"),
+    __param(0, Param("id")),
+    __param(1, QueryParams()),
+    __param(2, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, AssetImageParams, Object]),
+    __metadata("design:returntype", Promise)
+], AssetsController.prototype, "getImage", null);
+__decorate([
+    Get("/by-name/:name"),
+    __param(0, Param("name")),
+    __param(1, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], AssetsController.prototype, "getFileByName", null);
+__decorate([
+    Get("/by-name/image/:name"),
+    __param(0, Param("name")),
+    __param(1, QueryParams()),
+    __param(2, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, AssetImageParams, Object]),
+    __metadata("design:returntype", Promise)
+], AssetsController.prototype, "getImageByName", null);
+AssetsController = __decorate([
+    injectable(),
+    Controller("/assets"),
+    __metadata("design:paramtypes", [Assets, AssetResolver])
+], 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\ntype AssetReqType = 'Image' | 'Asset';\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(\"/metadata/:id\")\r\n    async getMetadata(@Param(\"id\") id: string, @QueryParam(\"lazy\") lazy: boolean, @Res() res: Response): Promise<any> {\r\n        const asset = await this.assetResolver.resolve(id, lazy);\r\n        if (!asset) {\r\n            throw new HttpError(404, `Asset with id: '${id}' not found.`);\r\n        }\r\n        return asset.metadata;\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(asset: IAsset, res: Response): void {\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: AssetReqType, id: string, lazy: boolean, res: Response): Promise<IAsset> {\r\n        let 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        asset = await this.resolveFinalAsset(type, asset);\r\n        this.setAssetHeaders(asset, res);\r\n        return asset;\r\n    }\r\n\r\n    protected async getAssetByName(type: AssetReqType, filename: string, res: Response): Promise<IAsset> {\r\n        let 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        asset = await this.resolveFinalAsset(type, asset);\r\n        this.setAssetHeaders(asset, res);\r\n        return asset;\r\n    }\r\n\r\n    protected async resolveFinalAsset(type: AssetReqType, asset: IAsset): Promise<IAsset> {\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        if (type == 'Image' && asset.metadata.preview) {\r\n            return this.resolveFinalAsset(type, await this.assetResolver.resolve(asset.metadata.preview));\r\n        }\r\n        return asset;\r\n    }\r\n}\r\n"]}

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

@@ -0,0 +1,57 @@
+import { __decorate, __metadata, __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";
+import { Configuration } from "../services/configuration";
+import { UserManager } from "../services/user-manager";
+let AuthController = class AuthController {
+    config;
+    userManager;
+    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()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AuthController.prototype, "login", null);
+__decorate([
+    Authorized(),
+    Get("/user"),
+    __param(0, CurrentUser()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], AuthController.prototype, "getProfile", null);
+AuthController = __decorate([
+    injectable(),
+    Controller(),
+    __metadata("design:paramtypes", [Configuration, UserManager])
+], AuthController);
+export { AuthController };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,27 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { injectable } from "tsyringe";
+import { Controller, Get, Param } from "routing-controllers";
+import { GalleryCache } from "../services/gallery-cache";
+let GalleryController = class GalleryController {
+    galleryCache;
+    constructor(galleryCache) {
+        this.galleryCache = galleryCache;
+    }
+    getFile(id) {
+        return this.galleryCache.serve(id);
+    }
+};
+__decorate([
+    Get("/:id"),
+    __param(0, Param("id")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], GalleryController.prototype, "getFile", null);
+GalleryController = __decorate([
+    injectable(),
+    Controller("/gallery"),
+    __metadata("design:paramtypes", [GalleryCache])
+], GalleryController);
+export { GalleryController };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2FsbGVyeS5jb250cm9sbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Jlc3QtY29udHJvbGxlcnMvZ2FsbGVyeS5jb250cm9sbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sVUFBVSxDQUFDO0FBQ3BDLE9BQU8sRUFBQyxVQUFVLEVBQUUsR0FBRyxFQUFFLEtBQUssRUFBQyxNQUFNLHFCQUFxQixDQUFDO0FBQzNELE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSwyQkFBMkIsQ0FBQztBQUloRCxJQUFNLGlCQUFpQixHQUF2QixNQUFNLGlCQUFpQjtJQUVMO0lBQXJCLFlBQXFCLFlBQTBCO1FBQTFCLGlCQUFZLEdBQVosWUFBWSxDQUFjO0lBQUksQ0FBQztJQUdwRCxPQUFPLENBQWMsRUFBVTtRQUMzQixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ3ZDLENBQUM7Q0FDSixDQUFBO0FBSEc7SUFEQyxHQUFHLENBQUMsTUFBTSxDQUFDO0lBQ0gsV0FBQSxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUE7Ozs7Z0RBRW5CO0FBUFEsaUJBQWlCO0lBRjdCLFVBQVUsRUFBRTtJQUNaLFVBQVUsQ0FBQyxVQUFVLENBQUM7cUNBR2dCLFlBQVk7R0FGdEMsaUJBQWlCLENBUTdCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtpbmplY3RhYmxlfSBmcm9tIFwidHN5cmluZ2VcIjtcclxuaW1wb3J0IHtDb250cm9sbGVyLCBHZXQsIFBhcmFtfSBmcm9tIFwicm91dGluZy1jb250cm9sbGVyc1wiO1xyXG5pbXBvcnQge0dhbGxlcnlDYWNoZX0gZnJvbSBcIi4uL3NlcnZpY2VzL2dhbGxlcnktY2FjaGVcIjtcclxuXHJcbkBpbmplY3RhYmxlKClcclxuQENvbnRyb2xsZXIoXCIvZ2FsbGVyeVwiKVxyXG5leHBvcnQgY2xhc3MgR2FsbGVyeUNvbnRyb2xsZXIge1xyXG5cclxuICAgIGNvbnN0cnVjdG9yKHJlYWRvbmx5IGdhbGxlcnlDYWNoZTogR2FsbGVyeUNhY2hlKSB7IH1cclxuXHJcbiAgICBAR2V0KFwiLzppZFwiKVxyXG4gICAgZ2V0RmlsZShAUGFyYW0oXCJpZFwiKSBpZDogc3RyaW5nKSB7XHJcbiAgICAgICAgcmV0dXJuIHRoaXMuZ2FsbGVyeUNhY2hlLnNlcnZlKGlkKTtcclxuICAgIH1cclxufVxyXG4iXX0=

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

@@ -0,0 +1,38 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { injectable } from "tsyringe";
+import { Controller, Get, Param } from "routing-controllers";
+import { Progresses } from "../services/progresses";
+import { Configuration } from "../services/configuration";
+let ProgressesController = class ProgressesController {
+    progresses;
+    config;
+    connectionType;
+    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")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], ProgressesController.prototype, "getProgress", null);
+ProgressesController = __decorate([
+    injectable(),
+    Controller("/progresses"),
+    __metadata("design:paramtypes", [Progresses, Configuration])
+], ProgressesController);
+export { ProgressesController };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZ3Jlc3Nlcy5jb250cm9sbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Jlc3QtY29udHJvbGxlcnMvcHJvZ3Jlc3Nlcy5jb250cm9sbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sVUFBVSxDQUFDO0FBQ3BDLE9BQU8sRUFBQyxVQUFVLEVBQUUsR0FBRyxFQUFFLEtBQUssRUFBQyxNQUFNLHFCQUFxQixDQUFDO0FBQzNELE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSx3QkFBd0IsQ0FBQztBQUNsRCxPQUFPLEVBQUMsYUFBYSxFQUFDLE1BQU0sMkJBQTJCLENBQUM7QUFJakQsSUFBTSxvQkFBb0IsR0FBMUIsTUFBTSxvQkFBb0I7SUFJUjtJQUFpQztJQUY1QyxjQUFjLENBQVM7SUFFakMsWUFBcUIsVUFBc0IsRUFBVyxNQUFxQjtRQUF0RCxlQUFVLEdBQVYsVUFBVSxDQUFZO1FBQVcsV0FBTSxHQUFOLE1BQU0sQ0FBZTtRQUN2RSxNQUFNLFlBQVksR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FBQztRQUN6RCxJQUFJLENBQUMsY0FBYyxHQUFHLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQztJQUMvRCxDQUFDO0lBR0ssQUFBTixLQUFLLENBQUMsV0FBVyxDQUFjLEVBQVU7UUFDckMsTUFBTSxRQUFRLEdBQUcsTUFBTSxJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUMvQyxJQUFJLENBQUMsUUFBUTtZQUFFLE9BQU8sSUFBSSxDQUFDO1FBQzNCLE1BQU0sSUFBSSxHQUFHLFFBQVEsQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUMvQixJQUFJLENBQUMsY0FBYyxHQUFHLElBQUksQ0FBQyxjQUFjLENBQUM7UUFDMUMsT0FBTyxJQUFJLENBQUM7SUFDaEIsQ0FBQztDQUNKLENBQUE7QUFQUztJQURMLEdBQUcsQ0FBQyxNQUFNLENBQUM7SUFDTyxXQUFBLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQTs7Ozt1REFNN0I7QUFoQlEsb0JBQW9CO0lBRmhDLFVBQVUsRUFBRTtJQUNaLFVBQVUsQ0FBQyxhQUFhLENBQUM7cUNBS1csVUFBVSxFQUFtQixhQUFhO0dBSmxFLG9CQUFvQixDQWlCaEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2luamVjdGFibGV9IGZyb20gXCJ0c3lyaW5nZVwiO1xyXG5pbXBvcnQge0NvbnRyb2xsZXIsIEdldCwgUGFyYW19IGZyb20gXCJyb3V0aW5nLWNvbnRyb2xsZXJzXCI7XHJcbmltcG9ydCB7UHJvZ3Jlc3Nlc30gZnJvbSBcIi4uL3NlcnZpY2VzL3Byb2dyZXNzZXNcIjtcclxuaW1wb3J0IHtDb25maWd1cmF0aW9ufSBmcm9tIFwiLi4vc2VydmljZXMvY29uZmlndXJhdGlvblwiO1xyXG5cclxuQGluamVjdGFibGUoKVxyXG5AQ29udHJvbGxlcihcIi9wcm9ncmVzc2VzXCIpXHJcbmV4cG9ydCBjbGFzcyBQcm9ncmVzc2VzQ29udHJvbGxlciB7XHJcblxyXG4gICAgcHJvdGVjdGVkIGNvbm5lY3Rpb25UeXBlOiBzdHJpbmc7XHJcblxyXG4gICAgY29uc3RydWN0b3IocmVhZG9ubHkgcHJvZ3Jlc3NlczogUHJvZ3Jlc3NlcywgcmVhZG9ubHkgY29uZmlnOiBDb25maWd1cmF0aW9uKSB7XHJcbiAgICAgICAgY29uc3QgbWFpbkVuZHBvaW50ID0gdGhpcy5jb25maWcucmVzb2x2ZShcIm1haW5FbmRwb2ludFwiKTtcclxuICAgICAgICB0aGlzLmNvbm5lY3Rpb25UeXBlID0gIW1haW5FbmRwb2ludCA/IFwicG9sbGluZ1wiIDogXCJzb2NrZXRcIjtcclxuICAgIH1cclxuXHJcbiAgICBAR2V0KFwiLzppZFwiKVxyXG4gICAgYXN5bmMgZ2V0UHJvZ3Jlc3MoQFBhcmFtKFwiaWRcIikgaWQ6IHN0cmluZykge1xyXG4gICAgICAgIGNvbnN0IHByb2dyZXNzID0gYXdhaXQgdGhpcy5wcm9ncmVzc2VzLmdldChpZCk7XHJcbiAgICAgICAgaWYgKCFwcm9ncmVzcykgcmV0dXJuIG51bGw7XHJcbiAgICAgICAgY29uc3QganNvbiA9IHByb2dyZXNzLnRvSlNPTigpO1xyXG4gICAgICAgIGpzb24uY29ubmVjdGlvblR5cGUgPSB0aGlzLmNvbm5lY3Rpb25UeXBlO1xyXG4gICAgICAgIHJldHVybiBqc29uO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2022/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/esm2022/rest-controllers/terminal.controller.mjs

@@ -0,0 +1,132 @@
+import { __decorate, __metadata } from "tslib";
+import { injectable } from "tsyringe";
+import { Controller, Get, Header } from "routing-controllers";
+import { Configuration } from "../services/configuration";
+import styles from "./terminal-styles";
+let TerminalController = class TerminalController {
+    config;
+    serviceName;
+    serviceUrl;
+    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"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TerminalController.prototype, "terminal", null);
+__decorate([
+    Get("/console"),
+    Header("Content-Type", "text/html"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TerminalController.prototype, "console", null);
+TerminalController = __decorate([
+    injectable(),
+    Controller(),
+    __metadata("design:paramtypes", [Configuration])
+], 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;AAC5D,OAAO,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AACxD,OAAO,MAAM,MAAM,mBAAmB,CAAC;AAIhC,IAAM,kBAAkB,GAAxB,MAAM,kBAAkB;IAMN;IAJX,WAAW,CAAS;IAEpB,UAAU,CAAS;IAE7B,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;IAES,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;AApGG;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;AArBQ,kBAAkB;IAF9B,UAAU,EAAE;IACZ,UAAU,EAAE;qCAOoB,aAAa;GANjC,kBAAkB,CAiH9B","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    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/esm2022/rest-middlewares/container.middleware.mjs

@@ -0,0 +1,22 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { inject, injectable } from "tsyringe";
+import { Middleware } from "routing-controllers";
+import { DI_CONTAINER } from "../common-types";
+let ContainerMiddleware = class ContainerMiddleware {
+    container;
+    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)),
+    __metadata("design:paramtypes", [Object])
+], ContainerMiddleware);
+export { ContainerMiddleware };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGFpbmVyLm1pZGRsZXdhcmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmVzdC1taWRkbGV3YXJlcy9jb250YWluZXIubWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFDLE1BQU0sRUFBRSxVQUFVLEVBQUMsTUFBTSxVQUFVLENBQUM7QUFDNUMsT0FBTyxFQUE2QixVQUFVLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUMzRSxPQUFPLEVBQUMsWUFBWSxFQUFXLE1BQU0saUJBQWlCLENBQUM7QUFLaEQsSUFBTSxtQkFBbUIsR0FBekIsTUFBTSxtQkFBbUI7SUFFZTtJQUEzQyxZQUEyQyxTQUE4QjtRQUE5QixjQUFTLEdBQVQsU0FBUyxDQUFxQjtJQUV6RSxDQUFDO0lBRUQsR0FBRyxDQUFDLE9BQWlCLEVBQUUsUUFBYSxFQUFFLElBQXdCO1FBQzFELE9BQU8sQ0FBQyxTQUFTLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQztRQUNuQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDZixDQUFDO0NBQ0osQ0FBQTtBQVZZLG1CQUFtQjtJQUYvQixVQUFVLEVBQUU7SUFDWixVQUFVLENBQUMsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLENBQUM7SUFHZCxXQUFBLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQTs7R0FGeEIsbUJBQW1CLENBVS9CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtpbmplY3QsIGluamVjdGFibGV9IGZyb20gXCJ0c3lyaW5nZVwiO1xyXG5pbXBvcnQge0V4cHJlc3NNaWRkbGV3YXJlSW50ZXJmYWNlLCBNaWRkbGV3YXJlfSBmcm9tIFwicm91dGluZy1jb250cm9sbGVyc1wiO1xyXG5pbXBvcnQge0RJX0NPTlRBSU5FUiwgSVJlcXVlc3R9IGZyb20gXCIuLi9jb21tb24tdHlwZXNcIjtcclxuaW1wb3J0IHtEZXBlbmRlbmN5Q29udGFpbmVyfSBmcm9tIFwidHN5cmluZ2VcIjtcclxuXHJcbkBpbmplY3RhYmxlKClcclxuQE1pZGRsZXdhcmUoeyB0eXBlOiBcImJlZm9yZVwiIH0pXHJcbmV4cG9ydCBjbGFzcyBDb250YWluZXJNaWRkbGV3YXJlIGltcGxlbWVudHMgRXhwcmVzc01pZGRsZXdhcmVJbnRlcmZhY2Uge1xyXG5cclxuICAgIGNvbnN0cnVjdG9yKEBpbmplY3QoRElfQ09OVEFJTkVSKSByZWFkb25seSBjb250YWluZXI6IERlcGVuZGVuY3lDb250YWluZXIpIHtcclxuXHJcbiAgICB9XHJcblxyXG4gICAgdXNlKHJlcXVlc3Q6IElSZXF1ZXN0LCByZXNwb25zZTogYW55LCBuZXh0OiAoZXJyPzogYW55KSA9PiBhbnkpOiB2b2lkIHtcclxuICAgICAgICByZXF1ZXN0LmNvbnRhaW5lciA9IHRoaXMuY29udGFpbmVyO1xyXG4gICAgICAgIG5leHQobnVsbCk7XHJcbiAgICB9XHJcbn1cclxuIl19