@stemy/backend 3.6.0 → 4.0.0

package/esm2020/services/progresses.mjs

@@ -0,0 +1,86 @@
+import { __decorate } from "tslib";
+import { singleton } from "tsyringe";
+import { ObjectId } from "bson";
+import { promiseTimeout } from "../utils";
+import { Progress } from "./entities/progress";
+let Progresses = class Progresses {
+    constructor(connector, jobMan) {
+        this.connector = connector;
+        this.jobMan = jobMan;
+        this.collection = connector.database.collection("progresses");
+        this.progresses = {};
+        this.jobMan.on("progress-changed", progress => {
+            const id = progress.id;
+            this.progresses[id] = new Progress(new ObjectId(id), progress, this.collection);
+        });
+    }
+    async waitToFinish(id) {
+        return Promise.race([
+            this.waitForProgress(id, async () => {
+                let progress = this.progresses[id];
+                if (!progress || progress.percent < 100) {
+                    progress = await this.get(id);
+                }
+                if (!progress) {
+                    throw new Error(`Progress does not exists with id: ${id}`);
+                }
+                return progress;
+            }, 500),
+            this.waitForProgress(id, async () => {
+                return this.progresses[id] || null;
+            }, 25)
+        ]);
+    }
+    async get(id) {
+        return !id ? null : this.find({ _id: new ObjectId(id) });
+    }
+    async find(where) {
+        const data = await this.collection.findOne(where);
+        return !data ? null : new Progress(data._id, data, this.collection);
+    }
+    async create(max = 100) {
+        if (isNaN(max) || max <= 0) {
+            throw new Error(`Max progress value must be bigger than zero`);
+        }
+        const data = {
+            current: 0,
+            max: max,
+            message: "",
+            error: "",
+            canceled: false
+        };
+        const res = await this.collection.insertOne(data);
+        return new Progress(res.insertedId, data, this.collection);
+    }
+    async remove(id) {
+        await this.collection.deleteOne({ _id: new ObjectId(id) });
+        return id;
+    }
+    async waitForProgress(id, cb, delay) {
+        let isFinished = false;
+        let progress = null;
+        let waitTime = 0;
+        while (!isFinished) {
+            progress = await cb();
+            waitTime += delay;
+            if (progress) {
+                if (progress.error) {
+                    throw new Error(progress.error);
+                }
+                isFinished = progress.percent >= 100;
+            }
+            if (!isFinished) {
+                if (waitTime >= this.jobMan.maxTimeout) {
+                    throw new Error(`Progress with id: ${id} probably never will be finished!`);
+                }
+                await promiseTimeout(delay);
+            }
+        }
+        return progress;
+    }
+};
+Progresses = __decorate([
+    singleton()
+], Progresses);
+export { Progresses };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"progresses.js","sourceRoot":"","sources":["../../../src/services/progresses.ts"],"names":[],"mappings":"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","sourcesContent":["import {singleton} from \"tsyringe\";\r\nimport {ObjectId} from \"bson\";\r\nimport {Collection} from \"mongodb\";\r\nimport {FilterQuery} from \"mongoose\";\r\nimport {IProgress} from \"../common-types\";\r\nimport {promiseTimeout} from \"../utils\";\r\nimport {MongoConnector} from \"./mongo-connector\";\r\nimport {JobManager} from \"./job-manager\";\r\nimport {Progress} from \"./entities/progress\";\r\n\r\n@singleton()\r\nexport class Progresses {\r\n\r\n    protected collection: Collection<Partial<IProgress>>;\r\n    protected progresses: {[id: string]: IProgress};\r\n\r\n    constructor(readonly connector: MongoConnector, readonly jobMan: JobManager) {\r\n        this.collection = connector.database.collection(\"progresses\");\r\n        this.progresses = {};\r\n        this.jobMan.on(\"progress-changed\", progress => {\r\n            const id = progress.id as string;\r\n            this.progresses[id] = new Progress(new ObjectId(id), progress as any, this.collection);\r\n        });\r\n    }\r\n\r\n    async waitToFinish(id: string): Promise<IProgress> {\r\n        return Promise.race([\r\n            this.waitForProgress(id, async () => {\r\n                let progress = this.progresses[id];\r\n                if (!progress || progress.percent < 100) {\r\n                    progress = await this.get(id);\r\n                }\r\n                if (!progress) {\r\n                    throw new Error(`Progress does not exists with id: ${id}`);\r\n                }\r\n                return progress;\r\n            }, 500),\r\n            this.waitForProgress(id, async () => {\r\n                return this.progresses[id] || null;\r\n            }, 25)\r\n        ]);\r\n    }\r\n\r\n    async get(id: string): Promise<IProgress> {\r\n        return !id ? null : this.find({_id: new ObjectId(id)});\r\n    }\r\n\r\n    async find(where: FilterQuery<IProgress>): Promise<IProgress> {\r\n        const data = await this.collection.findOne(where);\r\n        return !data ? null : new Progress(data._id, data, this.collection);\r\n    }\r\n\r\n    async create(max: number = 100): Promise<IProgress> {\r\n        if (isNaN(max) || max <= 0) {\r\n            throw new Error(`Max progress value must be bigger than zero`);\r\n        }\r\n        const data = {\r\n            current: 0,\r\n            max: max,\r\n            message: \"\",\r\n            error: \"\",\r\n            canceled: false\r\n        };\r\n        const res = await this.collection.insertOne(data);\r\n        return new Progress(res.insertedId, data, this.collection);\r\n    }\r\n\r\n    async remove(id: string): Promise<any> {\r\n        await this.collection.deleteOne({_id: new ObjectId(id)});\r\n        return id;\r\n    }\r\n\r\n    protected async waitForProgress(id: string, cb: () => Promise<IProgress>, delay: number): Promise<IProgress> {\r\n        let isFinished = false;\r\n        let progress: IProgress = null;\r\n        let waitTime: number = 0;\r\n        while (!isFinished) {\r\n            progress = await cb();\r\n            waitTime += delay;\r\n            if (progress) {\r\n                if (progress.error) {\r\n                    throw new Error(progress.error);\r\n                }\r\n                isFinished = progress.percent >= 100;\r\n            }\r\n            if (!isFinished) {\r\n                if (waitTime >= this.jobMan.maxTimeout) {\r\n                    throw new Error(`Progress with id: ${id} probably never will be finished!`);\r\n                }\r\n                await promiseTimeout(delay);\r\n            }\r\n        }\r\n        return progress;\r\n    }\r\n}\r\n"]}

