@stemy/backend 5.2.2 → 6.0.0

package/esm2022/services/cache.mjs

@@ -0,0 +1,70 @@
+import { __decorate, __metadata } from "tslib";
+import { singleton } from "tsyringe";
+import { MongoConnector } from "./mongo-connector";
+import { Configuration } from "./configuration";
+import { CacheProcessor } from "./cache-processor";
+let Cache = class Cache {
+    connector;
+    config;
+    cacheProcessor;
+    collection;
+    constructor(connector, config, cacheProcessor) {
+        this.connector = connector;
+        this.config = config;
+        this.cacheProcessor = cacheProcessor;
+    }
+    async prepare() {
+        if (this.collection)
+            return;
+        if (!this.connector.database) {
+            throw new Error(`You can't use cache without mongo connection!`);
+        }
+        this.collection = this.connector.database.collection(this.config.resolve("cacheCollection"));
+        await this.collection.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+    }
+    async set(key, value, ttl, expirationTimestamp = null, tags = {}) {
+        await this.prepare();
+        const item = {
+            _id: key,
+            data: await this.cacheProcessor.serialize(value),
+            tags: await this.cacheProcessor.serialize(tags),
+            expirationTimestamp,
+        };
+        if (ttl) {
+            const now = Math.round(new Date().getTime() / 1000);
+            item.expiresAt = now + ttl;
+        }
+        await this.collection.updateOne({ _id: key }, { $set: item }, { upsert: true });
+        return value;
+    }
+    async get(key) {
+        await this.prepare();
+        let item = await this.collection.findOne({ _id: key });
+        const now = Math.round(new Date().getTime() / 1000);
+        if (item && item.expiresAt && item.expiresAt < now) {
+            item = null;
+        }
+        if (!item) {
+            throw new Error(`Cache probably doesn't exists with key: ${key}`);
+        }
+        return await this.cacheProcessor.deserialize(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) {
+        await this.prepare();
+        await this.collection.deleteOne({ _id: key });
+    }
+};
+Cache = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [MongoConnector, Configuration, CacheProcessor])
+], Cache);
+export { Cache };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/configuration.mjs

