@stemy/backend 3.6.0 → 4.0.0

package/esm2020/services/entities/lazy-asset.mjs

@@ -0,0 +1,73 @@
+import { ObjectId } from "bson";
+import { deleteFromBucket } from "../../utils";
+import { BaseEntity } from "./base-entity";
+export class LazyAsset extends BaseEntity {
+    constructor(id, data, collection, logger, assets, progresses) {
+        super(id, data, collection);
+        this.logger = logger;
+        this.assets = assets;
+        this.progresses = progresses;
+    }
+    get jobName() {
+        return this.data.jobName;
+    }
+    get jobParams() {
+        return this.data.jobParams;
+    }
+    get jobQue() {
+        return this.data.jobQue;
+    }
+    get progressId() {
+        return this.data.progressId;
+    }
+    get assetId() {
+        return this.data.assetId;
+    }
+    async unlink() {
+        await this.load();
+        if (!this.progressId) {
+            await this.collection.deleteOne({ _id: this.mId });
+        }
+        return deleteFromBucket(this.assets.bucket, new ObjectId(this.assetId));
+    }
+    startWorking() {
+        this.load().then(() => {
+            if (this.deleted)
+                return;
+            this.progresses.get(this.progressId).then(p => {
+                p?.cancel();
+            });
+            this.startWorkingOnAsset(false).then(() => {
+                this.logger.log("lazy-assets", `Started working on lazy asset: ${this.id}`);
+            }).catch(reason => {
+                this.logger.log("lazy-assets", `Can't start working on lazy asset: ${this.id}\nReason: ${reason}`);
+            });
+        });
+    }
+    async loadAsset() {
+        await this.load();
+        if (this.deleted)
+            return null;
+        if (this.assetId) {
+            return this.assets.read(this.assetId);
+        }
+        if (this.progressId) {
+            await this.progresses.waitToFinish(this.progressId);
+            return this.loadAsset();
+        }
+        await this.startWorkingOnAsset(true);
+        return this.loadAsset();
+    }
+    async writeAsset(asset) {
+        this.data.assetId = asset.id;
+        await this.save();
+        return asset;
+    }
+    async startWorkingOnAsset(fromLoad) {
+        this.data.progressId = (await this.progresses.create()).id;
+        this.data.assetId = null;
+        await this.save();
+        await this.progresses.jobMan.enqueueWithName(this.data.jobName, { ...this.data.jobParams, lazyId: this.id, fromLoad });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/entities/progress.mjs

@@ -0,0 +1,176 @@
+import { BaseEntity } from "./base-entity";
+export class Progress extends BaseEntity {
+    constructor(id, data, collection) {
+        super(id, data, collection);
+    }
+    get current() {
+        return this.data.current;
+    }
+    get max() {
+        return this.data.max;
+    }
+    get message() {
+        return this.data.message;
+    }
+    get error() {
+        return this.data.error;
+    }
+    get canceled() {
+        return this.data.canceled;
+    }
+    get percent() {
+        return this.max > 0 ? Math.round(this.current / this.max * 100) : 0;
+    }
+    get remaining() {
+        return this.max > 0 ? this.max - this.current : 0;
+    }
+    setMessageBridge(messageBridge) {
+        this.messageBridge = messageBridge || this.messageBridge;
+        return this;
+    }
+    async createSubProgress(progressValue, max, message) {
+        if (max <= 0 && progressValue > 0) {
+            await this.advance(progressValue);
+        }
+        if (message !== null) {
+            this.data.message = message;
+            await this.save();
+        }
+        return new SubProgress(this, this.current, progressValue, Math.max(max, 1));
+    }
+    async setMax(max) {
+        if (isNaN(max) || max <= 0) {
+            throw "Max progress value must be bigger than zero";
+        }
+        this.data.max = max;
+        await this.save();
+    }
+    async setMessage(message) {
+        this.data.message = message;
+        await this.save();
+    }
+    async setError(error) {
+        this.data.error = error;
+        await this.save();
+    }
+    async advance(value = 1) {
+        if (isNaN(value) || value <= 0) {
+            throw new Error(`Advance value must be bigger than zero: ${this.id}`);
+        }
+        await this.load();
+        if (this.deleted || this.canceled) {
+            const status = this.deleted ? "deleted" : "canceled";
+            throw new Error(`Can't advance ${status} progress: ${this.id}`);
+        }
+        this.data.current = Math.min(this.max, this.current + value);
+        await this.save();
+    }
+    async cancel() {
+        this.data.canceled = true;
+        await this.save();
+    }
+    save() {
+        if (this.messageBridge) {
+            this.messageBridge.sendMessage(`progress-changed`, this.toJSON());
+        }
+        return super.save();
+    }
+}
+export class SubProgress {
+    constructor(parent, progressFrom, progressValue, mMax = 100) {
+        this.parent = parent;
+        this.progressFrom = progressFrom;
+        this.progressValue = progressValue;
+        this.mMax = mMax;
+        if (progressFrom < 0) {
+            throw "Progress from must be bigger than or zero";
+        }
+        if (progressValue <= 0) {
+            throw "Progress value must be bigger than zero";
+        }
+        this.mCurrent = 0;
+    }
+    get id() {
+        return this.parent.id;
+    }
+    get current() {
+        return this.mCurrent;
+    }
+    get max() {
+        return this.mMax;
+    }
+    get message() {
+        return this.parent.message;
+    }
+    get error() {
+        return this.parent.error;
+    }
+    get percent() {
+        return this.parent.percent;
+    }
+    get remaining() {
+        return this.max - this.mCurrent;
+    }
+    get canceled() {
+        return !this.parent || this.parent.canceled;
+    }
+    setMessageBridge(messageBridge) {
+        if (!this.parent)
+            return this;
+        this.parent.setMessageBridge(messageBridge);
+        return this;
+    }
+    async createSubProgress(progressValue, max, message) {
+        if (max <= 0 && progressValue > 0) {
+            await this.advance(progressValue);
+        }
+        if (message !== null) {
+            await this.setMessage(message);
+        }
+        return new SubProgress(this, this.current, progressValue, Math.max(max, 1));
+    }
+    async setMax(max) {
+        if (isNaN(max) || max <= 0) {
+            throw "Max progress value must be bigger than zero";
+        }
+        this.mMax = max;
+        await this.save();
+    }
+    async setMessage(message) {
+        if (!this.parent)
+            return null;
+        await this.parent.setMessage(message);
+    }
+    async setError(error) {
+        if (!this.parent)
+            return null;
+        await this.parent.setError(error);
+    }
+    async advance(value = 1) {
+        if (isNaN(value) || value <= 0) {
+            throw "Advance value must be bigger than zero";
+        }
+        this.mCurrent = Math.min(this.max, this.mCurrent + value);
+        await this.save();
+    }
+    async cancel() {
+        if (!this.parent)
+            return null;
+        await this.parent.cancel();
+    }
+    async save() {
+        const ratio = this.max > 0 ? this.mCurrent / this.max : 0;
+        const newProgress = this.progressFrom + Math.round(this.progressValue * ratio);
+        const current = this.parent.current;
+        if (newProgress <= current)
+            return null;
+        await this.parent.advance(newProgress);
+    }
+    async load() {
+        return null;
+    }
+    toJSON() {
+        return this.parent.toJSON();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"progress.js","sourceRoot":"","sources":["../../../../src/services/entities/progress.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAEzC,MAAM,OAAO,QAAS,SAAQ,UAAqB;IAgC/C,YAAY,EAAY,EACZ,IAAwB,EACxB,UAAsB;QAC9B,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;IAChC,CAAC;IAhCD,IAAI,OAAO;QACP,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;IAC7B,CAAC;IAED,IAAI,GAAG;QACH,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;IACzB,CAAC;IAED,IAAI,OAAO;QACP,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;IAC7B,CAAC;IAED,IAAI,KAAK;QACL,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;IAC3B,CAAC;IAED,IAAI,QAAQ;QACR,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;IAC9B,CAAC;IAED,IAAI,OAAO;QACP,OAAO,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACxE,CAAC;IAED,IAAI,SAAS;QACT,OAAO,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IACtD,CAAC;IAQD,gBAAgB,CAAC,aAA6B;QAC1C,IAAI,CAAC,aAAa,GAAG,aAAa,IAAI,IAAI,CAAC,aAAa,CAAC;QACzD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,KAAK,CAAC,iBAAiB,CAAC,aAAqB,EAAE,GAAY,EAAE,OAAgB;QACzE,IAAI,GAAG,IAAI,CAAC,IAAI,aAAa,GAAG,CAAC,EAAE;YAC/B,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;SACrC;QACD,IAAI,OAAO,KAAK,IAAI,EAAE;YAClB,IAAI,CAAC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;YAC5B,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;SACrB;QACD,OAAO,IAAI,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;IAChF,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,GAAW;QACpB,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,EAAE;YACxB,MAAM,6CAA6C,CAAC;SACvD;QACD,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACpB,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;IACtB,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,OAAe;QAC5B,IAAI,CAAC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QAC5B,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;IACtB,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,KAAa;QACxB,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACxB,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;IACtB,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,QAAgB,CAAC;QAC3B,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,EAAE;YAC5B,MAAM,IAAI,KAAK,CAAC,2CAA2C,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;SACzE;QACD,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE;YAC/B,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC;YACrD,MAAM,IAAI,KAAK,CAAC,iBAAiB,MAAM,cAAc,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;SACnE;QACD,IAAI,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,CAAC;QAC7D,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;IACtB,CAAC;IAED,KAAK,CAAC,MAAM;QACR,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QAC1B,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;IACtB,CAAC;IAED,IAAI;QACA,IAAI,IAAI,CAAC,aAAa,EAAE;YACpB,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,kBAAkB,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;SACrE;QACD,OAAO,KAAK,CAAC,IAAI,EAAE,CAAC;IACxB,CAAC;CACJ;AAED,MAAM,OAAO,WAAW;IAoCpB,YAAsB,MAAiB,EAAY,YAAoB,EAAY,aAAqB,EAAY,OAAe,GAAG;QAAhH,WAAM,GAAN,MAAM,CAAW;QAAY,iBAAY,GAAZ,YAAY,CAAQ;QAAY,kBAAa,GAAb,aAAa,CAAQ;QAAY,SAAI,GAAJ,IAAI,CAAc;QAClI,IAAI,YAAY,GAAG,CAAC,EAAE;YAClB,MAAM,2CAA2C,CAAC;SACrD;QACD,IAAI,aAAa,IAAI,CAAC,EAAE;YACpB,MAAM,yCAAyC,CAAC;SACnD;QACD,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;IACtB,CAAC;IA1CD,IAAI,EAAE;QACF,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;IAC1B,CAAC;IAED,IAAI,OAAO;QACP,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IAED,IAAI,GAAG;QACH,OAAO,IAAI,CAAC,IAAI,CAAC;IACrB,CAAC;IAED,IAAI,OAAO;QACP,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;IAC/B,CAAC;IAED,IAAI,KAAK;QACL,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;IAC7B,CAAC;IAED,IAAI,OAAO;QACP,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;IAC/B,CAAC;IAED,IAAI,SAAS;QACT,OAAO,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC;IACpC,CAAC;IAED,IAAI,QAAQ;QACR,OAAO,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;IAChD,CAAC;IAcD,gBAAgB,CAAC,aAA6B;QAC1C,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC;QAC9B,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;QAC5C,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,KAAK,CAAC,iBAAiB,CAAC,aAAqB,EAAE,GAAY,EAAE,OAAgB;QACzE,IAAI,GAAG,IAAI,CAAC,IAAI,aAAa,GAAG,CAAC,EAAE;YAC/B,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;SACrC;QACD,IAAI,OAAO,KAAK,IAAI,EAAE;YAClB,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;SAClC;QACD,OAAO,IAAI,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;IAChF,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,GAAW;QACpB,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,EAAE;YACxB,MAAM,6CAA6C,CAAC;SACvD;QACD,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAChB,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;IACtB,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,OAAe;QAC5B,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC;QAC9B,MAAM,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC1C,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,KAAa;QACxB,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC;QAC9B,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,QAAgB,CAAC;QAC3B,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,EAAE;YAC5B,MAAM,wCAAwC,CAAC;SAClD;QACD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,CAAC;QAC1D,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;IACtB,CAAC;IAED,KAAK,CAAC,MAAM;QACR,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC;QAC9B,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;IAC/B,CAAC;IAED,KAAK,CAAC,IAAI;QACN,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1D,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,CAAC;QAC/E,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;QACpC,IAAI,WAAW,IAAI,OAAO;YAAE,OAAO,IAAI,CAAC;QACxC,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAA;IAC1C,CAAC;IAED,KAAK,CAAC,IAAI;QACN,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,MAAM;QACF,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;IAChC,CAAC;CACJ","sourcesContent":["import {ObjectId} from \"bson\";\r\nimport {Collection} from \"mongodb\";\r\nimport {IMessageBridge, IProgress} from \"../../common-types\";\r\nimport {BaseEntity} from \"./base-entity\";\r\n\r\nexport class Progress extends BaseEntity<IProgress> implements IProgress {\r\n\r\n    protected messageBridge: IMessageBridge;\r\n\r\n    get current(): number {\r\n        return this.data.current;\r\n    }\r\n\r\n    get max(): number {\r\n        return this.data.max;\r\n    }\r\n\r\n    get message(): string {\r\n        return this.data.message;\r\n    }\r\n\r\n    get error(): string {\r\n        return this.data.error;\r\n    }\r\n\r\n    get canceled(): boolean {\r\n        return this.data.canceled;\r\n    }\r\n\r\n    get percent(): number {\r\n        return this.max > 0 ? Math.round(this.current / this.max * 100) : 0;\r\n    }\r\n\r\n    get remaining(): number {\r\n        return this.max > 0 ? this.max - this.current : 0;\r\n    }\r\n\r\n    constructor(id: ObjectId,\r\n                data: Partial<IProgress>,\r\n                collection: Collection) {\r\n        super(id, data, collection);\r\n    }\r\n\r\n    setMessageBridge(messageBridge: IMessageBridge): this {\r\n        this.messageBridge = messageBridge || this.messageBridge;\r\n        return this;\r\n    }\r\n\r\n    async createSubProgress(progressValue: number, max?: number, message?: string): Promise<IProgress> {\r\n        if (max <= 0 && progressValue > 0) {\r\n            await this.advance(progressValue);\r\n        }\r\n        if (message !== null) {\r\n            this.data.message = message;\r\n            await this.save();\r\n        }\r\n        return new SubProgress(this, this.current, progressValue, Math.max(max, 1));\r\n    }\r\n\r\n    async setMax(max: number): Promise<any> {\r\n        if (isNaN(max) || max <= 0) {\r\n            throw \"Max progress value must be bigger than zero\";\r\n        }\r\n        this.data.max = max;\r\n        await this.save();\r\n    }\r\n\r\n    async setMessage(message: string): Promise<any> {\r\n        this.data.message = message;\r\n        await this.save();\r\n    }\r\n\r\n    async setError(error: string): Promise<any> {\r\n        this.data.error = error;\r\n        await this.save();\r\n    }\r\n\r\n    async advance(value: number = 1): Promise<any> {\r\n        if (isNaN(value) || value <= 0) {\r\n            throw new Error(`Advance value must be bigger than zero: ${this.id}`);\r\n        }\r\n        await this.load();\r\n        if (this.deleted || this.canceled) {\r\n            const status = this.deleted ? \"deleted\" : \"canceled\";\r\n            throw new Error(`Can't advance ${status} progress: ${this.id}`);\r\n        }\r\n        this.data.current = Math.min(this.max, this.current + value);\r\n        await this.save();\r\n    }\r\n\r\n    async cancel(): Promise<any> {\r\n        this.data.canceled = true;\r\n        await this.save();\r\n    }\r\n\r\n    save(): Promise<any> {\r\n        if (this.messageBridge) {\r\n            this.messageBridge.sendMessage(`progress-changed`, this.toJSON());\r\n        }\r\n        return super.save();\r\n    }\r\n}\r\n\r\nexport class SubProgress implements IProgress {\r\n\r\n    get id(): string {\r\n        return this.parent.id;\r\n    }\r\n\r\n    get current(): number {\r\n        return this.mCurrent;\r\n    }\r\n\r\n    get max(): number {\r\n        return this.mMax;\r\n    }\r\n\r\n    get message(): string {\r\n        return this.parent.message;\r\n    }\r\n\r\n    get error(): string {\r\n        return this.parent.error;\r\n    }\r\n\r\n    get percent(): number {\r\n        return this.parent.percent;\r\n    }\r\n\r\n    get remaining(): number {\r\n        return this.max - this.mCurrent;\r\n    }\r\n\r\n    get canceled(): boolean {\r\n        return !this.parent || this.parent.canceled;\r\n    }\r\n\r\n    protected mCurrent: number;\r\n\r\n    constructor(protected parent: IProgress, protected progressFrom: number, protected progressValue: number, protected mMax: number = 100) {\r\n        if (progressFrom < 0) {\r\n            throw \"Progress from must be bigger than or zero\";\r\n        }\r\n        if (progressValue <= 0) {\r\n            throw \"Progress value must be bigger than zero\";\r\n        }\r\n        this.mCurrent = 0;\r\n    }\r\n\r\n    setMessageBridge(messageBridge: IMessageBridge): this {\r\n        if (!this.parent) return this;\r\n        this.parent.setMessageBridge(messageBridge);\r\n        return this;\r\n    }\r\n\r\n    async createSubProgress(progressValue: number, max?: number, message?: string): Promise<IProgress> {\r\n        if (max <= 0 && progressValue > 0) {\r\n            await this.advance(progressValue);\r\n        }\r\n        if (message !== null) {\r\n            await this.setMessage(message);\r\n        }\r\n        return new SubProgress(this, this.current, progressValue, Math.max(max, 1));\r\n    }\r\n\r\n    async setMax(max: number): Promise<any> {\r\n        if (isNaN(max) || max <= 0) {\r\n            throw \"Max progress value must be bigger than zero\";\r\n        }\r\n        this.mMax = max;\r\n        await this.save();\r\n    }\r\n\r\n    async setMessage(message: string): Promise<any> {\r\n        if (!this.parent) return null;\r\n        await this.parent.setMessage(message);\r\n    }\r\n\r\n    async setError(error: string): Promise<any> {\r\n        if (!this.parent) return null;\r\n        await this.parent.setError(error);\r\n    }\r\n\r\n    async advance(value: number = 1): Promise<any> {\r\n        if (isNaN(value) || value <= 0) {\r\n            throw \"Advance value must be bigger than zero\";\r\n        }\r\n        this.mCurrent = Math.min(this.max, this.mCurrent + value);\r\n        await this.save();\r\n    }\r\n\r\n    async cancel(): Promise<any> {\r\n        if (!this.parent) return null;\r\n        await this.parent.cancel();\r\n    }\r\n\r\n    async save(): Promise<any> {\r\n        const ratio = this.max > 0 ? this.mCurrent / this.max : 0;\r\n        const newProgress = this.progressFrom + Math.round(this.progressValue * ratio);\r\n        const current = this.parent.current;\r\n        if (newProgress <= current) return null;\r\n        await this.parent.advance(newProgress)\r\n    }\r\n\r\n    async load(): Promise<any> {\r\n        return null;\r\n    }\r\n\r\n    toJSON(): any {\r\n        return this.parent.toJSON();\r\n    }\r\n}\r\n"]}

package/esm2020/services/entities/temp-asset.mjs

@@ -0,0 +1,45 @@
+import { ObjectId } from "bson";
+import { bufferToStream, toImage } from "../../utils";
+export class TempAsset {
+    constructor(buffer, filename, contentType, metadata) {
+        this.buffer = buffer;
+        this.filename = filename;
+        this.contentType = contentType;
+        this.metadata = metadata;
+        this.id = new ObjectId().toHexString();
+    }
+    get stream() {
+        return bufferToStream(this.buffer);
+    }
+    async unlink() {
+        throw new Error(`Temp asset '${this.id}' can not be removed!`);
+    }
+    async getBuffer() {
+        return this.buffer;
+    }
+    async download(metadata) {
+        return this.stream;
+    }
+    downloadImage(params, metadata) {
+        Object.assign(this.metadata, metadata || {});
+        return toImage(this.stream, params, this.metadata);
+    }
+    getImage(params) {
+        return this.downloadImage(params);
+    }
+    async save() {
+        return this;
+    }
+    async load() {
+        return this;
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            filename: this.filename,
+            contentType: this.contentType,
+            metadata: this.metadata
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/fixtures.mjs

@@ -0,0 +1,26 @@
+import { __decorate, __param } from "tslib";
+import { injectable, injectAll, Lifecycle, scoped } from "tsyringe";
+import { FIXTURE } from "../common-types";
+let Fixtures = class Fixtures {
+    constructor(fixtures) {
+        this.fixtures = fixtures;
+    }
+    async load(output) {
+        if (!this.fixtures)
+            return;
+        output = output || {
+            write: console.log,
+            writeln: t => console.log(t + "\n")
+        };
+        for (let fixture of this.fixtures) {
+            await fixture.load(output);
+        }
+    }
+};
+Fixtures = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __param(0, injectAll(FIXTURE))
+], Fixtures);
+export { Fixtures };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZml4dHVyZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmljZXMvZml4dHVyZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUMsTUFBTSxVQUFVLENBQUM7QUFDbEUsT0FBTyxFQUFDLE9BQU8sRUFBMkIsTUFBTSxpQkFBaUIsQ0FBQztBQUkzRCxJQUFNLFFBQVEsR0FBZCxNQUFNLFFBQVE7SUFFakIsWUFBMEMsUUFBb0I7UUFBcEIsYUFBUSxHQUFSLFFBQVEsQ0FBWTtJQUU5RCxDQUFDO0lBRUQsS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFzQjtRQUM3QixJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVE7WUFBRSxPQUFPO1FBQzNCLE1BQU0sR0FBRyxNQUFNLElBQUk7WUFDZixLQUFLLEVBQUUsT0FBTyxDQUFDLEdBQUc7WUFDbEIsT0FBTyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsSUFBSSxDQUFDO1NBQ3RDLENBQUM7UUFDRixLQUFLLElBQUksT0FBTyxJQUFJLElBQUksQ0FBQyxRQUFRLEVBQUU7WUFDL0IsTUFBTSxPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1NBQzlCO0lBQ0wsQ0FBQztDQUNKLENBQUE7QUFoQlksUUFBUTtJQUZwQixVQUFVLEVBQUU7SUFDWixNQUFNLENBQUMsU0FBUyxDQUFDLGVBQWUsQ0FBQztJQUdqQixXQUFBLFNBQVMsQ0FBQyxPQUFPLENBQUMsQ0FBQTtHQUZ0QixRQUFRLENBZ0JwQjtTQWhCWSxRQUFRIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtpbmplY3RhYmxlLCBpbmplY3RBbGwsIExpZmVjeWNsZSwgc2NvcGVkfSBmcm9tIFwidHN5cmluZ2VcIjtcclxuaW1wb3J0IHtGSVhUVVJFLCBJRml4dHVyZSwgSUZpeHR1cmVPdXRwdXR9IGZyb20gXCIuLi9jb21tb24tdHlwZXNcIjtcclxuXHJcbkBpbmplY3RhYmxlKClcclxuQHNjb3BlZChMaWZlY3ljbGUuQ29udGFpbmVyU2NvcGVkKVxyXG5leHBvcnQgY2xhc3MgRml4dHVyZXMge1xyXG5cclxuICAgIGNvbnN0cnVjdG9yKEBpbmplY3RBbGwoRklYVFVSRSkgcHJvdGVjdGVkIGZpeHR1cmVzOiBJRml4dHVyZVtdKSB7XHJcblxyXG4gICAgfVxyXG5cclxuICAgIGFzeW5jIGxvYWQob3V0cHV0OiBJRml4dHVyZU91dHB1dCk6IFByb21pc2U8YW55PiB7XHJcbiAgICAgICAgaWYgKCF0aGlzLmZpeHR1cmVzKSByZXR1cm47XHJcbiAgICAgICAgb3V0cHV0ID0gb3V0cHV0IHx8IHtcclxuICAgICAgICAgICAgd3JpdGU6IGNvbnNvbGUubG9nLFxyXG4gICAgICAgICAgICB3cml0ZWxuOiB0ID0+IGNvbnNvbGUubG9nKHQgKyBcIlxcblwiKVxyXG4gICAgICAgIH07XHJcbiAgICAgICAgZm9yIChsZXQgZml4dHVyZSBvZiB0aGlzLmZpeHR1cmVzKSB7XHJcbiAgICAgICAgICAgIGF3YWl0IGZpeHR1cmUubG9hZChvdXRwdXQpO1xyXG4gICAgICAgIH1cclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2020/services/gallery-cache.mjs

@@ -0,0 +1,27 @@
+import { __decorate } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+import { GalleryImage } from "./gallery-image";
+let GalleryCache = class GalleryCache {
+    constructor() {
+        this.imgCache = {};
+    }
+    put(img) {
+        this.imgCache[img.thumb] = img;
+        this.imgCache[img.big] = img;
+    }
+    serve(id) {
+        const img = this.imgCache[id];
+        return !img ? null : img.serve(id);
+    }
+    create(folder, targetSize, handler) {
+        const image = new GalleryImage(folder, targetSize, handler);
+        this.put(image);
+        return image;
+    }
+};
+GalleryCache = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], GalleryCache);
+export { GalleryCache };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/gallery-image.mjs

@@ -0,0 +1,37 @@
+import { v4 as uuidv4 } from "uuid";
+import sharp_ from "sharp";
+const sharp = sharp_;
+const bigSize = 1500;
+const thumbSize = 250;
+export class GalleryImage {
+    constructor(folder, size, handler) {
+        this.folder = folder;
+        this.handler = handler;
+        this.thumb = uuidv4();
+        this.big = uuidv4();
+        this.targetSize = !size ? { width: thumbSize, height: thumbSize } : size;
+    }
+    async serve(id) {
+        const isThumb = id == this.thumb;
+        if (await this.handler.hasResult(isThumb)) {
+            return this.handler.serveResult(isThumb);
+        }
+        const original = sharp(await this.handler.getOriginal()).rotate();
+        const meta = await original.metadata();
+        const ratio = meta.width / meta.height;
+        const sizeRatio = isThumb ? this.targetSize.width / this.targetSize.height : 1;
+        const size = isThumb ? Math.max(this.targetSize.width, this.targetSize.height) : bigSize;
+        const targetHeight = ratio > sizeRatio ? size : Math.round(size / ratio);
+        const targetWidth = Math.round(targetHeight * ratio);
+        const resized = original.resize(targetWidth, targetHeight);
+        const buffer = await (isThumb ? resized.extract({
+            left: Math.floor((targetWidth - this.targetSize.width) / 2),
+            top: Math.floor((targetHeight - this.targetSize.height) / 2),
+            width: this.targetSize.width,
+            height: this.targetSize.height
+        }).toBuffer() : resized.toBuffer());
+        await this.handler.writeResult(isThumb, buffer);
+        return this.handler.serveResult(isThumb);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/gallery.mjs

@@ -0,0 +1,116 @@
+import { __decorate } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+import sharp_ from "sharp";
+import { access, constants, lstat, readdir, readFile, writeFile } from "fs";
+import { join, dirname } from "path";
+import { mkdirRecursive } from "../utils";
+const sharp = sharp_;
+let Gallery = class Gallery {
+    constructor(config, galleryCache) {
+        this.config = config;
+        this.galleryCache = galleryCache;
+        this.cache = {};
+        this.dir = this.config.resolve("galleryDir");
+        this.output = join(this.config.resolve("cacheDir"), "gallery");
+    }
+    async getFolder(folder, size = null) {
+        this.cache[folder] = this.cache[folder] || new Promise(resolve => {
+            lstat(join(this.dir, folder), (err, stats) => {
+                if (err || !stats.isDirectory()) {
+                    resolve([]);
+                    return;
+                }
+                this.readRecursive(folder, "", size).then(resolve, () => resolve([]));
+            });
+        });
+        return this.cache[folder];
+    }
+    readRecursive(path, folder, size) {
+        return new Promise(resolve => {
+            readdir(join(this.dir, path), (err, files) => {
+                if (err) {
+                    resolve([]);
+                    return;
+                }
+                const promises = files.map(file => {
+                    return new Promise(async (resolve) => {
+                        const filePath = join(path, file);
+                        const absoluteFilePath = join(this.dir, filePath);
+                        lstat(absoluteFilePath, (err, stats) => {
+                            if (err) {
+                                resolve([]);
+                                return;
+                            }
+                            if (stats.isDirectory()) {
+                                this.readRecursive(filePath, join(folder, file), size).then(resolve);
+                                return;
+                            }
+                            const sharpImg = sharp(absoluteFilePath);
+                            sharpImg.rotate().metadata().then(() => {
+                                const getResultPath = (isThumb) => {
+                                    return join(this.output, filePath.replace(/.([a-z|A-Z]+)$/gi, function (ext) {
+                                        const suffix = isThumb ? 'thumb' : 'big';
+                                        return `-${suffix}${ext}`;
+                                    }));
+                                };
+                                resolve([this.galleryCache.create(folder, size, {
+                                        getOriginal: () => {
+                                            return new Promise((res, rej) => {
+                                                readFile(absoluteFilePath, (err, data) => {
+                                                    if (err) {
+                                                        rej(err);
+                                                        return;
+                                                    }
+                                                    res(data);
+                                                });
+                                            });
+                                        },
+                                        writeResult: (isThumb, buffer) => {
+                                            return new Promise(async (res, rej) => {
+                                                const resultPath = getResultPath(isThumb);
+                                                await mkdirRecursive(dirname(resultPath));
+                                                writeFile(resultPath, buffer, err => {
+                                                    if (err) {
+                                                        rej(err);
+                                                        return;
+                                                    }
+                                                    res();
+                                                });
+                                            });
+                                        },
+                                        hasResult: (isThumb) => {
+                                            return new Promise(res => {
+                                                access(getResultPath(isThumb), constants.R_OK, err => {
+                                                    res(!err);
+                                                });
+                                            });
+                                        },
+                                        serveResult: (isThumb) => {
+                                            return new Promise((res, rej) => {
+                                                readFile(getResultPath(isThumb), (err, data) => {
+                                                    if (err) {
+                                                        rej(err);
+                                                        return;
+                                                    }
+                                                    res(data);
+                                                });
+                                            });
+                                        }
+                                    })]);
+                            }, () => resolve([]));
+                        });
+                    });
+                });
+                Promise.all(promises).then(folders => {
+                    resolve([].concat.apply([], folders));
+                });
+            });
+        });
+    }
+};
+Gallery = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], Gallery);
+export { Gallery };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gallery.js","sourceRoot":"","sources":["../../../src/services/gallery.ts"],"names":[],"mappings":"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","sourcesContent":["import {injectable, Lifecycle, scoped} from \"tsyringe\";\r\nimport sharp_ from \"sharp\";\r\nimport {access, constants, lstat, readdir, readFile, writeFile} from \"fs\";\r\nimport {join, dirname} from \"path\";\r\nimport {IGalleryImage, IGallerySize} from \"../common-types\";\r\nimport {Configuration} from \"./configuration\";\r\nimport {GalleryCache} from \"./gallery-cache\";\r\nimport {mkdirRecursive} from \"../utils\";\r\n\r\nconst sharp = sharp_;\r\n\r\n@injectable()\r\n@scoped(Lifecycle.ContainerScoped)\r\nexport class Gallery {\r\n\r\n    private readonly dir: string;\r\n    private readonly output: string;\r\n    private readonly cache: { [folder: string]: Promise<IGalleryImage[]> };\r\n\r\n    constructor(readonly config: Configuration, readonly galleryCache: GalleryCache) {\r\n        this.cache = {};\r\n        this.dir = this.config.resolve(\"galleryDir\");\r\n        this.output = join(this.config.resolve(\"cacheDir\"), \"gallery\");\r\n    }\r\n\r\n    async getFolder(folder: string, size: IGallerySize = null): Promise<IGalleryImage[]> {\r\n        this.cache[folder] = this.cache[folder] || new Promise<IGalleryImage[]>(resolve => {\r\n            lstat(join(this.dir, folder), (err, stats) => {\r\n                if (err || !stats.isDirectory()) {\r\n                    resolve([]);\r\n                    return;\r\n                }\r\n                this.readRecursive(folder, \"\", size).then(resolve, () => resolve([]));\r\n            });\r\n        });\r\n        return this.cache[folder];\r\n    }\r\n\r\n    protected readRecursive(path: string, folder: string, size: IGallerySize): Promise<IGalleryImage[]> {\r\n        return new Promise<IGalleryImage[]>(resolve => {\r\n            readdir(join(this.dir, path), (err, files) => {\r\n                if (err) {\r\n                    resolve([]);\r\n                    return;\r\n                }\r\n                const promises = files.map(file => {\r\n                    return new Promise<IGalleryImage[]>(async resolve => {\r\n                        const filePath = join(path, file);\r\n                        const absoluteFilePath = join(this.dir, filePath);\r\n                        lstat(absoluteFilePath, (err, stats) => {\r\n                            if (err) {\r\n                                resolve([]);\r\n                                return;\r\n                            }\r\n                            if (stats.isDirectory()) {\r\n                                this.readRecursive(filePath, join(folder, file), size).then(resolve);\r\n                                return;\r\n                            }\r\n                            const sharpImg = sharp(absoluteFilePath);\r\n                            sharpImg.rotate().metadata().then(() => {\r\n                                const getResultPath = (isThumb) => {\r\n                                    return join(this.output, filePath.replace(/.([a-z|A-Z]+)$/gi, function (ext) {\r\n                                        const suffix = isThumb ? 'thumb' : 'big';\r\n                                        return `-${suffix}${ext}`;\r\n                                    }));\r\n                                };\r\n                                resolve([this.galleryCache.create(folder, size, {\r\n                                    getOriginal: () => {\r\n                                        return new Promise<Buffer>((res, rej) => {\r\n                                            readFile(absoluteFilePath, (err, data) => {\r\n                                                if (err) {\r\n                                                    rej(err);\r\n                                                    return;\r\n                                                }\r\n                                                res(data);\r\n                                            });\r\n                                        });\r\n                                    },\r\n                                    writeResult: (isThumb: boolean, buffer: Buffer) => {\r\n                                        return new Promise<void>(async (res, rej) => {\r\n                                            const resultPath = getResultPath(isThumb);\r\n                                            await mkdirRecursive(dirname(resultPath));\r\n                                            writeFile(resultPath, buffer, err => {\r\n                                                if (err) {\r\n                                                    rej(err);\r\n                                                    return;\r\n                                                }\r\n                                                res();\r\n                                            });\r\n                                        });\r\n                                    },\r\n                                    hasResult: (isThumb: boolean) => {\r\n                                        return new Promise<boolean>(res => {\r\n                                            access(getResultPath(isThumb), constants.R_OK, err => {\r\n                                                res(!err);\r\n                                            });\r\n                                        });\r\n                                    },\r\n                                    serveResult: (isThumb: boolean) => {\r\n                                        return new Promise<Buffer>((res, rej) => {\r\n                                            readFile(getResultPath(isThumb), (err, data) => {\r\n                                                if (err) {\r\n                                                    rej(err);\r\n                                                    return;\r\n                                                }\r\n                                                res(data);\r\n                                            });\r\n                                        });\r\n                                    }\r\n                                })]);\r\n                            }, () => resolve([]));\r\n                        });\r\n                    });\r\n                });\r\n                Promise.all(promises).then(folders => {\r\n                    resolve([].concat.apply([], folders));\r\n                });\r\n            });\r\n        });\r\n    }\r\n}\r\n"]}

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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