package/esm2020/services/template-renderer.mjs

@@ -0,0 +1,64 @@
+import { __decorate } from "tslib";
+import { singleton } from "tsyringe";
+import { lstatSync, readdir, readFileSync } from "fs";
+import { join } from "path";
+import * as Handlebars from "handlebars";
+let TemplateRenderer = class TemplateRenderer {
+    constructor(translator, config) {
+        this.translator = translator;
+        this.config = config;
+        this.templates = {};
+        Handlebars.registerHelper(`object`, function ({ hash }) {
+            return hash;
+        });
+        Handlebars.registerHelper(`now`, function () {
+            return new Date().getTime();
+        });
+        Handlebars.registerHelper(`keys`, function (obj) {
+            return !obj ? [] : Object.keys(obj);
+        });
+        Handlebars.registerHelper(`translate`, function (key, params) {
+            return translator.getTranslationSync(this.language, key, params);
+        });
+    }
+    init() {
+        this.initPromise = this.initPromise || this.parseTemplates(this.config.resolve("templatesDir"), []);
+        return this.initPromise;
+    }
+    async parseTemplates(dir, dirPath) {
+        return new Promise(resolve => {
+            readdir(dir, async (err, files) => {
+                for (let file of files) {
+                    const path = join(dir, file);
+                    if (lstatSync(path).isDirectory()) {
+                        await this.parseTemplates(join(dir, file), dirPath.concat([file]));
+                        continue;
+                    }
+                    const parts = file.split(".");
+                    parts.pop();
+                    const name = parts.join(".");
+                    const fullName = dirPath.concat([name]).join("-");
+                    const content = readFileSync(path).toString("utf8");
+                    this.templates[fullName] = Handlebars.compile(content);
+                    Handlebars.registerPartial(fullName, content);
+                }
+                resolve();
+            });
+        });
+    }
+    async render(template, language, context) {
+        await this.init();
+        await this.translator.getDictionary(language);
+        if (!this.templates[template]) {
+            return Promise.reject(`Template not found with name: ${template}`);
+        }
+        context = Object.assign({ language }, context || {});
+        const res = this.templates[template](context);
+        return res instanceof Error ? await Promise.reject(res) : res;
+    }
+};
+TemplateRenderer = __decorate([
+    singleton()
+], TemplateRenderer);
+export { TemplateRenderer };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/terminal-manager.mjs

