@stemy/backend 3.5.16 → 4.0.0

package/esm2020/services/open-api.mjs

@@ -0,0 +1,114 @@
+import { __decorate, __param } from "tslib";
+import { inject, singleton } from "tsyringe";
+import { getMetadataArgsStorage } from "routing-controllers";
+import { routingControllersToSpec } from "routing-controllers-openapi";
+import { validationMetadatasToSchemas } from "class-validator-jsonschema";
+import { ValidationTypes } from "class-validator";
+import { isDefined, isFunction, isObject } from "../utils";
+import { IsFile, IsObjectId } from "../validators";
+import { DI_CONTAINER, OPENAPI_VALIDATION } from "../common-types";
+let OpenApi = class OpenApi {
+    constructor(container, customValidation) {
+        this.container = container;
+        this.customValidation = customValidation;
+        this.docs = null;
+    }
+    get apiDocs() {
+        if (!this.docs)
+            this.docs = this.createApiDocs();
+        return this.docs;
+    }
+    get apiDocsStr() {
+        if (!this.docsStr)
+            this.docsStr = JSON.stringify(this.apiDocs);
+        return this.docsStr;
+    }
+    async schemaToExample(src, req) {
+        if (src.$ref) {
+            const schemas = this.apiDocs.components.schemas;
+            const schema = src.$ref
+                .replace("#/components/schemas/", "")
+                .replace("#/definitions/", "");
+            return this.schemaToExample(schemas[schema], req);
+        }
+        let schema = src;
+        if (schema.oneOf) {
+            schema = Object.assign({}, schema, schema.oneOf[0]);
+        }
+        if (schema.type === "object") {
+            const result = {};
+            await Promise.all(Object.keys(schema.properties).map(async (key) => {
+                result[key] = await this.schemaToExample(schema.properties[key], req);
+            }));
+            return result;
+        }
+        if (schema.type === "array") {
+            return [await this.schemaToExample(schema.items, req)];
+        }
+        if (schema.type === "string") {
+            if (isDefined(schema.default)) {
+                if (isFunction(schema.default)) {
+                    return schema.default(this.container);
+                }
+                return schema.default;
+            }
+            if (schema.format == "date") {
+                return new Date().toISOString().substr(0, 10);
+            }
+            if (schema.format == "date-time") {
+                return new Date().toISOString();
+            }
+            if (schema.enum) {
+                return schema.enum[0];
+            }
+            return "string";
+        }
+        if (schema.type === "number") {
+            return schema.default ?? 0;
+        }
+        else if (schema.type === "boolean") {
+            return schema.default ?? false;
+        }
+        else {
+            return schema.default ?? null;
+        }
+    }
+    createApiDocs() {
+        const storage = getMetadataArgsStorage();
+        const docs = routingControllersToSpec(storage);
+        docs.basePath = "/api/";
+        docs.definitions = validationMetadatasToSchemas({
+            additionalConverters: {
+                [ValidationTypes.CUSTOM_VALIDATION]: (meta, options) => {
+                    const res = isFunction(this.customValidation) ? this.customValidation(meta, options) : this.customValidation;
+                    if (isObject(res))
+                        return res;
+                    const constraints = meta.constraints || [];
+                    if (meta.constraintCls === IsFile) {
+                        return {
+                            multi: constraints[0] || false,
+                            type: "file"
+                        };
+                    }
+                    if (meta.constraintCls === IsObjectId) {
+                        return {
+                            endpoint: constraints[0] || false,
+                            multi: constraints[1] || false,
+                            type: "list"
+                        };
+                    }
+                    return null;
+                }
+            }
+        });
+        docs.components.schemas = docs.definitions;
+        return docs;
+    }
+};
+OpenApi = __decorate([
+    singleton(),
+    __param(0, inject(DI_CONTAINER)),
+    __param(1, inject(OPENAPI_VALIDATION))
+], OpenApi);
+export { OpenApi };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"open-api.js","sourceRoot":"","sources":["../../../src/services/open-api.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,MAAM,EAAE,SAAS,EAAC,MAAM,UAAU,CAAC;AAE3C,OAAO,EAAC,sBAAsB,EAAC,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAC,wBAAwB,EAAC,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAC,4BAA4B,EAAC,MAAM,4BAA4B,CAAC;AACxE,OAAO,EAAC,eAAe,EAAC,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAC,MAAM,UAAU,CAAC;AACzD,OAAO,EAAC,MAAM,EAAE,UAAU,EAAC,MAAM,eAAe,CAAC;AACjD,OAAO,EAAC,YAAY,EAAkC,kBAAkB,EAAoB,MAAM,iBAAiB,CAAC;AAG7G,IAAM,OAAO,GAAb,MAAM,OAAO;IAehB,YAA4C,SAA+B,EACzB,gBAAmC;QADzC,cAAS,GAAT,SAAS,CAAsB;QACzB,qBAAgB,GAAhB,gBAAgB,CAAmB;QACjF,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACrB,CAAC;IAbD,IAAI,OAAO;QACP,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QACjD,OAAO,IAAI,CAAC,IAAI,CAAC;IACrB,CAAC;IAED,IAAI,UAAU;QACV,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC/D,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAOD,KAAK,CAAC,eAAe,CAAC,GAAmC,EAAE,GAAc;QACrE,IAAI,GAAG,CAAC,IAAI,EAAE;YACV,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC;YAChD,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI;iBAClB,OAAO,CAAC,uBAAuB,EAAE,EAAE,CAAC;iBACpC,OAAO,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC;YACnC,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC;SACrD;QACD,IAAI,MAAM,GAAG,GAAmB,CAAC;QACjC,IAAI,MAAM,CAAC,KAAK,EAAE;YACd,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;SACvD;QACD,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE;YAC1B,MAAM,MAAM,GAAG,EAAE,CAAC;YAClB,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,KAAK,EAAC,GAAG,EAAC,EAAE;gBAC7D,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;YAC1E,CAAC,CAAC,CAAC,CAAC;YACJ,OAAO,MAAM,CAAC;SACjB;QACD,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,EAAE;YACzB,OAAO,CAAC,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;SAC1D;QACD,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE;YAC1B,IAAI,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;gBAC3B,IAAI,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;oBAC5B,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;iBACzC;gBACD,OAAO,MAAM,CAAC,OAAO,CAAC;aACzB;YACD,IAAI,MAAM,CAAC,MAAM,IAAI,MAAM,EAAE;gBACzB,OAAO,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;aACjD;YACD,IAAI,MAAM,CAAC,MAAM,IAAI,WAAW,EAAE;gBAC9B,OAAO,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;aACnC;YACD,IAAI,MAAM,CAAC,IAAI,EAAE;gBACb,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACzB;YACD,OAAO,QAAQ,CAAC;SACnB;QACD,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE;YAC1B,OAAO,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC;SAC9B;aAAM,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE;YAClC,OAAO,MAAM,CAAC,OAAO,IAAI,KAAK,CAAC;SAClC;aAAM;YACH,OAAO,MAAM,CAAC,OAAO,IAAI,IAAI,CAAC;SACjC;IACL,CAAC;IAES,aAAa;QACnB,MAAM,OAAO,GAAG,sBAAsB,EAAE,CAAC;QACzC,MAAM,IAAI,GAAG,wBAAwB,CAAC,OAAO,CAAC,CAAC;QAC/C,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,IAAI,CAAC,WAAW,GAAG,4BAA4B,CAAC;YAC5C,oBAAoB,EAAE;gBAClB,CAAC,eAAe,CAAC,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE;oBACnD,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC;oBAC7G,IAAI,QAAQ,CAAC,GAAG,CAAC;wBAAE,OAAO,GAAG,CAAC;oBAC9B,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,IAAI,EAAE,CAAC;oBAC3C,IAAI,IAAI,CAAC,aAAa,KAAK,MAAM,EAAE;wBAC/B,OAAO;4BACH,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,IAAI,KAAK;4BAC9B,IAAI,EAAE,MAAM;yBACR,CAAC;qBACZ;oBACD,IAAI,IAAI,CAAC,aAAa,KAAK,UAAU,EAAE;wBACnC,OAAO;4BACH,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,IAAI,KAAK;4BACjC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,IAAI,KAAK;4BAC9B,IAAI,EAAE,MAAM;yBACR,CAAC;qBACZ;oBACD,OAAO,IAAI,CAAC;gBAChB,CAAC;aACJ;SACJ,CAAC,CAAC;QACH,IAAI,CAAC,UAAU,CAAC,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC;QAC3C,OAAO,IAAI,CAAC;IAChB,CAAC;CACJ,CAAA;AAnGY,OAAO;IADnB,SAAS,EAAE;IAgBK,WAAA,MAAM,CAAC,YAAY,CAAC,CAAA;IACpB,WAAA,MAAM,CAAC,kBAAkB,CAAC,CAAA;GAhB9B,OAAO,CAmGnB;SAnGY,OAAO","sourcesContent":["import {inject, singleton} from \"tsyringe\";\r\nimport {OpenAPIObject, ReferenceObject, SchemaObject} from \"openapi3-ts\";\r\nimport {getMetadataArgsStorage} from \"routing-controllers\";\r\nimport {routingControllersToSpec} from \"routing-controllers-openapi\";\r\nimport {validationMetadatasToSchemas} from \"class-validator-jsonschema\";\r\nimport {ValidationTypes} from \"class-validator\";\r\nimport {isDefined, isFunction, isObject} from \"../utils\";\r\nimport {IsFile, IsObjectId} from \"../validators\";\r\nimport {DI_CONTAINER, IDependencyContainer, IRequest, OPENAPI_VALIDATION, OpenApiValidation} from \"../common-types\";\r\n\r\n@singleton()\r\nexport class OpenApi {\r\n\r\n    protected docs: OpenAPIObject;\r\n    protected docsStr: string;\r\n\r\n    get apiDocs(): OpenAPIObject {\r\n        if (!this.docs) this.docs = this.createApiDocs();\r\n        return this.docs;\r\n    }\r\n\r\n    get apiDocsStr(): string {\r\n        if (!this.docsStr) this.docsStr = JSON.stringify(this.apiDocs);\r\n        return this.docsStr;\r\n    }\r\n\r\n    constructor(@inject(DI_CONTAINER) protected container: IDependencyContainer,\r\n                @inject(OPENAPI_VALIDATION) protected customValidation: OpenApiValidation) {\r\n        this.docs = null;\r\n    }\r\n\r\n    async schemaToExample(src: ReferenceObject | SchemaObject, req?: IRequest): Promise<any> {\r\n        if (src.$ref) {\r\n            const schemas = this.apiDocs.components.schemas;\r\n            const schema = src.$ref\r\n                .replace(\"#/components/schemas/\", \"\")\r\n                .replace(\"#/definitions/\", \"\");\r\n            return this.schemaToExample(schemas[schema], req);\r\n        }\r\n        let schema = src as SchemaObject;\r\n        if (schema.oneOf) {\r\n            schema = Object.assign({}, schema, schema.oneOf[0]);\r\n        }\r\n        if (schema.type === \"object\") {\r\n            const result = {};\r\n            await Promise.all(Object.keys(schema.properties).map(async key => {\r\n                result[key] = await this.schemaToExample(schema.properties[key], req);\r\n            }));\r\n            return result;\r\n        }\r\n        if (schema.type === \"array\") {\r\n            return [await this.schemaToExample(schema.items, req)];\r\n        }\r\n        if (schema.type === \"string\") {\r\n            if (isDefined(schema.default)) {\r\n                if (isFunction(schema.default)) {\r\n                    return schema.default(this.container);\r\n                }\r\n                return schema.default;\r\n            }\r\n            if (schema.format == \"date\") {\r\n                return new Date().toISOString().substr(0, 10);\r\n            }\r\n            if (schema.format == \"date-time\") {\r\n                return new Date().toISOString();\r\n            }\r\n            if (schema.enum) {\r\n                return schema.enum[0];\r\n            }\r\n            return \"string\";\r\n        }\r\n        if (schema.type === \"number\") {\r\n            return schema.default ?? 0;\r\n        } else if (schema.type === \"boolean\") {\r\n            return schema.default ?? false;\r\n        } else {\r\n            return schema.default ?? null;\r\n        }\r\n    }\r\n\r\n    protected createApiDocs(): OpenAPIObject {\r\n        const storage = getMetadataArgsStorage();\r\n        const docs = routingControllersToSpec(storage);\r\n        docs.basePath = \"/api/\";\r\n        docs.definitions = validationMetadatasToSchemas({\r\n            additionalConverters: {\r\n                [ValidationTypes.CUSTOM_VALIDATION]: (meta, options) => {\r\n                    const res = isFunction(this.customValidation) ? this.customValidation(meta, options) : this.customValidation;\r\n                    if (isObject(res)) return res;\r\n                    const constraints = meta.constraints || [];\r\n                    if (meta.constraintCls === IsFile) {\r\n                        return {\r\n                            multi: constraints[0] || false,\r\n                            type: \"file\"\r\n                        } as any;\r\n                    }\r\n                    if (meta.constraintCls === IsObjectId) {\r\n                        return {\r\n                            endpoint: constraints[0] || false,\r\n                            multi: constraints[1] || false,\r\n                            type: \"list\"\r\n                        } as any;\r\n                    }\r\n                    return null;\r\n                }\r\n            }\r\n        });\r\n        docs.components.schemas = docs.definitions;\r\n        return docs;\r\n    }\r\n}\r\n"]}

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":";AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,UAAU,CAAC;AACnC,OAAO,EAAC,QAAQ,EAAC,MAAM,MAAM,CAAC;AAI9B,OAAO,EAAC,cAAc,EAAC,MAAM,UAAU,CAAC;AAGxC,OAAO,EAAC,QAAQ,EAAC,MAAM,qBAAqB,CAAC;AAGtC,IAAM,UAAU,GAAhB,MAAM,UAAU;IAKnB,YAAqB,SAAyB,EAAW,MAAkB;QAAtD,cAAS,GAAT,SAAS,CAAgB;QAAW,WAAM,GAAN,MAAM,CAAY;QACvE,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;QAC9D,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;QACrB,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,kBAAkB,EAAE,QAAQ,CAAC,EAAE;YAC1C,MAAM,EAAE,GAAG,QAAQ,CAAC,EAAY,CAAC;YACjC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,GAAG,IAAI,QAAQ,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,EAAE,QAAe,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QAC3F,CAAC,CAAC,CAAC;IACP,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,EAAU;QACzB,OAAO,OAAO,CAAC,IAAI,CAAC;YAChB,IAAI,CAAC,eAAe,CAAC,EAAE,EAAE,KAAK,IAAI,EAAE;gBAChC,IAAI,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;gBACnC,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,OAAO,GAAG,GAAG,EAAE;oBACrC,QAAQ,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;iBACjC;gBACD,IAAI,CAAC,QAAQ,EAAE;oBACX,MAAM,IAAI,KAAK,CAAC,qCAAqC,EAAE,EAAE,CAAC,CAAC;iBAC9D;gBACD,OAAO,QAAQ,CAAC;YACpB,CAAC,EAAE,GAAG,CAAC;YACP,IAAI,CAAC,eAAe,CAAC,EAAE,EAAE,KAAK,IAAI,EAAE;gBAChC,OAAO,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC;YACvC,CAAC,EAAE,EAAE,CAAC;SACT,CAAC,CAAC;IACP,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,EAAU;QAChB,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAC,GAAG,EAAE,IAAI,QAAQ,CAAC,EAAE,CAAC,EAAC,CAAC,CAAC;IAC3D,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,KAA6B;QACpC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAClD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IACxE,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,MAAc,GAAG;QAC1B,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,EAAE;YACxB,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;SAClE;QACD,MAAM,IAAI,GAAG;YACT,OAAO,EAAE,CAAC;YACV,GAAG,EAAE,GAAG;YACR,OAAO,EAAE,EAAE;YACX,KAAK,EAAE,EAAE;YACT,QAAQ,EAAE,KAAK;SAClB,CAAC;QACF,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAClD,OAAO,IAAI,QAAQ,CAAC,GAAG,CAAC,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAC/D,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,EAAU;QACnB,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAC,GAAG,EAAE,IAAI,QAAQ,CAAC,EAAE,CAAC,EAAC,CAAC,CAAC;QACzD,OAAO,EAAE,CAAC;IACd,CAAC;IAES,KAAK,CAAC,eAAe,CAAC,EAAU,EAAE,EAA4B,EAAE,KAAa;QACnF,IAAI,UAAU,GAAG,KAAK,CAAC;QACvB,IAAI,QAAQ,GAAc,IAAI,CAAC;QAC/B,IAAI,QAAQ,GAAW,CAAC,CAAC;QACzB,OAAO,CAAC,UAAU,EAAE;YAChB,QAAQ,GAAG,MAAM,EAAE,EAAE,CAAC;YACtB,QAAQ,IAAI,KAAK,CAAC;YAClB,IAAI,QAAQ,EAAE;gBACV,IAAI,QAAQ,CAAC,KAAK,EAAE;oBAChB,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;iBACnC;gBACD,UAAU,GAAG,QAAQ,CAAC,OAAO,IAAI,GAAG,CAAC;aACxC;YACD,IAAI,CAAC,UAAU,EAAE;gBACb,IAAI,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE;oBACpC,MAAM,IAAI,KAAK,CAAC,qBAAqB,EAAE,mCAAmC,CAAC,CAAC;iBAC/E;gBACD,MAAM,cAAc,CAAC,KAAK,CAAC,CAAC;aAC/B;SACJ;QACD,OAAO,QAAQ,CAAC;IACpB,CAAC;CACJ,CAAA;AAnFY,UAAU;IADtB,SAAS,EAAE;GACC,UAAU,CAmFtB;SAnFY,UAAU","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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