@stemy/backend 5.2.2 → 6.0.0

package/esm2022/services/job-manager.mjs

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

package/esm2022/services/lazy-assets.mjs

@@ -0,0 +1,68 @@
+import { __decorate, __metadata } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+import { ObjectId } from "bson";
+import { MongoConnector } from "./mongo-connector";
+import { Assets } from "./assets";
+import { LazyAsset } from "./entities/lazy-asset";
+import { JobManager } from "./job-manager";
+import { Logger } from "./logger";
+import { Progresses } from "./progresses";
+import { gzipPromised } from '../utils';
+let LazyAssets = class LazyAssets {
+    connector;
+    assets;
+    progresses;
+    logger;
+    jobMan;
+    collection;
+    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, jobParamsObj = {}, jobQue = "main") {
+        const jobName = this.jobMan.tryResolve(jobType, { ...jobParamsObj, lazyId: "" });
+        const jobParams = await gzipPromised(JSON.stringify(jobParamsObj));
+        const data = {
+            jobName,
+            jobParams,
+            jobQue,
+        };
+        const existingAsset = await this.find(data);
+        if (existingAsset)
+            return existingAsset;
+        data.createdAt = new Date();
+        data.updatedAt = data.createdAt;
+        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),
+    __metadata("design:paramtypes", [MongoConnector,
+        Assets,
+        Progresses,
+        Logger,
+        JobManager])
+], LazyAssets);
+export { LazyAssets };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/logger.mjs

@@ -0,0 +1,26 @@
+import { __decorate, __metadata } from "tslib";
+import { singleton } from "tsyringe";
+import { Configuration } from "./configuration";
+let Logger = class Logger {
+    config;
+    tags;
+    ignoredTags;
+    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(),
+    __metadata("design:paramtypes", [Configuration])
+], Logger);
+export { Logger };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NlcnZpY2VzL2xvZ2dlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLFVBQVUsQ0FBQztBQUNuQyxPQUFPLEVBQUMsYUFBYSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFHdkMsSUFBTSxNQUFNLEdBQVosTUFBTSxNQUFNO0lBS007SUFIWCxJQUFJLENBQVc7SUFDZixXQUFXLENBQVc7SUFFaEMsWUFBcUIsTUFBcUI7UUFBckIsV0FBTSxHQUFOLE1BQU0sQ0FBZTtRQUN0QyxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQzNDLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztJQUM3RCxDQUFDO0lBRUQsR0FBRyxDQUFDLEdBQVcsRUFBRSxHQUFHLE1BQWE7UUFDN0IsSUFBSSxJQUFJLENBQUMsV0FBVyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUM7WUFBRSxPQUFPO1FBQzNDLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLEtBQUssQ0FBQyxJQUFJLElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDcEQsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLEdBQUcsR0FBRyxFQUFFLEdBQUcsTUFBTSxDQUFDLENBQUM7UUFDdkMsQ0FBQztJQUNMLENBQUM7Q0FDSixDQUFBO0FBaEJZLE1BQU07SUFEbEIsU0FBUyxFQUFFO3FDQU1xQixhQUFhO0dBTGpDLE1BQU0sQ0FnQmxCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtzaW5nbGV0b259IGZyb20gXCJ0c3lyaW5nZVwiO1xyXG5pbXBvcnQge0NvbmZpZ3VyYXRpb259IGZyb20gXCIuL2NvbmZpZ3VyYXRpb25cIjtcclxuXHJcbkBzaW5nbGV0b24oKVxyXG5leHBvcnQgY2xhc3MgTG9nZ2VyIHtcclxuXHJcbiAgICBwcm90ZWN0ZWQgdGFnczogc3RyaW5nW107XHJcbiAgICBwcm90ZWN0ZWQgaWdub3JlZFRhZ3M6IHN0cmluZ1tdO1xyXG5cclxuICAgIGNvbnN0cnVjdG9yKHJlYWRvbmx5IGNvbmZpZzogQ29uZmlndXJhdGlvbikge1xyXG4gICAgICAgIHRoaXMudGFncyA9IHRoaXMuY29uZmlnLnJlc29sdmUoXCJsb2dUYWdzXCIpO1xyXG4gICAgICAgIHRoaXMuaWdub3JlZFRhZ3MgPSB0aGlzLmNvbmZpZy5yZXNvbHZlKFwiaWdub3JlZExvZ1RhZ3NcIik7XHJcbiAgICB9XHJcblxyXG4gICAgbG9nKHRhZzogc3RyaW5nLCAuLi5wYXJhbXM6IGFueVtdKTogdm9pZCB7XHJcbiAgICAgICAgaWYgKHRoaXMuaWdub3JlZFRhZ3MuaW5jbHVkZXModGFnKSkgcmV0dXJuO1xyXG4gICAgICAgIGlmICh0aGlzLnRhZ3MubGVuZ3RoID09PSAwIHx8IHRoaXMudGFncy5pbmNsdWRlcyh0YWcpKSB7XHJcbiAgICAgICAgICAgIGNvbnNvbGUubG9nKGBbJHt0YWd9XWAsIC4uLnBhcmFtcyk7XHJcbiAgICAgICAgfVxyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2022/services/mail-sender.mjs

@@ -0,0 +1,42 @@
+import { __decorate, __metadata } from "tslib";
+import { singleton } from "tsyringe";
+import { createTransport } from "nodemailer";
+import { TemplateRenderer } from "./template-renderer";
+import { Configuration } from "./configuration";
+let MailSender = class MailSender {
+    config;
+    renderer;
+    transporter;
+    get translator() {
+        return this.renderer.translator;
+    }
+    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"),
+            }
+        });
+    }
+    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(),
+    __metadata("design:paramtypes", [Configuration, TemplateRenderer])
+], MailSender);
+export { MailSender };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/memory-cache.mjs

@@ -0,0 +1,61 @@
+import { __decorate, __metadata } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+import { Cache } from "./cache";
+let MemoryCache = class MemoryCache {
+    cache;
+    cacheMap;
+    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),
+    __metadata("design:paramtypes", [Cache])
+], MemoryCache);
+export { MemoryCache };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/mongo-connector.mjs

@@ -0,0 +1,36 @@
+import { __decorate, __metadata } from "tslib";
+import { singleton } from "tsyringe";
+import mongoose from "mongoose";
+import { Configuration } from "./configuration";
+let MongoConnector = class MongoConnector {
+    configuration;
+    get connection() {
+        return this.conn;
+    }
+    get database() {
+        return this.db;
+    }
+    conn;
+    db;
+    constructor(configuration) {
+        this.configuration = configuration;
+        this.conn = null;
+        this.db = null;
+    }
+    async connect() {
+        if (this.db)
+            return this.db;
+        this.conn = (await mongoose.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;
+    }
+};
+MongoConnector = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Configuration])
+], MongoConnector);
+export { MongoConnector };
+//# sourceMappingURL=data:application/json;base64,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