@stemy/backend 5.2.1 → 6.0.0

package/esm2022/services/open-api.mjs

@@ -0,0 +1,124 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { inject, singleton } from "tsyringe";
+import { getMetadataArgsStorage } from "routing-controllers";
+import { routingControllersToSpec } from "routing-controllers-openapi";
+import { defaultMetadataStorage } from "class-transformer/cjs/storage";
+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 {
+    container;
+    customValidation;
+    docs;
+    docsStr;
+    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;
+    }
+    constructor(container, customValidation) {
+        this.container = container;
+        this.customValidation = customValidation;
+        this.docs = null;
+    }
+    async schemaToExample(src, req) {
+        const maybeRef = src;
+        if (maybeRef.$ref) {
+            const schemas = this.apiDocs.components.schemas;
+            const schema = maybeRef.$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.components = {
+            ...(docs.components || {}),
+            schemas: validationMetadatasToSchemas({
+                classTransformerMetadataStorage: defaultMetadataStorage,
+                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;
+                    }
+                }
+            })
+        };
+        return docs;
+    }
+};
+OpenApi = __decorate([
+    singleton(),
+    __param(0, inject(DI_CONTAINER)),
+    __param(1, inject(OPENAPI_VALIDATION)),
+    __metadata("design:paramtypes", [Object, Object])
+], 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,sBAAsB,EAAC,MAAM,+BAA+B,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;IAe4B;IACM;IAdxC,IAAI,CAAgB;IACpB,OAAO,CAAS;IAE1B,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;IAED,YAA4C,SAA+B,EACzB,gBAAmC;QADzC,cAAS,GAAT,SAAS,CAAsB;QACzB,qBAAgB,GAAhB,gBAAgB,CAAmB;QACjF,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACrB,CAAC;IAED,KAAK,CAAC,eAAe,CAAC,GAAmC,EAAE,GAAc;QACrE,MAAM,QAAQ,GAAG,GAAsB,CAAC;QACxC,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC;YAChB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC;YAChD,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI;iBACvB,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;QACtD,CAAC;QACD,IAAI,MAAM,GAAG,GAAmB,CAAC;QACjC,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;YACf,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QACxD,CAAC;QACD,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC3B,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;QAClB,CAAC;QACD,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC1B,OAAO,CAAC,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;QAC3D,CAAC;QACD,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC3B,IAAI,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC5B,IAAI,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;oBAC7B,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;gBAC1C,CAAC;gBACD,OAAO,MAAM,CAAC,OAAO,CAAC;YAC1B,CAAC;YACD,IAAI,MAAM,CAAC,MAAM,IAAI,MAAM,EAAE,CAAC;gBAC1B,OAAO,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAClD,CAAC;YACD,IAAI,MAAM,CAAC,MAAM,IAAI,WAAW,EAAE,CAAC;gBAC/B,OAAO,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YACpC,CAAC;YACD,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;gBACd,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC1B,CAAC;YACD,OAAO,QAAQ,CAAC;QACpB,CAAC;QACD,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC3B,OAAO,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC;QAC/B,CAAC;aAAM,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YACnC,OAAO,MAAM,CAAC,OAAO,IAAI,KAAK,CAAC;QACnC,CAAC;aAAM,CAAC;YACJ,OAAO,MAAM,CAAC,OAAO,IAAI,IAAI,CAAC;QAClC,CAAC;IACL,CAAC;IAES,aAAa;QACnB,MAAM,OAAO,GAAG,sBAAsB,EAAE,CAAC;QACzC,MAAM,IAAI,GAAG,wBAAwB,CAAC,OAAO,CAAC,CAAC;QAC/C,2BAA2B;QAC3B,IAAI,CAAC,UAAU,GAAG;YACd,GAAG,CAAC,IAAI,CAAC,UAAU,IAAI,EAAE,CAAC;YAC1B,OAAO,EAAE,4BAA4B,CAAC;gBAClC,+BAA+B,EAAE,sBAAsB;gBACvD,oBAAoB,EAAE;oBAClB,CAAC,eAAe,CAAC,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE;wBACnD,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;wBAC7G,IAAI,QAAQ,CAAC,GAAG,CAAC;4BAAE,OAAO,GAAG,CAAC;wBAC9B,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,IAAI,EAAE,CAAC;wBAC3C,IAAI,IAAI,CAAC,aAAa,KAAK,MAAM,EAAE,CAAC;4BAChC,OAAO;gCACH,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,IAAI,KAAK;gCAC9B,IAAI,EAAE,MAAM;6BACR,CAAC;wBACb,CAAC;wBACD,IAAI,IAAI,CAAC,aAAa,KAAK,UAAU,EAAE,CAAC;4BACpC,OAAO;gCACH,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,IAAI,KAAK;gCACjC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,IAAI,KAAK;gCAC9B,IAAI,EAAE,MAAM;6BACR,CAAC;wBACb,CAAC;wBACD,OAAO,IAAI,CAAC;oBAChB,CAAC;iBACJ;aACJ,CAAC;SACL,CAAC;QACF,OAAO,IAAI,CAAC;IAChB,CAAC;CACJ,CAAA;AAvGY,OAAO;IADnB,SAAS,EAAE;IAgBK,WAAA,MAAM,CAAC,YAAY,CAAC,CAAA;IACpB,WAAA,MAAM,CAAC,kBAAkB,CAAC,CAAA;;GAhB9B,OAAO,CAuGnB","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 {defaultMetadataStorage} from \"class-transformer/cjs/storage\";\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        const maybeRef = src as ReferenceObject;\r\n        if (maybeRef.$ref) {\r\n            const schemas = this.apiDocs.components.schemas;\r\n            const schema = maybeRef.$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.components = {\r\n            ...(docs.components || {}),\r\n            schemas: validationMetadatasToSchemas({\r\n                classTransformerMetadataStorage: defaultMetadataStorage,\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        };\r\n        return docs;\r\n    }\r\n}\r\n"]}