@@ -0,0 +1,68 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { injectAll, singleton } from "tsyringe";
+import dotenv from "dotenv";
+import { PARAMETER } from "../common-types";
+import { colorize, ConsoleColor, convertValue, getType, isFunction } from "../utils";
+let Configuration = class Configuration {
+    paramMap;
+    paramValues;
+    constructor(params) {
+        dotenv.config();
+        this.paramMap = {};
+        this.paramValues = {};
+        (params || []).forEach(param => this.add(param));
+    }
+    add(param) {
+        const existingParam = this.paramMap[param.name] || param;
+        existingParam.defaultValue = param.defaultValue;
+        existingParam.resolver = param.resolver || existingParam.resolver;
+        this.paramMap[param.name] = existingParam;
+    }
+    resolveValue(param, alreadyResolved) {
+        const envName = param.name.replace(/\.?([A-Z|0-9]+)/g, function (x, y) {
+            return "_" + y.toLowerCase();
+        }).replace(/\./gi, "_").replace(/^_/, "").toUpperCase();
+        const envValue = process.env[envName];
+        const helper = (p) => this.resolveInternal(p, alreadyResolved);
+        if (typeof envValue !== "undefined") {
+            const value = isFunction(param.resolver)
+                ? param.resolver(envValue, helper)
+                : convertValue(envValue, getType(param.defaultValue));
+            console.log(colorize(`Processing param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), colorize(envName, ConsoleColor.FgBlue), `"${envValue}"`, value);
+            return value;
+        }
+        else if (isFunction(param.resolver)) {
+            const value = param.resolver(param.defaultValue, helper);
+            console.log(colorize(`Processing default param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), param.defaultValue, value);
+            return value;
+        }
+        console.log(colorize(`Using default param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), param.defaultValue);
+        return param.defaultValue;
+    }
+    hasParam(name) {
+        return !!this.paramMap[name];
+    }
+    resolve(name) {
+        return this.resolveInternal(name, []);
+    }
+    resolveInternal(name, alreadyResolved) {
+        if (alreadyResolved.includes(name)) {
+            throw new Error(`Circular dependency detected: ${alreadyResolved.join(" -> ")} -> ${name}`);
+        }
+        alreadyResolved.push(name);
+        const param = this.paramMap[name];
+        if (!param)
+            throw new Error(`Parameter with name: '${name}' does not exists in configuration`);
+        if (!(name in this.paramValues)) {
+            this.paramValues[name] = this.resolveValue(param, alreadyResolved);
+        }
+        return this.paramValues[name];
+    }
+};
+Configuration = __decorate([
+    singleton(),
+    __param(0, injectAll(PARAMETER)),
+    __metadata("design:paramtypes", [Array])
+], Configuration);
+export { Configuration };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration.js","sourceRoot":"","sources":["../../../src/services/configuration.ts"],"names":[],"mappings":"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","sourcesContent":["import {injectAll, singleton} from \"tsyringe\";\r\nimport dotenv from \"dotenv\";\r\n\r\nimport {PARAMETER, Parameter} from \"../common-types\";\r\nimport {colorize, ConsoleColor, convertValue, getType, isFunction} from \"../utils\";\r\n\r\n@singleton()\r\nexport class Configuration {\r\n\r\n    protected paramMap: {[name: string]: Parameter};\r\n    protected paramValues: {[name: string]: any};\r\n\r\n    constructor(@injectAll(PARAMETER) params: Parameter[]) {\r\n        dotenv.config();\r\n        this.paramMap = {};\r\n        this.paramValues = {};\r\n        (params || []).forEach(param => this.add(param));\r\n    }\r\n\r\n    protected add(param: Parameter): void {\r\n        const existingParam = this.paramMap[param.name] || param;\r\n        existingParam.defaultValue = param.defaultValue;\r\n        existingParam.resolver = param.resolver || existingParam.resolver;\r\n        this.paramMap[param.name] = existingParam;\r\n    }\r\n\r\n    protected resolveValue(param: Parameter, alreadyResolved: string[]): any {\r\n        const envName = param.name.replace(/\\.?([A-Z|0-9]+)/g, function (x, y) {\r\n            return \"_\" + y.toLowerCase()\r\n        }).replace(/\\./gi, \"_\").replace(/^_/, \"\").toUpperCase();\r\n        const envValue = process.env[envName];\r\n        const helper = (p: string) => this.resolveInternal(p, alreadyResolved);\r\n        if (typeof envValue !== \"undefined\") {\r\n            const value = isFunction(param.resolver)\r\n                ? param.resolver(envValue, helper)\r\n                : convertValue(envValue, getType(param.defaultValue));\r\n            console.log(\r\n                colorize(`Processing param value`, ConsoleColor.FgYellow),\r\n                colorize(param.name, ConsoleColor.FgGreen),\r\n                colorize(envName, ConsoleColor.FgBlue),\r\n                `\"${envValue}\"`,\r\n                value\r\n            );\r\n            return value;\r\n        } else if (isFunction(param.resolver)) {\r\n            const value = param.resolver(param.defaultValue, helper);\r\n            console.log(\r\n                colorize(`Processing default param value`, ConsoleColor.FgYellow),\r\n                colorize(param.name, ConsoleColor.FgGreen),\r\n                param.defaultValue,\r\n                value\r\n            );\r\n            return value;\r\n        }\r\n        console.log(\r\n            colorize(`Using default param value`, ConsoleColor.FgYellow),\r\n            colorize(param.name, ConsoleColor.FgGreen),\r\n            param.defaultValue,\r\n        );\r\n        return param.defaultValue;\r\n    }\r\n\r\n    hasParam(name: string): boolean {\r\n        return !!this.paramMap[name];\r\n    }\r\n\r\n    resolve(name: string): any {\r\n        return this.resolveInternal(name, []);\r\n    }\r\n\r\n    protected resolveInternal(name: string, alreadyResolved: string[]): any {\r\n        if (alreadyResolved.includes(name)) {\r\n            throw new Error(`Circular dependency detected: ${alreadyResolved.join(\" -> \")} -> ${name}`);\r\n        }\r\n        alreadyResolved.push(name);\r\n        const param = this.paramMap[name];\r\n        if (!param) throw new Error(`Parameter with name: '${name}' does not exists in configuration`);\r\n        if (!(name in this.paramValues)) {\r\n            this.paramValues[name] = this.resolveValue(param, alreadyResolved);\r\n        }\r\n        return this.paramValues[name];\r\n    }\r\n}\r\n"]}

package/esm2022/services/drivers/asset-grid.driver.mjs

@@ -0,0 +1,27 @@
+import { __decorate, __metadata } from "tslib";
+import { injectable } from "tsyringe";
+import { GridFSBucket as BucketImpl } from 'mongodb/lib/gridfs';
+import { MongoConnector } from "../mongo-connector";
+let AssetGridDriver = class AssetGridDriver {
+    metaCollection;
+    bucket;
+    constructor(connector) {
+        this.bucket = new BucketImpl(connector.database, { bucketName: 'assets' });
+        this.metaCollection = "assets.files";
+    }
+    openUploadStream(filename, opts) {
+        return this.bucket.openUploadStream(filename, opts);
+    }
+    openDownloadStream(id) {
+        return this.bucket.openDownloadStream(id);
+    }
+    delete(id) {
+        return this.bucket.delete(id);
+    }
+};
+AssetGridDriver = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [MongoConnector])
+], AssetGridDriver);
+export { AssetGridDriver };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/drivers/asset-local.driver.mjs