@@ -0,0 +1,77 @@
+import { __decorate, __param } from "tslib";
+import { injectAll, singleton } from "tsyringe";
+import { CommandsAddon } from "@stemy/terminal-commands-addon";
+import { TERMINAL_COMMAND } from "../common-types";
+import { camelCaseToDash, colorize, ConsoleColor } from "../utils";
+let TerminalManager = class TerminalManager {
+    constructor(logger, config, commands) {
+        this.logger = logger;
+        this.config = config;
+        this.servicePassword = config.resolve("servicePassword");
+        this.suggestions = {
+            login: async (args) => {
+                if (args.length > 2) {
+                    return null;
+                }
+                const input = `${args.at(1).label}`;
+                return (!input) ? [] : [{
+                        id: input,
+                        label: input,
+                        masked: true
+                    }];
+            },
+            ...commands.reduce((acc, command) => {
+                command.name = camelCaseToDash(command.name || command.constructor.name || "");
+                if (!command.name || !command.suggest)
+                    return acc;
+                acc[command.name] = async (a, t) => command.suggest(a, t);
+                return acc;
+            }, {})
+        };
+        this.commands = commands.reduce((acc, command) => {
+            if (!command.name)
+                return acc;
+            acc[command.name] = async (a, t) => command.execute(a, t);
+            return acc;
+        }, {});
+        this.loggedOutCommands = ["login", "clear"];
+        this.loggedInCommands = Object.keys(this.commands);
+        this.loggedInCommands.push("logout");
+        console.log(`Current service password is: ${colorize(this.servicePassword, ConsoleColor.FgGreen)}`);
+    }
+    loadAddons(terminal) {
+        let loggedIn = false;
+        const addon = new CommandsAddon({
+            commands: {
+                login: async (args, terminal) => {
+                    if (args.at(1).label === this.servicePassword) {
+                        loggedIn = true;
+                        terminal.writeln("Logged in as admin");
+                    }
+                    else {
+                        throw new Error("Invalid login");
+                    }
+                },
+                logout: async (args, terminal) => {
+                    loggedIn = false;
+                    terminal.writeln("Logged out");
+                },
+                ...this.commands
+            },
+            suggestCommands: async () => {
+                if (loggedIn) {
+                    return this.loggedInCommands;
+                }
+                return this.loggedOutCommands;
+            },
+            suggestions: this.suggestions
+        });
+        terminal.loadAddon(addon);
+    }
+};
+TerminalManager = __decorate([
+    singleton(),
+    __param(2, injectAll(TERMINAL_COMMAND))
+], TerminalManager);
+export { TerminalManager };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"terminal-manager.js","sourceRoot":"","sources":["../../../src/services/terminal-manager.ts"],"names":[],"mappings":"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","sourcesContent":["import {injectAll, singleton} from \"tsyringe\";\r\nimport {CommandsAddon, ICommandMap, ISuggestionMap} from \"@stemy/terminal-commands-addon\";\r\nimport {ITerminal, ITerminalCommand, TERMINAL_COMMAND} from \"../common-types\";\r\nimport {Logger} from \"./logger\";\r\nimport {Configuration} from \"./configuration\";\r\nimport {camelCaseToDash, colorize, ConsoleColor} from \"../utils\";\r\n\r\n@singleton()\r\nexport class TerminalManager {\r\n    protected servicePassword: string;\r\n    protected suggestions: ISuggestionMap;\r\n    protected commands: ICommandMap;\r\n    protected loggedOutCommands: string[];\r\n    protected loggedInCommands: string[];\r\n\r\n    constructor(protected logger: Logger,\r\n                protected config: Configuration,\r\n                @injectAll(TERMINAL_COMMAND) commands: ITerminalCommand[]) {\r\n        this.servicePassword = config.resolve(\"servicePassword\");\r\n        this.suggestions = {\r\n            login: async (args) => {\r\n                if (args.length > 2) {\r\n                    return null;\r\n                }\r\n                const input = `${args.at(1).label}`;\r\n                return (!input) ? [] : [{\r\n                    id: input,\r\n                    label: input,\r\n                    masked: true\r\n                }];\r\n            },\r\n            ...commands.reduce((acc, command) => {\r\n                command.name = camelCaseToDash(command.name || command.constructor.name || \"\");\r\n                if (!command.name || !command.suggest) return acc;\r\n                acc[command.name] = async (a, t) => command.suggest(a, t);\r\n                return acc;\r\n            }, {})\r\n        };\r\n        this.commands = commands.reduce((acc, command) => {\r\n            if (!command.name) return acc;\r\n            acc[command.name] = async (a, t) => command.execute(a, t);\r\n            return acc;\r\n        }, {});\r\n        this.loggedOutCommands = [\"login\", \"clear\"];\r\n        this.loggedInCommands = Object.keys(this.commands);\r\n        this.loggedInCommands.push(\"logout\");\r\n        console.log(`Current service password is: ${colorize(this.servicePassword, ConsoleColor.FgGreen)}`);\r\n    }\r\n\r\n    loadAddons(terminal: ITerminal): void {\r\n        let loggedIn = false;\r\n        const addon = new CommandsAddon({\r\n            commands: {\r\n                login: async (args, terminal) => {\r\n                    if (args.at(1).label === this.servicePassword) {\r\n                        loggedIn = true;\r\n                        terminal.writeln(\"Logged in as admin\");\r\n                    } else {\r\n                        throw new Error(\"Invalid login\");\r\n                    }\r\n                },\r\n                logout: async (args, terminal) => {\r\n                    loggedIn = false;\r\n                    terminal.writeln(\"Logged out\");\r\n                },\r\n                ...this.commands\r\n            },\r\n            suggestCommands: async () => {\r\n                if (loggedIn) {\r\n                    return this.loggedInCommands;\r\n                }\r\n                return this.loggedOutCommands;\r\n            },\r\n            suggestions: this.suggestions\r\n        });\r\n        terminal.loadAddon(addon);\r\n    }\r\n}\r\n"]}