package/esm2022/services/progresses.mjs

@@ -0,0 +1,93 @@
+import { __decorate, __metadata } from "tslib";
+import { singleton } from "tsyringe";
+import { ObjectId } from "bson";
+import { promiseTimeout } from "../utils";
+import { MongoConnector } from "./mongo-connector";
+import { JobManager } from "./job-manager";
+import { Progress } from "./entities/progress";
+let Progresses = class Progresses {
+    connector;
+    jobMan;
+    collection;
+    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(),
+    __metadata("design:paramtypes", [MongoConnector, JobManager])
+], 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/esm2022/services/template-renderer.mjs

@@ -0,0 +1,71 @@
+import { __decorate, __metadata } from "tslib";
+import { singleton } from "tsyringe";
+import { lstatSync, readdir, readFileSync } from "fs";
+import { join } from "path";
+import * as Handlebars from "handlebars";
+import { Translator } from "./translator";
+import { Configuration } from "./configuration";
+let TemplateRenderer = class TemplateRenderer {
+    translator;
+    config;
+    templates;
+    initPromise;
+    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(),
+    __metadata("design:paramtypes", [Translator, Configuration])
+], TemplateRenderer);
+export { TemplateRenderer };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/terminal-manager.mjs

@@ -0,0 +1,88 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { injectAll, singleton } from "tsyringe";
+import { CommandsAddon } from "@stemy/terminal-commands-addon";
+import { TERMINAL_COMMAND } from "../common-types";
+import { Logger } from "./logger";
+import { Configuration } from "./configuration";
+import { camelCaseToDash, colorize, ConsoleColor } from "../utils";
+let TerminalManager = class TerminalManager {
+    logger;
+    config;
+    servicePassword;
+    suggestions;
+    commands;
+    loggedOutCommands;
+    loggedInCommands;
+    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)),
+    __metadata("design:paramtypes", [Logger,
+        Configuration, Array])
+], 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/esm2022/services/token-generator.mjs

@@ -0,0 +1,37 @@
+import { __decorate, __metadata } from "tslib";
+import { singleton } from "tsyringe";
+import { rand } from "../utils";
+let TokenGenerator = class TokenGenerator {
+    chars;
+    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(),
+    __metadata("design:paramtypes", [])
+], TokenGenerator);
+export { TokenGenerator };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/translation-provider.mjs

@@ -0,0 +1,39 @@
+import { __decorate, __metadata } from "tslib";
+import { singleton } from "tsyringe";
+import axios from "axios";
+import { isObject } from "../utils";
+import { Configuration } from "./configuration";
+import { Cache } from "./cache";
+let TranslationProvider = class TranslationProvider {
+    config;
+    cache;
+    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(),
+    __metadata("design:paramtypes", [Configuration, Cache])
+], TranslationProvider);
+export { TranslationProvider };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/translator.mjs