@@ -0,0 +1,41 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { createReadStream, createWriteStream, mkdirSync } from 'fs';
+import { inject, injectable } from "tsyringe";
+import { rm, writeFile } from 'fs/promises';
+import { Types } from 'mongoose';
+import { LOCAL_DIR } from '../../common-types';
+let AssetLocalDriver = class AssetLocalDriver {
+    dir;
+    metaCollection;
+    constructor(dir) {
+        this.dir = dir;
+        this.metaCollection = "assets.local";
+    }
+    openUploadStream(filename, opts) {
+        const id = new Types.ObjectId();
+        const dir = `${this.dir}/${id.toHexString()}`;
+        mkdirSync(dir, { recursive: true });
+        const stream = createWriteStream(`${dir}/file.bin`);
+        stream.id = id;
+        stream.done = false;
+        stream.on('finish', () => {
+            writeFile(`${dir}/filename.txt`, filename);
+            writeFile(`${dir}/metadata.json`, JSON.stringify(opts?.metadata || {}));
+            stream.done = true;
+        });
+        return stream;
+    }
+    openDownloadStream(id) {
+        return createReadStream(`${this.dir}/${id.toHexString()}/file.bin`, { autoClose: true, emitClose: true });
+    }
+    delete(id) {
+        return rm(`${this.dir}/${id.toHexString()}`, { recursive: true, force: true });
+    }
+};
+AssetLocalDriver = __decorate([
+    injectable(),
+    __param(0, inject(LOCAL_DIR)),
+    __metadata("design:paramtypes", [String])
+], AssetLocalDriver);
+export { AssetLocalDriver };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/endpoint-provider.mjs

@@ -0,0 +1,13 @@
+import { __decorate } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+let EndpointProvider = class EndpointProvider {
+    async configure(app) {
+        console.log(`Express app is mounted to: ${app.mountpath}`);
+    }
+};
+EndpointProvider = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], EndpointProvider);
+export { EndpointProvider };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5kcG9pbnQtcHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmljZXMvZW5kcG9pbnQtcHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBQyxNQUFNLFVBQVUsQ0FBQztBQUtoRCxJQUFNLGdCQUFnQixHQUF0QixNQUFNLGdCQUFnQjtJQUV6QixLQUFLLENBQUMsU0FBUyxDQUFDLEdBQVk7UUFDeEIsT0FBTyxDQUFDLEdBQUcsQ0FBQyw4QkFBOEIsR0FBRyxDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUM7SUFDL0QsQ0FBQztDQUNKLENBQUE7QUFMWSxnQkFBZ0I7SUFGNUIsVUFBVSxFQUFFO0lBQ1osTUFBTSxDQUFDLFNBQVMsQ0FBQyxlQUFlLENBQUM7R0FDckIsZ0JBQWdCLENBSzVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtpbmplY3RhYmxlLCBMaWZlY3ljbGUsIHNjb3BlZH0gZnJvbSBcInRzeXJpbmdlXCI7XHJcbmltcG9ydCB7RXhwcmVzc30gZnJvbSBcImV4cHJlc3NcIjtcclxuXHJcbkBpbmplY3RhYmxlKClcclxuQHNjb3BlZChMaWZlY3ljbGUuQ29udGFpbmVyU2NvcGVkKVxyXG5leHBvcnQgY2xhc3MgRW5kcG9pbnRQcm92aWRlciB7XHJcblxyXG4gICAgYXN5bmMgY29uZmlndXJlKGFwcDogRXhwcmVzcyk6IFByb21pc2U8YW55PiB7XHJcbiAgICAgICAgY29uc29sZS5sb2coYEV4cHJlc3MgYXBwIGlzIG1vdW50ZWQgdG86ICR7YXBwLm1vdW50cGF0aH1gKTtcclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2022/services/entities/asset.mjs