package/esm2020/services/token-generator.mjs

@@ -0,0 +1,35 @@
+import { __decorate } from "tslib";
+import { singleton } from "tsyringe";
+import { rand } from "../utils";
+let TokenGenerator = class TokenGenerator {
+    constructor() {
+        this.chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    }
+    async generate(checkCb) {
+        let token = null;
+        let tries = 0;
+        let notGood = true;
+        while (notGood && tries < 5) {
+            token = this.generateToken();
+            notGood = await checkCb(token);
+            tries++;
+        }
+        if (notGood) {
+            throw new Error(`Couldn't generate an unique token..`);
+        }
+        return token;
+    }
+    generateToken() {
+        let s = "";
+        for (let i = 0; i < 15; i++) {
+            const ix = rand(0, this.chars.length - 1);
+            s += this.chars[ix];
+        }
+        return s;
+    }
+};
+TokenGenerator = __decorate([
+    singleton()
+], TokenGenerator);
+export { TokenGenerator };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/translation-provider.mjs

@@ -0,0 +1,34 @@
+import { __decorate } from "tslib";
+import { singleton } from "tsyringe";
+import axios from "axios";
+import { isObject } from "../utils";
+let TranslationProvider = class TranslationProvider {
+    constructor(config, cache) {
+        this.config = config;
+        this.cache = cache;
+    }
+    getDictionary(language) {
+        return this.cache.getOrSet(`translations-${language}`, async () => {
+            try {
+                const url = this.config.resolve("translationsTemplate")
+                    .replace(`__lang__`, language)
+                    .replace(`[lang]`, language);
+                const data = await axios.get(url).then(t => t.data);
+                if (isObject(data[language])) {
+                    return data[language];
+                }
+                return data;
+            }
+            catch (e) {
+                return {
+                    message: `${e}`
+                };
+            }
+        }, 5 * 60);
+    }
+};
+TranslationProvider = __decorate([
+    singleton()
+], TranslationProvider);
+export { TranslationProvider };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/translator.mjs

