@stemy/backend 3.5.16 → 4.0.0

package/esm2020/services/id-generator.mjs

@@ -0,0 +1,42 @@
+import { __decorate } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+import { rand } from "../utils";
+let IdGenerator = class IdGenerator {
+    constructor(config) {
+        this.config = config;
+        this.prefix = config.resolve("idPrefix");
+        this.separator = config.resolve("idSeparator");
+        this.chars = config.resolve("idChars");
+        this.parts = config.resolve("idParts");
+    }
+    async generate(checkCb) {
+        let id = null;
+        let tries = 0;
+        let notGood = true;
+        while (notGood && tries < 5) {
+            id = this.generateId();
+            notGood = await checkCb(id);
+            tries++;
+        }
+        if (notGood) {
+            throw `Couldn't generate an unique id..`;
+        }
+        return id;
+    }
+    generateId() {
+        return this.prefix + this.parts.map(num => {
+            let s = "";
+            for (let i = 0; i < num; i++) {
+                const ix = rand(0, this.chars.length - 1);
+                s += this.chars[ix];
+            }
+            return s;
+        }).join(this.separator);
+    }
+};
+IdGenerator = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], IdGenerator);
+export { IdGenerator };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/job-manager.mjs

@@ -0,0 +1,187 @@
+import { __decorate, __param } from "tslib";
+import { inject, injectable, injectAll, Lifecycle, scoped } from "tsyringe";
+import cron from "node-cron";
+import { socket } from "zeromq";
+import { Subject } from "rxjs";
+import { filter, map } from "rxjs/operators";
+import { ObjectId } from "bson";
+import { DI_CONTAINER, JOB } from "../common-types";
+import { colorize, ConsoleColor, getConstructorName, getType, isArray, isObject, jsonHighlight, promiseTimeout } from "../utils";
+let JobManager = class JobManager {
+    constructor(config, logger, container, jobTypes) {
+        this.config = config;
+        this.logger = logger;
+        this.container = container;
+        this.jobTypes = jobTypes || [];
+        this.jobs = this.jobTypes.reduce((res, jobType) => {
+            const jobName = getConstructorName(jobType);
+            res[jobName] = (jobParams, uniqueId) => {
+                const job = this.resolveJobInstance(jobType, jobParams, uniqueId);
+                const messageBridge = {
+                    sendMessage: (message, params) => {
+                        params.uniqueId = uniqueId;
+                        this.workerPush.send([message, JSON.stringify(params)]);
+                    }
+                };
+                messageBridge.sendMessage(`job-started`, { name: jobName });
+                return job.process(messageBridge);
+            };
+            return res;
+        }, {});
+        this.messages = new Subject();
+        this.processing = false;
+        this.maxTimeout = this.config.resolve("jobTimeout");
+    }
+    on(message, cb) {
+        return this.messages
+            .pipe(filter(t => t.message === message))
+            .pipe(map(t => t.params)).subscribe(cb);
+    }
+    async process(jobType, params = {}) {
+        let instance = null;
+        try {
+            instance = this.resolveJobInstance(jobType, params);
+        }
+        catch (e) {
+            const jobName = getConstructorName(jobType);
+            throw new Error(`Can't resolve params for job: ${jobName}, with params: ${JSON.stringify(params)}. Reason: ${e}`);
+        }
+        return instance.process();
+    }
+    async enqueueWithName(name, params = {}) {
+        return this.sendToWorkers(this.tryResolveFromName(name, params), params);
+    }
+    async enqueue(jobType, params = {}) {
+        return this.sendToWorkers(this.tryResolveAndInit(jobType, params), params);
+    }
+    schedule(minute, hour, dayOfMonth, month, dayOfWeek, jobType, params = {}) {
+        const expression = [minute, hour, dayOfMonth, month, dayOfWeek].map(t => {
+            if (isObject(t)) {
+                const range = t;
+                return `${range.min || 0}-${range.max || 0}`;
+            }
+            if (isArray(t)) {
+                return t.join(",");
+            }
+            return `${t}`;
+        }).join(" ");
+        const jobName = getConstructorName(jobType);
+        if (!cron.validate(expression)) {
+            this.logger.log("job-manager", `Can't schedule the task: '${jobName}' because time expression is invalid.`);
+            return null;
+        }
+        return cron.schedule(expression, () => {
+            this.enqueue(jobType, params).catch(e => {
+                this.logger.log("job-manager", `Can't enqueue job: '${jobName}' because: ${e}`);
+            });
+        });
+    }
+    async startProcessing() {
+        if (this.processing)
+            return null;
+        this.processing = true;
+        if (!this.config.resolve("isWorker")) {
+            this.logger.log("job-manager", colorize(`Processing can not be started because this is NOT a worker process!`, ConsoleColor.FgRed));
+            return null;
+        }
+        const host = this.config.resolve("zmqRemoteHost");
+        const pushHost = `${host}:${this.config.resolve("zmqBackPort")}`;
+        this.workerPush = socket("push");
+        await this.workerPush.connect(pushHost);
+        this.logger.log("job-manager", `Worker producer connected to: ${pushHost}`);
+        const pullHost = `${host}:${this.config.resolve("zmqPort")}`;
+        this.workerPull = socket("pull");
+        await this.workerPull.connect(pullHost);
+        this.logger.log("job-manager", `Worker consumer connected to: ${pullHost}`);
+        this.workerPull.on("message", async (name, args, uniqId) => {
+            try {
+                const jobName = name.toString("utf8");
+                const jobParams = JSON.parse(args.toString("utf8"));
+                const uniqueId = uniqId?.toString("utf8");
+                console.time(uniqueId);
+                console.timeLog(uniqueId, `Started working on background job: ${colorize(jobName, ConsoleColor.FgCyan)} with args: \n${jsonHighlight(jobParams)}\n\n`);
+                try {
+                    await Promise.race([this.jobs[jobName](jobParams, uniqueId), promiseTimeout(this.maxTimeout, true)]);
+                    console.timeLog(uniqueId, `Finished working on background job: ${colorize(jobName, ConsoleColor.FgCyan)}\n\n`);
+                }
+                catch (e) {
+                    console.timeLog(uniqueId, `Background job failed: ${colorize(jobName, ConsoleColor.FgRed)}\n${e}\n\n`);
+                }
+                console.timeEnd(uniqueId);
+            }
+            catch (e) {
+                this.logger.log("job-manager", `Failed to start job: ${e.message}`);
+            }
+        });
+    }
+    tryResolve(jobType, params) {
+        const jobName = getConstructorName(jobType);
+        if (!this.jobs[jobName]) {
+            throw `Can't find job with name: ${jobName} so it can't be enqueued!`;
+        }
+        try {
+            this.resolveJobInstance(jobType, params);
+        }
+        catch (e) {
+            throw `Can't resolve params for job: ${jobName}, with params: ${JSON.stringify(params)}. Reason: ${e}`;
+        }
+        return jobName;
+    }
+    tryResolveFromName(jobName, params) {
+        const jobType = this.jobTypes.find(type => {
+            return getConstructorName(type) == jobName;
+        });
+        if (!jobType) {
+            throw `Can't find job type with name: ${jobName} so it can't be enqueued!`;
+        }
+        return this.tryResolveAndInit(jobType, params);
+    }
+    tryResolveAndInit(jobType, params) {
+        if (!this.apiPush) {
+            const port = this.config.resolve("zmqPort");
+            this.apiPush = socket("push");
+            this.apiPush.bind(`tcp://0.0.0.0:${port}`);
+            this.logger.log("job-manager", `API producer bound to port: ${port}`);
+        }
+        if (!this.apiPull) {
+            const backPort = this.config.resolve("zmqBackPort");
+            this.apiPull = socket("pull");
+            this.apiPull.bind(`tcp://0.0.0.0:${backPort}`);
+            this.apiPull.on("message", (name, args) => {
+                const message = name.toString("utf8");
+                const params = JSON.parse(args?.toString("utf8") || "{}");
+                const paramTypes = Object.keys(params).reduce((res, key) => {
+                    res[key] = getType(params[key]);
+                    return res;
+                }, {});
+                this.logger.log("job-manager", `Received a message from worker: "${colorize(message, ConsoleColor.FgCyan)}" with args: ${jsonHighlight(paramTypes)}\n\n`);
+                this.messages.next({ message, params });
+            });
+            this.logger.log("job-manager", `API consumer bound to port: ${backPort}`);
+        }
+        return this.tryResolve(jobType, params);
+    }
+    resolveJobInstance(jobType, params, uniqueId = "") {
+        const container = this.container.createChildContainer();
+        Object.keys(params).map((name) => {
+            container.register(name, { useValue: params[name] });
+        });
+        container.register("uniqueId", { useValue: uniqueId });
+        container.register(jobType, jobType);
+        return container.resolve(jobType);
+    }
+    async sendToWorkers(jobName, params) {
+        const publisher = await this.apiPush;
+        const uniqueId = new ObjectId().toHexString();
+        await publisher.send([jobName, JSON.stringify(params), uniqueId]);
+        return uniqueId;
+    }
+};
+JobManager = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __param(2, inject(DI_CONTAINER)),
+    __param(3, injectAll(JOB))
+], JobManager);
+export { JobManager };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job-manager.js","sourceRoot":"","sources":["../../../src/services/job-manager.ts"],"names":[],"mappings":"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","sourcesContent":["import {DependencyContainer, inject, injectable, injectAll, Lifecycle, scoped} from \"tsyringe\";\r\nimport cron from \"node-cron\";\r\nimport {socket, Socket} from \"zeromq\";\r\nimport {Subject, Subscription} from \"rxjs\";\r\nimport {filter, map} from \"rxjs/operators\";\r\nimport {ObjectId} from \"bson\";\r\nimport {\r\n    DI_CONTAINER,\r\n    IJob,\r\n    IJobTask,\r\n    IMessageBridge,\r\n    ISocketMessage,\r\n    JOB,\r\n    JobParams,\r\n    JobScheduleRange,\r\n    JobScheduleTime,\r\n    SocketParams,\r\n    Type\r\n} from \"../common-types\";\r\nimport {\r\n    colorize,\r\n    ConsoleColor,\r\n    getConstructorName,\r\n    getType,\r\n    isArray,\r\n    isObject,\r\n    jsonHighlight,\r\n    promiseTimeout\r\n} from \"../utils\";\r\nimport {Configuration} from \"./configuration\";\r\nimport {Logger} from \"./logger\";\r\n\r\n@injectable()\r\n@scoped(Lifecycle.ContainerScoped)\r\nexport class JobManager {\r\n\r\n    protected jobTypes: Type<IJob>[];\r\n    protected jobs: { [name: string]: (jobParams: JobParams, uniqueId: string) => Promise<any> };\r\n    protected messages: Subject<ISocketMessage>;\r\n    protected processing: boolean;\r\n\r\n    protected apiPush: Socket;\r\n    protected apiPull: Socket;\r\n    protected workerPush: Socket;\r\n    protected workerPull: Socket;\r\n\r\n    readonly maxTimeout: number;\r\n\r\n    constructor(readonly config: Configuration,\r\n                readonly logger: Logger,\r\n                @inject(DI_CONTAINER) readonly container: DependencyContainer,\r\n                @injectAll(JOB) jobTypes: Type<IJob>[]) {\r\n        this.jobTypes = jobTypes || [];\r\n        this.jobs = this.jobTypes.reduce((res, jobType) => {\r\n            const jobName = getConstructorName(jobType);\r\n            res[jobName] = (jobParams: JobParams, uniqueId: string) => {\r\n                const job = this.resolveJobInstance(jobType, jobParams, uniqueId);\r\n                const messageBridge: IMessageBridge = {\r\n                    sendMessage: (message: string, params?: SocketParams) => {\r\n                        params.uniqueId = uniqueId;\r\n                        this.workerPush.send([message, JSON.stringify(params)]);\r\n                    }\r\n                };\r\n                messageBridge.sendMessage(`job-started`, {name: jobName});\r\n                return job.process(messageBridge);\r\n            }\r\n            return res;\r\n        }, {});\r\n        this.messages = new Subject<ISocketMessage>();\r\n        this.processing = false;\r\n        this.maxTimeout = this.config.resolve(\"jobTimeout\");\r\n    }\r\n\r\n    on(message: string, cb: (params: SocketParams) => any): Subscription {\r\n        return this.messages\r\n            .pipe(filter(t => t.message === message))\r\n            .pipe(map(t => t.params)).subscribe(cb);\r\n    }\r\n\r\n    async process(jobType: Type<IJob>, params: JobParams = {}): Promise<any> {\r\n        let instance: IJob = null;\r\n        try {\r\n            instance = this.resolveJobInstance(jobType, params);\r\n        } catch (e) {\r\n            const jobName = getConstructorName(jobType);\r\n            throw new Error(`Can't resolve params for job: ${jobName}, with params: ${JSON.stringify(params)}. Reason: ${e}`);\r\n        }\r\n        return instance.process();\r\n    }\r\n\r\n    async enqueueWithName(name: string, params: JobParams = {}): Promise<string> {\r\n        return this.sendToWorkers(this.tryResolveFromName(name, params), params);\r\n    }\r\n\r\n    async enqueue(jobType: Type<IJob>, params: JobParams = {}): Promise<string> {\r\n        return this.sendToWorkers(this.tryResolveAndInit(jobType, params), params);\r\n    }\r\n\r\n    schedule(minute: JobScheduleTime, hour: JobScheduleTime, dayOfMonth: JobScheduleTime, month: JobScheduleTime, dayOfWeek: JobScheduleTime, jobType: Type<IJob>, params: JobParams = {}): IJobTask {\r\n        const expression = [minute, hour, dayOfMonth, month, dayOfWeek].map(t => {\r\n            if (isObject(t)) {\r\n                const range = t as JobScheduleRange;\r\n                return `${range.min || 0}-${range.max || 0}`;\r\n            }\r\n            if (isArray(t)) {\r\n                return t.join(\",\");\r\n            }\r\n            return `${t}`;\r\n        }).join(\" \");\r\n        const jobName = getConstructorName(jobType);\r\n        if (!cron.validate(expression)) {\r\n            this.logger.log(\"job-manager\", `Can't schedule the task: '${jobName}' because time expression is invalid.`);\r\n            return null;\r\n        }\r\n        return cron.schedule(expression, () => {\r\n            this.enqueue(jobType, params).catch(e => {\r\n                this.logger.log(\"job-manager\", `Can't enqueue job: '${jobName}' because: ${e}`);\r\n            });\r\n        });\r\n    }\r\n\r\n    async startProcessing(): Promise<any> {\r\n        if (this.processing) return null;\r\n        this.processing = true;\r\n\r\n        if (!this.config.resolve(\"isWorker\")) {\r\n            this.logger.log(\"job-manager\", colorize(`Processing can not be started because this is NOT a worker process!`, ConsoleColor.FgRed));\r\n            return null;\r\n        }\r\n\r\n        const host = this.config.resolve(\"zmqRemoteHost\");\r\n        const pushHost = `${host}:${this.config.resolve(\"zmqBackPort\")}`;\r\n        this.workerPush = socket(\"push\");\r\n        await this.workerPush.connect(pushHost);\r\n        this.logger.log(\"job-manager\", `Worker producer connected to: ${pushHost}`);\r\n\r\n        const pullHost = `${host}:${this.config.resolve(\"zmqPort\")}`;\r\n        this.workerPull = socket(\"pull\");\r\n        await this.workerPull.connect(pullHost);\r\n        this.logger.log(\"job-manager\", `Worker consumer connected to: ${pullHost}`);\r\n\r\n        this.workerPull.on(\"message\", async (name: Buffer, args: Buffer, uniqId: Buffer) => {\r\n            try {\r\n                const jobName = name.toString(\"utf8\");\r\n                const jobParams = JSON.parse(args.toString(\"utf8\")) as JobParams;\r\n                const uniqueId = uniqId?.toString(\"utf8\");\r\n\r\n                console.time(uniqueId);\r\n                console.timeLog(uniqueId, `Started working on background job: ${colorize(jobName, ConsoleColor.FgCyan)} with args: \\n${jsonHighlight(jobParams)}\\n\\n`);\r\n\r\n                try {\r\n                    await Promise.race([this.jobs[jobName](jobParams, uniqueId), promiseTimeout(this.maxTimeout, true)]);\r\n                    console.timeLog(uniqueId, `Finished working on background job: ${colorize(jobName, ConsoleColor.FgCyan)}\\n\\n`);\r\n                } catch (e) {\r\n                    console.timeLog(uniqueId, `Background job failed: ${colorize(jobName, ConsoleColor.FgRed)}\\n${e}\\n\\n`);\r\n                }\r\n                console.timeEnd(uniqueId);\r\n            } catch (e) {\r\n                this.logger.log(\"job-manager\", `Failed to start job: ${e.message}`);\r\n            }\r\n        });\r\n    }\r\n\r\n    tryResolve(jobType: Type<IJob>, params: JobParams): string {\r\n        const jobName = getConstructorName(jobType);\r\n        if (!this.jobs[jobName]) {\r\n            throw `Can't find job with name: ${jobName} so it can't be enqueued!`;\r\n        }\r\n        try {\r\n            this.resolveJobInstance(jobType, params);\r\n        } catch (e) {\r\n            throw `Can't resolve params for job: ${jobName}, with params: ${JSON.stringify(params)}. Reason: ${e}`;\r\n        }\r\n        return jobName;\r\n    }\r\n\r\n    protected tryResolveFromName(jobName: string, params: JobParams): string {\r\n        const jobType = this.jobTypes.find(type => {\r\n            return getConstructorName(type) == jobName;\r\n        });\r\n        if (!jobType) {\r\n            throw `Can't find job type with name: ${jobName} so it can't be enqueued!`;\r\n        }\r\n        return this.tryResolveAndInit(jobType, params);\r\n    }\r\n\r\n    protected tryResolveAndInit(jobType: Type<IJob>, params: JobParams): string {\r\n        if (!this.apiPush) {\r\n            const port = this.config.resolve(\"zmqPort\");\r\n            this.apiPush = socket(\"push\");\r\n            this.apiPush.bind(`tcp://0.0.0.0:${port}`);\r\n            this.logger.log(\"job-manager\", `API producer bound to port: ${port}`);\r\n        }\r\n        if (!this.apiPull) {\r\n            const backPort = this.config.resolve(\"zmqBackPort\");\r\n            this.apiPull = socket(\"pull\");\r\n            this.apiPull.bind(`tcp://0.0.0.0:${backPort}`);\r\n            this.apiPull.on(\"message\", (name: Buffer, args?: Buffer) => {\r\n                const message = name.toString(\"utf8\");\r\n                const params = JSON.parse(args?.toString(\"utf8\") || \"{}\") as JobParams;\r\n                const paramTypes = Object.keys(params).reduce((res, key) => {\r\n                    res[key] = getType(params[key]);\r\n                    return res;\r\n                }, {});\r\n                this.logger.log(\"job-manager\", `Received a message from worker: \"${colorize(message, ConsoleColor.FgCyan)}\" with args: ${jsonHighlight(paramTypes)}\\n\\n`);\r\n                this.messages.next({message, params});\r\n            });\r\n            this.logger.log(\"job-manager\", `API consumer bound to port: ${backPort}`);\r\n        }\r\n        return this.tryResolve(jobType, params);\r\n    }\r\n\r\n    protected resolveJobInstance(jobType: Type<IJob>, params: JobParams, uniqueId: string = \"\"): IJob {\r\n        const container = this.container.createChildContainer();\r\n        Object.keys(params).map((name) => {\r\n            container.register(name, {useValue: params[name]});\r\n        });\r\n        container.register(\"uniqueId\", {useValue: uniqueId});\r\n        container.register(jobType, jobType);\r\n        return container.resolve(jobType) as IJob;\r\n    }\r\n\r\n    protected async sendToWorkers(jobName: string, params: JobParams): Promise<string> {\r\n        const publisher = await this.apiPush;\r\n        const uniqueId = new ObjectId().toHexString();\r\n        await publisher.send([jobName, JSON.stringify(params), uniqueId]);\r\n        return uniqueId;\r\n    }\r\n}\r\n"]}