@@ -0,0 +1,61 @@
+import { isString, streamToBuffer, toImage } from "../../utils";
+import { BaseEntity } from "./base-entity";
+export class Asset extends BaseEntity {
+    driver;
+    get filename() {
+        return this.data.filename;
+    }
+    get contentType() {
+        return this.data.contentType;
+    }
+    get metadata() {
+        return this.data.metadata;
+    }
+    get stream() {
+        return this.driver.openDownloadStream(this.oid);
+    }
+    constructor(id, data, collection, driver) {
+        super(id, data, collection);
+        this.driver = driver;
+    }
+    async unlink() {
+        try {
+            await this.driver.delete(this.oid);
+            await this.collection.deleteOne({ _id: this.oid });
+        }
+        catch (error) {
+            let err = error;
+            if (error) {
+                err = error.message || error || "";
+                if (!isString(err) || !err.startsWith("FileNotFound")) {
+                    throw err;
+                }
+            }
+        }
+        return this.id;
+    }
+    async setMeta(metadata) {
+        metadata = Object.assign(this.metadata, metadata || {});
+        await this.collection.updateOne({ _id: this.oid }, { $set: { metadata } });
+    }
+    getBuffer() {
+        return streamToBuffer(this.stream);
+    }
+    async download(metadata) {
+        metadata = Object.assign(this.metadata, metadata || {});
+        metadata.downloadCount = isNaN(metadata.downloadCount) || !metadata.firstDownload
+            ? 1
+            : metadata.downloadCount + 1;
+        metadata.firstDownload = metadata.firstDownload || new Date();
+        metadata.lastDownload = new Date();
+        await this.collection.updateOne({ _id: this.oid }, { $set: { metadata } });
+        return this.stream;
+    }
+    async getImage(params = null) {
+        return toImage(this.stream, params, this.metadata);
+    }
+    async downloadImage(params, metadata) {
+        return toImage(await this.download(metadata), params, this.metadata);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/entities/base-entity.mjs

@@ -0,0 +1,32 @@
+export class BaseEntity {
+    oid;
+    data;
+    collection;
+    get id() {
+        return this.oid.toHexString();
+    }
+    deleted;
+    constructor(oid, data, collection) {
+        this.oid = oid;
+        this.data = data;
+        this.collection = collection;
+    }
+    save() {
+        return this.collection.updateOne({ _id: this.oid }, { $set: this.toJSON() }, { upsert: true });
+    }
+    async load() {
+        const res = await this.collection.findOne({ _id: this.oid });
+        this.deleted = !res;
+        this.data = res || {};
+        return this;
+    }
+    toJSON() {
+        const ret = Object.assign({}, this.data);
+        delete ret._id;
+        ret.id = this.id;
+        ret.updatedAt = new Date();
+        ret.createdAt = ret.createdAt || ret.updatedAt;
+        return ret;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,87 @@
+import { gunzipPromised } from "../../utils";
+import { BaseEntity } from "./base-entity";
+export class LazyAsset extends BaseEntity {
+    logger;
+    assets;
+    progresses;
+    get jobName() {
+        return this.data.jobName;
+    }
+    get jobParams() {
+        return this.data.jobParams;
+    }
+    get jobQue() {
+        return this.data.jobQue;
+    }
+    get createdAt() {
+        return this.data.createdAt;
+    }
+    get updatedAt() {
+        return this.data.updatedAt;
+    }
+    get progressId() {
+        return this.data.progressId;
+    }
+    get assetId() {
+        return this.data.assetId;
+    }
+    constructor(id, data, collection, logger, assets, progresses) {
+        super(id, data, collection);
+        this.logger = logger;
+        this.assets = assets;
+        this.progresses = progresses;
+    }
+    async unlink() {
+        await this.load();
+        if (!this.progressId) {
+            await this.collection.deleteOne({ _id: this.oid });
+        }
+        return this.assets.unlink(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.updatedAt = new Date();
+        this.data.assetId = asset.id;
+        await asset.setMeta({ lazyId: this.id });
+        await this.save();
+        return asset;
+    }
+    async startWorkingOnAsset(fromLoad) {
+        const oldAsset = this.data.assetId;
+        this.data.updatedAt = new Date();
+        this.data.progressId = (await this.progresses.create()).id;
+        this.data.assetId = null;
+        await this.save();
+        await this.assets.unlink(oldAsset);
+        const jobParams = JSON.parse(await gunzipPromised(this.data.jobParams));
+        await this.progresses.jobMan.enqueueWithName(this.data.jobName, { ...jobParams, lazyId: this.id, fromLoad });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lazy-asset.js","sourceRoot":"","sources":["../../../../src/services/entities/lazy-asset.ts"],"names":[],"mappings":"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","sourcesContent":["import {Collection} from \"mongodb\";\r\nimport {ObjectId} from \"bson\";\r\n\r\nimport {IAsset, ILazyAsset} from \"../../common-types\";\r\nimport {gunzipPromised} from \"../../utils\";\r\nimport {Assets} from \"../assets\";\r\nimport {Progresses} from \"../progresses\";\r\nimport {BaseEntity} from \"./base-entity\";\r\nimport {Logger} from \"../logger\";\r\n\r\nexport class LazyAsset extends BaseEntity<ILazyAsset> implements ILazyAsset {\r\n\r\n    get jobName(): string {\r\n        return this.data.jobName;\r\n    }\r\n\r\n    get jobParams(): any {\r\n        return this.data.jobParams;\r\n    }\r\n\r\n    get jobQue(): string {\r\n        return this.data.jobQue;\r\n    }\r\n\r\n    get createdAt(): Date {\r\n        return this.data.createdAt;\r\n    }\r\n\r\n    get updatedAt(): Date {\r\n        return this.data.updatedAt;\r\n    }\r\n\r\n    get progressId(): string {\r\n        return this.data.progressId;\r\n    }\r\n\r\n    get assetId(): string {\r\n        return this.data.assetId;\r\n    }\r\n\r\n    constructor(id: ObjectId,\r\n                data: Partial<ILazyAsset>,\r\n                collection: Collection,\r\n                protected logger: Logger,\r\n                protected assets: Assets,\r\n                protected progresses: Progresses) {\r\n        super(id, data, collection);\r\n    }\r\n\r\n    async unlink(): Promise<string> {\r\n        await this.load();\r\n        if (!this.progressId) {\r\n            await this.collection.deleteOne({_id: this.oid});\r\n        }\r\n        return this.assets.unlink(this.assetId);\r\n    }\r\n\r\n    startWorking(): void {\r\n        this.load().then(() => {\r\n            if (this.deleted) return;\r\n            this.progresses.get(this.progressId).then(p => {\r\n                p?.cancel();\r\n            });\r\n            this.startWorkingOnAsset(false).then(() => {\r\n                this.logger.log(\"lazy-assets\", `Started working on lazy asset: ${this.id}`);\r\n            }).catch(reason => {\r\n                this.logger.log(\"lazy-assets\", `Can't start working on lazy asset: ${this.id}\\nReason: ${reason}`);\r\n            });\r\n        });\r\n    }\r\n\r\n    async loadAsset(): Promise<IAsset> {\r\n        await this.load();\r\n        if (this.deleted) return null;\r\n        if (this.assetId) {\r\n            return this.assets.read(this.assetId);\r\n        }\r\n        if (this.progressId) {\r\n            await this.progresses.waitToFinish(this.progressId);\r\n            return this.loadAsset();\r\n        }\r\n        await this.startWorkingOnAsset(true);\r\n        return this.loadAsset();\r\n    }\r\n\r\n    async writeAsset(asset: IAsset): Promise<IAsset> {\r\n        this.data.updatedAt = new Date();\r\n        this.data.assetId = asset.id;\r\n        await asset.setMeta({lazyId: this.id});\r\n        await this.save();\r\n        return asset;\r\n    }\r\n\r\n    protected async startWorkingOnAsset(fromLoad: boolean): Promise<any> {\r\n        const oldAsset = this.data.assetId;\r\n        this.data.updatedAt = new Date();\r\n        this.data.progressId = (await this.progresses.create()).id;\r\n        this.data.assetId = null;\r\n        await this.save();\r\n        await this.assets.unlink(oldAsset);\r\n        const jobParams = JSON.parse(await gunzipPromised(this.data.jobParams));\r\n        await this.progresses.jobMan.enqueueWithName(this.data.jobName, {...jobParams, lazyId: this.id, fromLoad});\r\n    }\r\n}\r\n"]}