@@ -0,0 +1,63 @@
+import { __decorate } from "tslib";
+import { injectable, singleton } from "tsyringe";
+import { getValue, isDefined, isString } from "../utils";
+let Translator = class Translator {
+    constructor(translationProvider) {
+        this.translationProvider = translationProvider;
+        this.dictionaries = {};
+    }
+    async getDictionary(language) {
+        this.dictionaries[language] = await this.translationProvider.getDictionary(language);
+        return this.dictionaries[language];
+    }
+    getTranslationSync(language, key, params) {
+        if (!isString(key) || !key.length) {
+            throw new Error(`Parameter "key" required`);
+        }
+        const dictionary = this.dictionaries[language];
+        const translation = getValue(dictionary, key, key) || key;
+        return this.interpolate(translation, params);
+    }
+    getTranslation(language, key, params) {
+        if (!isString(key) || !key.length) {
+            throw new Error(`Parameter "key" required`);
+        }
+        return this.getDictionary(language).then(dictionary => {
+            const translation = getValue(dictionary, key, key) || key;
+            return this.interpolate(translation, params);
+        });
+    }
+    getTranslations(language, ...keys) {
+        return new Promise(resolve => {
+            Promise.all(keys.map(key => this.getTranslation(language, key))).then(translations => {
+                resolve(keys.reduce((result, key, i) => {
+                    result[key] = translations[i];
+                    return result;
+                }, {}));
+            });
+        });
+    }
+    interpolate(expr, params) {
+        if (typeof expr === "string") {
+            return this.interpolateString(expr, params);
+        }
+        if (typeof expr === "function") {
+            return expr(params);
+        }
+        return expr;
+    }
+    interpolateString(expr, params) {
+        if (!expr || !params)
+            return expr;
+        return expr.replace(/{{\s?([^{}\s]*)\s?}}/g, (substring, b) => {
+            const r = getValue(params, b);
+            return isDefined(r) ? r : substring;
+        });
+    }
+};
+Translator = __decorate([
+    injectable(),
+    singleton()
+], Translator);
+export { Translator };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/user-manager.mjs

@@ -0,0 +1,27 @@
+import { __decorate } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+const sampleUser = {
+    id: "5a3cdf7c6a9cf0ba32feccdf",
+    email: "admin@site.com",
+    password: "",
+    roles: ["admin"]
+};
+let UserManager = class UserManager {
+    async getByCredentials(credentials) {
+        return (sampleUser.email == credentials.email) ? sampleUser : await Promise.reject("message.login.error");
+    }
+    async getById(id) {
+        return (sampleUser.id == id) ? sampleUser : null;
+    }
+    async serialize(user) {
+        const res = Object.assign({}, user);
+        delete res.password;
+        return res;
+    }
+};
+UserManager = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], UserManager);
+export { UserManager };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/socket-controllers/progress.controller.mjs