@@ -0,0 +1,67 @@
+import { __decorate, __metadata } from "tslib";
+import { injectable, singleton } from "tsyringe";
+import { getValue, isDefined, isString } from "../utils";
+import { TranslationProvider } from "./translation-provider";
+let Translator = class Translator {
+    translationProvider;
+    dictionaries;
+    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(),
+    __metadata("design:paramtypes", [TranslationProvider])
+], Translator);
+export { Translator };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zZXJ2aWNlcy90cmFuc2xhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFFLFNBQVMsRUFBQyxNQUFNLFVBQVUsQ0FBQztBQUMvQyxPQUFPLEVBQUMsUUFBUSxFQUFFLFNBQVMsRUFBRSxRQUFRLEVBQUMsTUFBTSxVQUFVLENBQUM7QUFFdkQsT0FBTyxFQUFDLG1CQUFtQixFQUFDLE1BQU0sd0JBQXdCLENBQUM7QUFJcEQsSUFBTSxVQUFVLEdBQWhCLE1BQU0sVUFBVTtJQUlDO0lBRlYsWUFBWSxDQUFvQztJQUUxRCxZQUFvQixtQkFBd0M7UUFBeEMsd0JBQW1CLEdBQW5CLG1CQUFtQixDQUFxQjtRQUN4RCxJQUFJLENBQUMsWUFBWSxHQUFHLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBRUQsS0FBSyxDQUFDLGFBQWEsQ0FBQyxRQUFnQjtRQUNoQyxJQUFJLENBQUMsWUFBWSxDQUFDLFFBQVEsQ0FBQyxHQUFHLE1BQU0sSUFBSSxDQUFDLG1CQUFtQixDQUFDLGFBQWEsQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUNyRixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDdkMsQ0FBQztJQUVELGtCQUFrQixDQUFDLFFBQWdCLEVBQUUsR0FBVyxFQUFFLE1BQVk7UUFDMUQsSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUNoQyxNQUFNLElBQUksS0FBSyxDQUFDLDBCQUEwQixDQUFDLENBQUM7UUFDaEQsQ0FBQztRQUNELE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxZQUFZLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDL0MsTUFBTSxXQUFXLEdBQUcsUUFBUSxDQUFDLFVBQVUsRUFBRSxHQUFHLEVBQUUsR0FBRyxDQUFDLElBQUksR0FBRyxDQUFDO1FBQzFELE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQyxXQUFXLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDakQsQ0FBQztJQUVELGNBQWMsQ0FBQyxRQUFnQixFQUFFLEdBQVcsRUFBRSxNQUFZO1FBQ3RELElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDaEMsTUFBTSxJQUFJLEtBQUssQ0FBQywwQkFBMEIsQ0FBQyxDQUFDO1FBQ2hELENBQUM7UUFDRCxPQUFPLElBQUksQ0FBQyxhQUFhLENBQUMsUUFBUSxDQUFDLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxFQUFFO1lBQ2xELE1BQU0sV0FBVyxHQUFHLFFBQVEsQ0FBQyxVQUFVLEVBQUUsR0FBRyxFQUFFLEdBQUcsQ0FBQyxJQUFJLEdBQUcsQ0FBQztZQUMxRCxPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsV0FBVyxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBQ2pELENBQUMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQztJQUVELGVBQWUsQ0FBQyxRQUFnQixFQUFFLEdBQUcsSUFBYztRQUMvQyxPQUFPLElBQUksT0FBTyxDQUFnQixPQUFPLENBQUMsRUFBRTtZQUN4QyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLFFBQVEsRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxFQUFFO2dCQUNqRixPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLE1BQU0sRUFBRSxHQUFHLEVBQUUsQ0FBQyxFQUFFLEVBQUU7b0JBQ25DLE1BQU0sQ0FBQyxHQUFHLENBQUMsR0FBRyxZQUFZLENBQUMsQ0FBQyxDQUFDLENBQUM7b0JBQzlCLE9BQU8sTUFBTSxDQUFDO2dCQUNsQixDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQztZQUNaLENBQUMsQ0FBQyxDQUFDO1FBQ1AsQ0FBQyxDQUFDLENBQUM7SUFDUCxDQUFDO0lBRVMsV0FBVyxDQUFDLElBQXVCLEVBQUUsTUFBWTtRQUN2RCxJQUFJLE9BQU8sSUFBSSxLQUFLLFFBQVEsRUFBRSxDQUFDO1lBQzNCLE9BQU8sSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksRUFBRSxNQUFNLENBQUMsQ0FBQztRQUNoRCxDQUFDO1FBQ0QsSUFBSSxPQUFPLElBQUksS0FBSyxVQUFVLEVBQUUsQ0FBQztZQUM3QixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUN4QixDQUFDO1FBQ0QsT0FBTyxJQUFjLENBQUM7SUFDMUIsQ0FBQztJQUVTLGlCQUFpQixDQUFDLElBQVksRUFBRSxNQUFZO1FBQ2xELElBQUksQ0FBQyxJQUFJLElBQUksQ0FBQyxNQUFNO1lBQUUsT0FBTyxJQUFJLENBQUM7UUFDbEMsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLHVCQUF1QixFQUFFLENBQUMsU0FBaUIsRUFBRSxDQUFTLEVBQUUsRUFBRTtZQUMxRSxNQUFNLENBQUMsR0FBRyxRQUFRLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDO1lBQzlCLE9BQU8sU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQztRQUN4QyxDQUFDLENBQUMsQ0FBQztJQUNQLENBQUM7Q0FDSixDQUFBO0FBNURZLFVBQVU7SUFGdEIsVUFBVSxFQUFFO0lBQ1osU0FBUyxFQUFFO3FDQUtpQyxtQkFBbUI7R0FKbkQsVUFBVSxDQTREdEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2luamVjdGFibGUsIHNpbmdsZXRvbn0gZnJvbSBcInRzeXJpbmdlXCI7XHJcbmltcG9ydCB7Z2V0VmFsdWUsIGlzRGVmaW5lZCwgaXNTdHJpbmd9IGZyb20gXCIuLi91dGlsc1wiO1xyXG5pbXBvcnQge0lUcmFuc2xhdGlvbnN9IGZyb20gXCIuLi9jb21tb24tdHlwZXNcIjtcclxuaW1wb3J0IHtUcmFuc2xhdGlvblByb3ZpZGVyfSBmcm9tIFwiLi90cmFuc2xhdGlvbi1wcm92aWRlclwiO1xyXG5cclxuQGluamVjdGFibGUoKVxyXG5Ac2luZ2xldG9uKClcclxuZXhwb3J0IGNsYXNzIFRyYW5zbGF0b3Ige1xyXG5cclxuICAgIHByb3RlY3RlZCBkaWN0aW9uYXJpZXM6IHsgW2xhbmc6IHN0cmluZ106IElUcmFuc2xhdGlvbnMgfTtcclxuXHJcbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIHRyYW5zbGF0aW9uUHJvdmlkZXI6IFRyYW5zbGF0aW9uUHJvdmlkZXIpIHtcclxuICAgICAgICB0aGlzLmRpY3Rpb25hcmllcyA9IHt9O1xyXG4gICAgfVxyXG5cclxuICAgIGFzeW5jIGdldERpY3Rpb25hcnkobGFuZ3VhZ2U6IHN0cmluZyk6IFByb21pc2U8SVRyYW5zbGF0aW9ucz4ge1xyXG4gICAgICAgIHRoaXMuZGljdGlvbmFyaWVzW2xhbmd1YWdlXSA9IGF3YWl0IHRoaXMudHJhbnNsYXRpb25Qcm92aWRlci5nZXREaWN0aW9uYXJ5KGxhbmd1YWdlKTtcclxuICAgICAgICByZXR1cm4gdGhpcy5kaWN0aW9uYXJpZXNbbGFuZ3VhZ2VdO1xyXG4gICAgfVxyXG5cclxuICAgIGdldFRyYW5zbGF0aW9uU3luYyhsYW5ndWFnZTogc3RyaW5nLCBrZXk6IHN0cmluZywgcGFyYW1zPzogYW55KTogc3RyaW5nIHtcclxuICAgICAgICBpZiAoIWlzU3RyaW5nKGtleSkgfHwgIWtleS5sZW5ndGgpIHtcclxuICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBQYXJhbWV0ZXIgXCJrZXlcIiByZXF1aXJlZGApO1xyXG4gICAgICAgIH1cclxuICAgICAgICBjb25zdCBkaWN0aW9uYXJ5ID0gdGhpcy5kaWN0aW9uYXJpZXNbbGFuZ3VhZ2VdO1xyXG4gICAgICAgIGNvbnN0IHRyYW5zbGF0aW9uID0gZ2V0VmFsdWUoZGljdGlvbmFyeSwga2V5LCBrZXkpIHx8IGtleTtcclxuICAgICAgICByZXR1cm4gdGhpcy5pbnRlcnBvbGF0ZSh0cmFuc2xhdGlvbiwgcGFyYW1zKTtcclxuICAgIH1cclxuXHJcbiAgICBnZXRUcmFuc2xhdGlvbihsYW5ndWFnZTogc3RyaW5nLCBrZXk6IHN0cmluZywgcGFyYW1zPzogYW55KTogUHJvbWlzZTxzdHJpbmc+IHtcclxuICAgICAgICBpZiAoIWlzU3RyaW5nKGtleSkgfHwgIWtleS5sZW5ndGgpIHtcclxuICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBQYXJhbWV0ZXIgXCJrZXlcIiByZXF1aXJlZGApO1xyXG4gICAgICAgIH1cclxuICAgICAgICByZXR1cm4gdGhpcy5nZXREaWN0aW9uYXJ5KGxhbmd1YWdlKS50aGVuKGRpY3Rpb25hcnkgPT4ge1xyXG4gICAgICAgICAgICBjb25zdCB0cmFuc2xhdGlvbiA9IGdldFZhbHVlKGRpY3Rpb25hcnksIGtleSwga2V5KSB8fCBrZXk7XHJcbiAgICAgICAgICAgIHJldHVybiB0aGlzLmludGVycG9sYXRlKHRyYW5zbGF0aW9uLCBwYXJhbXMpO1xyXG4gICAgICAgIH0pO1xyXG4gICAgfVxyXG5cclxuICAgIGdldFRyYW5zbGF0aW9ucyhsYW5ndWFnZTogc3RyaW5nLCAuLi5rZXlzOiBzdHJpbmdbXSk6IFByb21pc2U8SVRyYW5zbGF0aW9ucz4ge1xyXG4gICAgICAgIHJldHVybiBuZXcgUHJvbWlzZTxJVHJhbnNsYXRpb25zPihyZXNvbHZlID0+IHtcclxuICAgICAgICAgICAgUHJvbWlzZS5hbGwoa2V5cy5tYXAoa2V5ID0+IHRoaXMuZ2V0VHJhbnNsYXRpb24obGFuZ3VhZ2UsIGtleSkpKS50aGVuKHRyYW5zbGF0aW9ucyA9PiB7XHJcbiAgICAgICAgICAgICAgICByZXNvbHZlKGtleXMucmVkdWNlKChyZXN1bHQsIGtleSwgaSkgPT4ge1xyXG4gICAgICAgICAgICAgICAgICAgIHJlc3VsdFtrZXldID0gdHJhbnNsYXRpb25zW2ldO1xyXG4gICAgICAgICAgICAgICAgICAgIHJldHVybiByZXN1bHQ7XHJcbiAgICAgICAgICAgICAgICB9LCB7fSkpO1xyXG4gICAgICAgICAgICB9KTtcclxuICAgICAgICB9KTtcclxuICAgIH1cclxuXHJcbiAgICBwcm90ZWN0ZWQgaW50ZXJwb2xhdGUoZXhwcjogc3RyaW5nIHwgRnVuY3Rpb24sIHBhcmFtcz86IGFueSk6IHN0cmluZyB7XHJcbiAgICAgICAgaWYgKHR5cGVvZiBleHByID09PSBcInN0cmluZ1wiKSB7XHJcbiAgICAgICAgICAgIHJldHVybiB0aGlzLmludGVycG9sYXRlU3RyaW5nKGV4cHIsIHBhcmFtcyk7XHJcbiAgICAgICAgfVxyXG4gICAgICAgIGlmICh0eXBlb2YgZXhwciA9PT0gXCJmdW5jdGlvblwiKSB7XHJcbiAgICAgICAgICAgIHJldHVybiBleHByKHBhcmFtcyk7XHJcbiAgICAgICAgfVxyXG4gICAgICAgIHJldHVybiBleHByIGFzIHN0cmluZztcclxuICAgIH1cclxuXHJcbiAgICBwcm90ZWN0ZWQgaW50ZXJwb2xhdGVTdHJpbmcoZXhwcjogc3RyaW5nLCBwYXJhbXM/OiBhbnkpIHtcclxuICAgICAgICBpZiAoIWV4cHIgfHwgIXBhcmFtcykgcmV0dXJuIGV4cHI7XHJcbiAgICAgICAgcmV0dXJuIGV4cHIucmVwbGFjZSgve3tcXHM/KFtee31cXHNdKilcXHM/fX0vZywgKHN1YnN0cmluZzogc3RyaW5nLCBiOiBzdHJpbmcpID0+IHtcclxuICAgICAgICAgICAgY29uc3QgciA9IGdldFZhbHVlKHBhcmFtcywgYik7XHJcbiAgICAgICAgICAgIHJldHVybiBpc0RlZmluZWQocikgPyByIDogc3Vic3RyaW5nO1xyXG4gICAgICAgIH0pO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2022/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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