package/esm2020/services/lazy-assets.mjs

@@ -0,0 +1,48 @@
+import { __decorate } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+import { ObjectId } from "bson";
+import { LazyAsset } from "./entities/lazy-asset";
+let LazyAssets = class LazyAssets {
+    constructor(connector, assets, progresses, logger, jobMan) {
+        this.connector = connector;
+        this.assets = assets;
+        this.progresses = progresses;
+        this.logger = logger;
+        this.jobMan = jobMan;
+        this.collection = connector.database.collection("lazyassets");
+    }
+    async create(jobType, jobParams = {}, jobQue = "main") {
+        const jobName = this.jobMan.tryResolve(jobType, { ...jobParams, lazyId: "" });
+        const data = {
+            jobName,
+            jobParams,
+            jobQue
+        };
+        const existingAsset = await this.find(data);
+        if (existingAsset)
+            return existingAsset;
+        const res = await this.collection.insertOne(data);
+        return new LazyAsset(res.insertedId, data, this.collection, this.logger, this.assets, this.progresses);
+    }
+    async read(id) {
+        return !id ? null : this.find({ _id: new ObjectId(id) });
+    }
+    async find(where) {
+        const data = await this.collection.findOne(where);
+        return !data
+            ? null
+            : new LazyAsset(data._id, data, this.collection, this.logger, this.assets, this.progresses);
+    }
+    async unlink(id) {
+        const asset = await this.read(id);
+        if (!asset)
+            return null;
+        return asset.unlink();
+    }
+};
+LazyAssets = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], LazyAssets);
+export { LazyAssets };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/logger.mjs