@@ -0,0 +1,52 @@
+import { __decorate, __param } from "tslib";
+import { inject, singleton } from "tsyringe";
+import { ConnectedSocket, MessageBody, OnMessage, SocketController, } from "socket-controllers";
+import { SOCKET_SERVER } from "../common-types";
+import { broadcast } from "../utils";
+let ProgressController = class ProgressController {
+    constructor(progresses, socketServer) {
+        this.progresses = progresses;
+        this.socketServer = socketServer;
+    }
+    async advanceProgress(client, progressId) {
+        const progress = await this.progresses.get(progressId);
+        if (!progress)
+            return;
+        const json = progress.toJSON();
+        broadcast(this.socketServer, c => {
+            if (c.interestedProgresses instanceof Set && c.interestedProgresses.has(progressId)) {
+                client.emit("background-progress-changed", json);
+            }
+        });
+        console.log(`progress changed: ${client.id}, data: ${JSON.stringify(json)}`);
+    }
+    async setProgressInterest(client, progressId) {
+        const progress = await this.progresses.get(progressId);
+        if (!progress)
+            return;
+        const json = progress.toJSON();
+        client.interestedProgresses = client.interestedProgresses || new Set();
+        if (client.interestedProgresses.has(progressId))
+            return;
+        client.interestedProgresses.add(progressId);
+        client.emit("background-progress-changed", json);
+        console.log(`progress interest added: ${client.id}, data: ${JSON.stringify(json)}`);
+    }
+};
+__decorate([
+    OnMessage("background-progress"),
+    __param(0, ConnectedSocket()),
+    __param(1, MessageBody())
+], ProgressController.prototype, "advanceProgress", null);
+__decorate([
+    OnMessage("background-progress-interest"),
+    __param(0, ConnectedSocket()),
+    __param(1, MessageBody())
+], ProgressController.prototype, "setProgressInterest", null);
+ProgressController = __decorate([
+    singleton(),
+    SocketController(),
+    __param(1, inject(SOCKET_SERVER))
+], ProgressController);
+export { ProgressController };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,48 @@
+import { __decorate, __param } from "tslib";
+import { singleton } from "tsyringe";
+import { ConnectedSocket, MessageBody, OnMessage, SocketController } from "socket-controllers";
+import { Terminal } from "./terminal";
+let TerminalController = class TerminalController {
+    constructor(manager) {
+        this.manager = manager;
+        this.terminals = {};
+    }
+    async terminalInit(client) {
+        const terminal = new Terminal(client);
+        this.manager.loadAddons(terminal);
+        this.terminals[client.id] = terminal;
+        client.on("disconnect", () => terminal.dispose());
+    }
+    async terminalData(client, data) {
+        const terminal = this.terminals[client.id];
+        if (!terminal)
+            return;
+        terminal.input(data);
+    }
+    async terminalUpload(client, upload) {
+        const terminal = this.terminals[client.id];
+        if (!terminal || !upload)
+            return;
+        terminal.addFile(upload);
+    }
+};
+__decorate([
+    OnMessage("terminal-init"),
+    __param(0, ConnectedSocket())
+], TerminalController.prototype, "terminalInit", null);
+__decorate([
+    OnMessage("terminal-data"),
+    __param(0, ConnectedSocket()),
+    __param(1, MessageBody())
+], TerminalController.prototype, "terminalData", null);
+__decorate([
+    OnMessage("terminal-upload"),
+    __param(0, ConnectedSocket()),
+    __param(1, MessageBody())
+], TerminalController.prototype, "terminalUpload", null);
+TerminalController = __decorate([
+    singleton(),
+    SocketController()
+], TerminalController);
+export { TerminalController };
+//# sourceMappingURL=data:application/json;base64,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