@@ -0,0 +1,21 @@
+import { __decorate } from "tslib";
+import { singleton } from "tsyringe";
+let Logger = class Logger {
+    constructor(config) {
+        this.config = config;
+        this.tags = this.config.resolve("logTags");
+        this.ignoredTags = this.config.resolve("ignoredLogTags");
+    }
+    log(tag, ...params) {
+        if (this.ignoredTags.includes(tag))
+            return;
+        if (this.tags.length === 0 || this.tags.includes(tag)) {
+            console.log(`[${tag}]`, ...params);
+        }
+    }
+};
+Logger = __decorate([
+    singleton()
+], Logger);
+export { Logger };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NlcnZpY2VzL2xvZ2dlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLFVBQVUsQ0FBQztBQUk1QixJQUFNLE1BQU0sR0FBWixNQUFNLE1BQU07SUFLZixZQUFxQixNQUFxQjtRQUFyQixXQUFNLEdBQU4sTUFBTSxDQUFlO1FBQ3RDLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDM0MsSUFBSSxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0lBQzdELENBQUM7SUFFRCxHQUFHLENBQUMsR0FBVyxFQUFFLEdBQUcsTUFBYTtRQUM3QixJQUFJLElBQUksQ0FBQyxXQUFXLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQztZQUFFLE9BQU87UUFDM0MsSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sS0FBSyxDQUFDLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEVBQUU7WUFDbkQsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLEdBQUcsR0FBRyxFQUFFLEdBQUcsTUFBTSxDQUFDLENBQUM7U0FDdEM7SUFDTCxDQUFDO0NBQ0osQ0FBQTtBQWhCWSxNQUFNO0lBRGxCLFNBQVMsRUFBRTtHQUNDLE1BQU0sQ0FnQmxCO1NBaEJZLE1BQU0iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge3NpbmdsZXRvbn0gZnJvbSBcInRzeXJpbmdlXCI7XHJcbmltcG9ydCB7Q29uZmlndXJhdGlvbn0gZnJvbSBcIi4vY29uZmlndXJhdGlvblwiO1xyXG5cclxuQHNpbmdsZXRvbigpXHJcbmV4cG9ydCBjbGFzcyBMb2dnZXIge1xyXG5cclxuICAgIHByb3RlY3RlZCB0YWdzOiBzdHJpbmdbXTtcclxuICAgIHByb3RlY3RlZCBpZ25vcmVkVGFnczogc3RyaW5nW107XHJcblxyXG4gICAgY29uc3RydWN0b3IocmVhZG9ubHkgY29uZmlnOiBDb25maWd1cmF0aW9uKSB7XHJcbiAgICAgICAgdGhpcy50YWdzID0gdGhpcy5jb25maWcucmVzb2x2ZShcImxvZ1RhZ3NcIik7XHJcbiAgICAgICAgdGhpcy5pZ25vcmVkVGFncyA9IHRoaXMuY29uZmlnLnJlc29sdmUoXCJpZ25vcmVkTG9nVGFnc1wiKTtcclxuICAgIH1cclxuXHJcbiAgICBsb2codGFnOiBzdHJpbmcsIC4uLnBhcmFtczogYW55W10pOiB2b2lkIHtcclxuICAgICAgICBpZiAodGhpcy5pZ25vcmVkVGFncy5pbmNsdWRlcyh0YWcpKSByZXR1cm47XHJcbiAgICAgICAgaWYgKHRoaXMudGFncy5sZW5ndGggPT09IDAgfHwgdGhpcy50YWdzLmluY2x1ZGVzKHRhZykpIHtcclxuICAgICAgICAgICAgY29uc29sZS5sb2coYFske3RhZ31dYCwgLi4ucGFyYW1zKTtcclxuICAgICAgICB9XHJcbiAgICB9XHJcbn1cclxuIl19

package/esm2020/services/mail-sender.mjs

@@ -0,0 +1,36 @@
+import { __decorate } from "tslib";
+import { singleton } from "tsyringe";
+import { createTransport } from "nodemailer";
+let MailSender = class MailSender {
+    constructor(config, renderer) {
+        this.config = config;
+        this.renderer = renderer;
+        this.transporter = createTransport({
+            host: this.config.resolve("smtpHost"),
+            port: this.config.resolve("smtpPort"),
+            auth: {
+                user: this.config.resolve("smtpUser"),
+                pass: this.config.resolve("smtpPassword"),
+            }
+        });
+    }
+    get translator() {
+        return this.renderer.translator;
+    }
+    async sendMail(language, options) {
+        const subject = await this.translator.getTranslation(language, options.subject || "-");
+        const html = await this.renderer.render(options.template, language, options.context);
+        return this.transporter.sendMail({
+            from: options.from || this.config.resolve("mailSenderAddress"),
+            to: options.to,
+            attachments: options.attachments,
+            subject,
+            html
+        });
+    }
+};
+MailSender = __decorate([
+    singleton()
+], MailSender);
+export { MailSender };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/memory-cache.mjs

@@ -0,0 +1,57 @@
+import { __decorate } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+let MemoryCache = class MemoryCache {
+    constructor(cache) {
+        this.cache = cache;
+        this.cacheMap = new Map();
+    }
+    async set(key, value, ttl, expirationTimestamp = null, tags = {}) {
+        const now = Math.round(new Date().getTime() / 1000);
+        const expTimestamp = Math.min(isNaN(ttl) ? Number.MAX_SAFE_INTEGER : ttl, 3600);
+        this.cacheMap.set(key, {
+            _id: key,
+            data: value,
+            expirationTimestamp: expTimestamp,
+            expiresAt: now + expTimestamp,
+        });
+        return this.cache.set(key, value, ttl, expirationTimestamp, tags);
+    }
+    async get(key) {
+        let item = this.cacheMap.get(key);
+        const now = Math.round(new Date().getTime() / 1000);
+        let expTimestamp = 3600;
+        if (item && item.expiresAt && item.expiresAt < now) {
+            expTimestamp = item.expirationTimestamp;
+            item = null;
+        }
+        if (!item) {
+            const value = await this.cache.get(key);
+            this.cacheMap.set(key, {
+                _id: key,
+                data: value,
+                expirationTimestamp: expTimestamp,
+                expiresAt: now + expTimestamp,
+            });
+            return value;
+        }
+        return item.data;
+    }
+    async getOrSet(key, valueCb, ttl, expirationTimestamp = null, tags = {}) {
+        try {
+            return await this.get(key);
+        }
+        catch (e) {
+            return await this.set(key, await valueCb(), ttl, expirationTimestamp, tags);
+        }
+    }
+    async delete(key) {
+        this.cacheMap.delete(key);
+        await this.cacheMap.delete(key);
+    }
+};
+MemoryCache = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], MemoryCache);
+export { MemoryCache };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/mongo-connector.mjs

@@ -0,0 +1,37 @@
+import { __decorate } from "tslib";
+import { singleton } from "tsyringe";
+import { GridFSBucket } from "mongodb";
+import { connect } from "mongoose";
+let MongoConnector = class MongoConnector {
+    constructor(configuration) {
+        this.configuration = configuration;
+        this.conn = null;
+        this.db = null;
+        this.fsBucket = null;
+    }
+    get connection() {
+        return this.conn;
+    }
+    get database() {
+        return this.db;
+    }
+    get bucket() {
+        return this.fsBucket;
+    }
+    async connect() {
+        if (this.db)
+            return this.db;
+        this.conn = (await connect(this.configuration.resolve("mongoUri"), {
+            dbName: this.configuration.resolve("mongoDb"),
+            user: this.configuration.resolve("mongoUser"),
+            pass: this.configuration.resolve("mongoPassword")
+        })).connection;
+        this.db = this.conn.db;
+        this.fsBucket = new GridFSBucket(this.db, { bucketName: "assets" });
+    }
+};
+MongoConnector = __decorate([
+    singleton()
+], MongoConnector);
+export { MongoConnector };
+//# sourceMappingURL=data:application/json;base64,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