@minimaltech/node-infra 0.5.9-2 → 0.5.9-21

package/dist/base/repositories/searchable-tz-crud.repository.js

@@ -8,15 +8,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -30,143 +21,129 @@ const utilities_1 = require("../../utilities");
 const get_1 = __importDefault(require("lodash/get"));
 const set_1 = __importDefault(require("lodash/set"));
 let SearchableTzCrudRepository = SearchableTzCrudRepository_1 = class SearchableTzCrudRepository extends tz_crud_repository_1.TzCrudRepository {
+    searchableInclusions;
+    isInclusionRelations;
     constructor(entityClass, dataSource, opts, scope) {
-        var _a;
-        super(entityClass, dataSource, scope !== null && scope !== void 0 ? scope : SearchableTzCrudRepository_1.name);
+        super(entityClass, dataSource, scope ?? SearchableTzCrudRepository_1.name);
         this.isInclusionRelations = opts.isInclusionRelations;
-        this.searchableInclusions = (_a = opts.searchableInclusions) !== null && _a !== void 0 ? _a : [];
+        this.searchableInclusions = opts.searchableInclusions ?? [];
     }
-    // ----------------------------------------------------------------------------------------------------
-    registerOnInclusionChanged(relation, relationRepositoryGetter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const relationRepository = yield relationRepositoryGetter();
-            relationRepository.modelClass.observe('after save', (context) => __awaiter(this, void 0, void 0, function* () {
-                const { isNewInstance, where, instance, options } = context;
-                let entities = [];
-                if (isNewInstance) {
-                    entities.push(instance);
-                }
-                else {
-                    entities = yield relationRepository.find({ where }, options);
-                }
-                yield this.onInclusionChanged({ relation, relationRepository, entities, options });
-            }));
-            relationRepository.modelClass.observe('after deleteWithReturn', (context) => __awaiter(this, void 0, void 0, function* () {
-                const { data } = context;
-                yield this.onInclusionChanged({
-                    relation,
-                    relationRepository,
-                    entities: data,
-                });
-            }));
+    async registerOnInclusionChanged(relation, relationRepositoryGetter) {
+        const relationRepository = await relationRepositoryGetter();
+        relationRepository.modelClass.observe('after save', async (context) => {
+            const { isNewInstance, where, instance, options } = context;
+            let entities = [];
+            if (isNewInstance) {
+                entities.push(instance);
+            }
+            else {
+                entities = await relationRepository.find({ where }, options);
+            }
+            await this.onInclusionChanged({ relation, relationRepository, entities, options });
+        });
+        relationRepository.modelClass.observe('after deleteWithReturn', async (context) => {
+            const { data } = context;
+            await this.onInclusionChanged({
+                relation,
+                relationRepository,
+                entities: data,
+            });
         });
     }
-    // ----------------------------------------------------------------------------------------------------
-    handleInclusionChanged(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { relationName, relationType, entities, relationRepository, options } = opts;
-            const resolved = yield ((_a = relationRepository.inclusionResolvers.get(relationName)) === null || _a === void 0 ? void 0 : _a(entities, {
-                relation: relationName,
-                scope: {
-                    include: this.searchableInclusions,
-                },
-            }, options));
-            const promises = [];
-            switch (relationType) {
-                case 'belongsTo': {
-                    const rs = resolved;
-                    if (!(rs === null || rs === void 0 ? void 0 : rs.length)) {
-                        break;
-                    }
-                    for (const r1 of rs) {
-                        if (!r1) {
-                            continue;
-                        }
-                        promises.push(this.updateById(r1.id, 
-                        // TODO: handle type
-                        {
-                            objectSearch: this.renderObjectSearch({ entity: r1 }),
-                        }, { ignoreMixSearchFields: true, options }));
-                    }
+    async handleInclusionChanged(opts) {
+        const { relationName, relationType, entities, relationRepository, options } = opts;
+        const resolved = await relationRepository.inclusionResolvers.get(relationName)?.(entities, {
+            relation: relationName,
+            scope: {
+                include: this.searchableInclusions,
+            },
+        }, options);
+        const promises = [];
+        switch (relationType) {
+            case 'belongsTo': {
+                const rs = resolved;
+                if (!rs?.length) {
                     break;
                 }
-                case 'hasOne': {
+                for (const r1 of rs) {
+                    if (!r1) {
+                        continue;
+                    }
+                    promises.push(this.updateById(r1.id, {
+                        objectSearch: this.renderObjectSearch({ entity: r1 }),
+                    }, { ignoreMixSearchFields: true, options }));
+                }
+                break;
+            }
+            case 'hasOne': {
+                break;
+            }
+            case 'hasMany':
+            case 'hasManyThrough': {
+                const rs = resolved;
+                if (!rs?.length) {
                     break;
                 }
-                case 'hasMany':
-                case 'hasManyThrough': {
-                    const rs = resolved;
-                    if (!(rs === null || rs === void 0 ? void 0 : rs.length)) {
+                for (const r1 of rs) {
+                    if (!r1?.length) {
                         break;
                     }
-                    for (const r1 of rs) {
-                        if (!(r1 === null || r1 === void 0 ? void 0 : r1.length)) {
-                            break;
-                        }
-                        for (const r2 of r1) {
-                            if (!rs) {
-                                continue;
-                            }
-                            promises.push(this.updateById(r2.id, 
-                            // TODO: handle type
-                            {
-                                objectSearch: this.renderObjectSearch({ entity: r2 }),
-                            }, { ignoreMixSearchFields: true, options }));
+                    for (const r2 of r1) {
+                        if (!rs) {
+                            continue;
                         }
+                        promises.push(this.updateById(r2.id, {
+                            objectSearch: this.renderObjectSearch({ entity: r2 }),
+                        }, { ignoreMixSearchFields: true, options }));
                     }
-                    break;
-                }
-                default: {
-                    break;
                 }
+                break;
             }
-            yield Promise.all(promises);
-        });
-    }
-    // ----------------------------------------------------------------------------------------------------
-    renderSearchable(field, data, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const where = (0, get_1.default)(options, 'where');
-            const isSearchable = (0, get_1.default)(this.modelClass.definition.properties, field, null) !== null;
-            if (!isSearchable) {
-                return null;
+            default: {
+                break;
             }
-            let resolved = [data];
-            if (this.isInclusionRelations && this.searchableInclusions.length) {
-                resolved = yield this.includeRelatedModels([data], this.searchableInclusions, options);
+        }
+        await Promise.all(promises);
+    }
+    async renderSearchable(field, data, options) {
+        const where = (0, get_1.default)(options, 'where');
+        const isSearchable = (0, get_1.default)(this.modelClass.definition.properties, field, null) !== null;
+        if (!isSearchable) {
+            return null;
+        }
+        let resolved = [data];
+        if (this.isInclusionRelations && this.searchableInclusions.length) {
+            resolved = await this.includeRelatedModels([data], this.searchableInclusions, options);
+        }
+        switch (field) {
+            case 'textSearch': {
+                return this.renderTextSearch({ data, entity: resolved?.[0] });
             }
-            switch (field) {
-                case 'textSearch': {
-                    return this.renderTextSearch({ data, entity: resolved === null || resolved === void 0 ? void 0 : resolved[0] });
-                }
-                case 'objectSearch': {
-                    let currentObjectSearch = {};
-                    if (where) {
-                        const found = yield this.findOne({
-                            where,
-                            include: this.searchableInclusions,
+            case 'objectSearch': {
+                let currentObjectSearch = {};
+                if (where) {
+                    const found = await this.findOne({
+                        where,
+                        include: this.searchableInclusions,
+                    });
+                    if (found) {
+                        currentObjectSearch = this.renderObjectSearch({
+                            data,
+                            entity: found,
                         });
-                        if (found) {
-                            currentObjectSearch = this.renderObjectSearch({
-                                data,
-                                entity: found,
-                            });
-                        }
                     }
-                    const newObjectSearch = this.renderObjectSearch({
-                        data,
-                        entity: resolved === null || resolved === void 0 ? void 0 : resolved[0],
-                    });
-                    return Object.assign(Object.assign({}, currentObjectSearch), newObjectSearch);
-                }
-                default: {
-                    return null;
                 }
+                const newObjectSearch = this.renderObjectSearch({
+                    data,
+                    entity: resolved?.[0],
+                });
+                return { ...currentObjectSearch, ...newObjectSearch };
             }
-        });
+            default: {
+                return null;
+            }
+        }
     }
-    // ----------------------------------------------------------------------------------------------------
     mixSearchFields(data, options) {
         return new Promise((resolve, reject) => {
             const ignoreMixSearchFields = (0, get_1.default)(options, 'ignoreMixSearchFields');
@@ -189,9 +166,8 @@ let SearchableTzCrudRepository = SearchableTzCrudRepository_1 = class Searchable
                 .catch(reject);
         });
     }
-    // ----------------------------------------------------------------------------------------------------
     create(data, options) {
-        const tmp = this.mixUserAudit(data, { newInstance: true, authorId: options === null || options === void 0 ? void 0 : options.authorId });
+        const tmp = this.mixUserAudit(data, { newInstance: true, authorId: options?.authorId });
         return new Promise((resolve, reject) => {
             this.mixSearchFields(tmp, options)
                 .then(enriched => {
@@ -200,11 +176,10 @@ let SearchableTzCrudRepository = SearchableTzCrudRepository_1 = class Searchable
                 .catch(reject);
         });
     }
-    // ----------------------------------------------------------------------------------------------------
     createAll(data, options) {
         return new Promise((resolve, reject) => {
             Promise.all(data.map(el => {
-                const tmp = this.mixUserAudit(el, { newInstance: true, authorId: options === null || options === void 0 ? void 0 : options.authorId });
+                const tmp = this.mixUserAudit(el, { newInstance: true, authorId: options?.authorId });
                 return this.mixSearchFields(tmp, options);
             }))
                 .then(enriched => {
@@ -213,20 +188,18 @@ let SearchableTzCrudRepository = SearchableTzCrudRepository_1 = class Searchable
                 .catch(reject);
         });
     }
-    // ----------------------------------------------------------------------------------------------------
     updateById(id, data, options) {
-        const tmp = this.mixUserAudit(data, { newInstance: false, authorId: options === null || options === void 0 ? void 0 : options.authorId });
+        const tmp = this.mixUserAudit(data, { newInstance: false, authorId: options?.authorId });
         return new Promise((resolve, reject) => {
-            this.mixSearchFields(tmp, Object.assign(Object.assign({}, options), { where: { id } }))
+            this.mixSearchFields(tmp, { ...options, where: { id } })
                 .then(enriched => {
                 resolve(super.updateById(id, enriched, options));
             })
                 .catch(reject);
         });
     }
-    // ----------------------------------------------------------------------------------------------------
     replaceById(id, data, options) {
-        const tmp = this.mixUserAudit(data, { newInstance: false, authorId: options === null || options === void 0 ? void 0 : options.authorId });
+        const tmp = this.mixUserAudit(data, { newInstance: false, authorId: options?.authorId });
         return new Promise((resolve, reject) => {
             this.mixSearchFields(tmp, options)
                 .then(enriched => {
@@ -235,7 +208,6 @@ let SearchableTzCrudRepository = SearchableTzCrudRepository_1 = class Searchable
                 .catch(reject);
         });
     }
-    // ----------------------------------------------------------------------------------------------------
     _syncSearchFields(entities, options) {
         const { table, columns } = (0, utilities_1.getTableDefinition)({ model: this.entityClass });
         const data = entities.map(e => {
@@ -264,33 +236,30 @@ let SearchableTzCrudRepository = SearchableTzCrudRepository_1 = class Searchable
         });
         return this.execute(query, undefined, options);
     }
-    // ----------------------------------------------------------------------------------------------------
-    syncSearchFields(where, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const t = performance.now();
-            const pagingLimit = (0, get_1.default)(options, 'pagingLimit', 50);
-            let pagingOffset = 0;
-            this.logger.info('[syncSearchFields] Start sync searchable fields');
-            const tasks = [];
-            while (true) {
-                const entities = yield this.find({ where, include: this.searchableInclusions, limit: pagingLimit, offset: pagingOffset }, options);
-                this.logger.info('[syncSearchFields] Where: %j | Found: %d', where, entities.length);
-                tasks.push(() => this._syncSearchFields(entities, options)
-                    .then(() => {
-                    this.logger.info(`[syncSearchFields] Sucess sync %d rows`, entities.length);
-                })
-                    .catch(e => {
-                    this.logger.error(`[syncSearchFields] Error: %j`, e);
-                }));
-                pagingOffset += pagingLimit;
-                if (entities.length < pagingLimit) {
-                    break;
-                }
+    async syncSearchFields(where, options) {
+        const t = performance.now();
+        const pagingLimit = (0, get_1.default)(options, 'pagingLimit', 50);
+        let pagingOffset = 0;
+        this.logger.info('[syncSearchFields] Start sync searchable fields');
+        const tasks = [];
+        while (true) {
+            const entities = await this.find({ where, include: this.searchableInclusions, limit: pagingLimit, offset: pagingOffset }, options);
+            this.logger.info('[syncSearchFields] Where: %j | Found: %d', where, entities.length);
+            tasks.push(() => this._syncSearchFields(entities, options)
+                .then(() => {
+                this.logger.info(`[syncSearchFields] Sucess sync %d rows`, entities.length);
+            })
+                .catch(e => {
+                this.logger.error(`[syncSearchFields] Error: %j`, e);
+            }));
+            pagingOffset += pagingLimit;
+            if (entities.length < pagingLimit) {
+                break;
             }
-            yield (0, utilities_1.executePromiseWithLimit)({ tasks, limit: 5 });
-            this.logger.info('[syncSearchFields] End sync searchable fields | Took: %d (ms)', performance.now() - t);
-            return;
-        });
+        }
+        await (0, utilities_1.executePromiseWithLimit)({ tasks, limit: 5 });
+        this.logger.info('[syncSearchFields] End sync searchable fields | Took: %d (ms)', performance.now() - t);
+        return;
     }
 };
 exports.SearchableTzCrudRepository = SearchableTzCrudRepository;
@@ -298,4 +267,3 @@ exports.SearchableTzCrudRepository = SearchableTzCrudRepository = SearchableTzCr
     (0, core_1.injectable)({ scope: core_1.BindingScope.SINGLETON }),
     __metadata("design:paramtypes", [Object, repository_1.juggler.DataSource, Object, String])
 ], SearchableTzCrudRepository);
-//# sourceMappingURL=searchable-tz-crud.repository.js.map

package/dist/base/repositories/tz-crud.repository.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -17,12 +8,10 @@ const helpers_1 = require("../../helpers");
 const utilities_1 = require("../../utilities");
 const base_repository_1 = require("./base.repository");
 const get_1 = __importDefault(require("lodash/get"));
-// ----------------------------------------------------------------------------------------------------------------------------------------
 class TzCrudRepository extends base_repository_1.AbstractTzRepository {
     constructor(entityClass, dataSource, scope) {
         super(entityClass, dataSource, scope);
     }
-    // ----------------------------------------------------------------------------------------------------
     existsWith(where, options) {
         return new Promise((resolve, reject) => {
             this.findOne({ where }, options)
@@ -32,54 +21,44 @@ class TzCrudRepository extends base_repository_1.AbstractTzRepository {
                 .catch(reject);
         });
     }
-    // ----------------------------------------------------------------------------------------------------
     create(data, options) {
-        var _a;
         let enriched = this.mixTimestamp(data, {
             newInstance: true,
-            ignoreModified: (_a = options === null || options === void 0 ? void 0 : options.ignoreModified) !== null && _a !== void 0 ? _a : false,
+            ignoreModified: options?.ignoreModified ?? false,
         });
         enriched = this.mixUserAudit(enriched, {
             newInstance: true,
-            authorId: options === null || options === void 0 ? void 0 : options.authorId,
+            authorId: options?.authorId,
         });
         return super.create(enriched, options);
     }
-    // ----------------------------------------------------------------------------------------------------
     createAll(datum, options) {
         const enriched = datum.map(data => {
-            var _a;
             const tmp = this.mixTimestamp(data, {
                 newInstance: true,
-                ignoreModified: (_a = options === null || options === void 0 ? void 0 : options.ignoreModified) !== null && _a !== void 0 ? _a : false,
+                ignoreModified: options?.ignoreModified ?? false,
             });
             return this.mixUserAudit(tmp, {
                 newInstance: true,
-                authorId: options === null || options === void 0 ? void 0 : options.authorId,
+                authorId: options?.authorId,
             });
         });
         return super.createAll(enriched, options);
     }
-    /*
-     * @deprecated | Redundant | Please .create
-     */
     createWithReturn(data, options) {
         return this.create(data, options);
     }
-    // ----------------------------------------------------------------------------------------------------
     updateById(id, data, options) {
-        var _a;
         let enriched = this.mixTimestamp(data, {
             newInstance: false,
-            ignoreModified: (_a = options === null || options === void 0 ? void 0 : options.ignoreModified) !== null && _a !== void 0 ? _a : false,
+            ignoreModified: options?.ignoreModified ?? false,
         });
         enriched = this.mixUserAudit(enriched, {
             newInstance: false,
-            authorId: options === null || options === void 0 ? void 0 : options.authorId,
+            authorId: options?.authorId,
         });
         return super.updateById(id, enriched, options);
     }
-    // ----------------------------------------------------------------------------------------------------
     updateWithReturn(id, data, options) {
         return new Promise((resolve, reject) => {
             this.updateById(id, data, options)
@@ -93,55 +72,45 @@ class TzCrudRepository extends base_repository_1.AbstractTzRepository {
                 .catch(reject);
         });
     }
-    // ----------------------------------------------------------------------------------------------------
     updateAll(data, where, options) {
-        var _a;
         let enriched = this.mixTimestamp(data, {
             newInstance: false,
-            ignoreModified: (_a = options === null || options === void 0 ? void 0 : options.ignoreModified) !== null && _a !== void 0 ? _a : false,
+            ignoreModified: options?.ignoreModified ?? false,
         });
         enriched = this.mixUserAudit(enriched, {
             newInstance: false,
-            authorId: options === null || options === void 0 ? void 0 : options.authorId,
+            authorId: options?.authorId,
         });
         return super.updateAll(enriched, where, options);
     }
-    // ----------------------------------------------------------------------------------------------------
-    upsertWith(data, where, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const isExisted = yield this.existsWith(where, options);
-            if (isExisted) {
-                yield this.updateAll(data, where, options);
-                const rs = yield this.findOne({ where }, options);
-                return rs;
-            }
-            const rs = yield this.create(data, options);
+    async upsertWith(data, where, options) {
+        const isExisted = await this.existsWith(where, options);
+        if (isExisted) {
+            await this.updateAll(data, where, options);
+            const rs = await this.findOne({ where }, options);
             return rs;
-        });
+        }
+        const rs = await this.create(data, options);
+        return rs;
     }
-    // ----------------------------------------------------------------------------------------------------
     replaceById(id, data, options) {
-        var _a;
         let enriched = this.mixTimestamp(data, {
             newInstance: false,
-            ignoreModified: (_a = options === null || options === void 0 ? void 0 : options.ignoreModified) !== null && _a !== void 0 ? _a : false,
+            ignoreModified: options?.ignoreModified ?? false,
         });
         enriched = this.mixUserAudit(enriched, {
             newInstance: false,
-            authorId: options === null || options === void 0 ? void 0 : options.authorId,
+            authorId: options?.authorId,
         });
         return super.replaceById(id, enriched, options);
     }
-    // ----------------------------------------------------------------------------------------------------
     _softDelete(where, options) {
         return new Promise((resolve, reject) => {
-            const { databaseSchema, connectorType = 'postgresql', softDeleteField = 'isDeleted', useIgnoreModified = false, authorId, } = options !== null && options !== void 0 ? options : {};
+            const { databaseSchema, connectorType = 'postgresql', softDeleteField = 'isDeleted', useIgnoreModified = false, authorId, } = options ?? {};
             const tableName = this.modelClass.definition.tableName(connectorType);
             const softDeleteColumnName = this.modelClass.definition.columnName(connectorType, softDeleteField);
-            // Mix Timestamp
             const mixTimestampColumnName = this.modelClass.definition.columnName(connectorType, 'modifiedAt');
             const schema = (0, get_1.default)(this.modelClass.definition.settings, `${connectorType}.schema`, 'public');
-            // Mix User Audit
             const mixUserAuditColumnName = this.modelClass.definition.columnName(connectorType, 'modifiedBy');
             const isSoftDeleteFieldExist = (0, get_1.default)(this.modelClass.definition.rawProperties, softDeleteField);
             if (!isSoftDeleteFieldExist) {
@@ -152,9 +121,8 @@ class TzCrudRepository extends base_repository_1.AbstractTzRepository {
             const now = new Date();
             this.find({ fields: { id: true }, where })
                 .then(rs => {
-                var _a;
                 const sqlBuilder = helpers_1.QueryBuilderHelper.getPostgresQueryBuilder()
-                    .withSchema((_a = databaseSchema !== null && databaseSchema !== void 0 ? databaseSchema : schema) !== null && _a !== void 0 ? _a : 'public')
+                    .withSchema(databaseSchema ?? schema ?? 'public')
                     .from(tableName)
                     .update({ [softDeleteColumnName]: true })
                     .whereIn('id', rs.map(el => el.id));
@@ -196,12 +164,11 @@ class TzCrudRepository extends base_repository_1.AbstractTzRepository {
             });
         });
     }
-    // ----------------------------------------------------------------------------------------------------
     mixTimestamp(entity, options = {
         newInstance: false,
         ignoreModified: false,
     }) {
-        if (options === null || options === void 0 ? void 0 : options.newInstance) {
+        if (options?.newInstance) {
             entity.createdAt = new Date();
         }
         if (!options.ignoreModified) {
@@ -210,16 +177,15 @@ class TzCrudRepository extends base_repository_1.AbstractTzRepository {
         return entity;
     }
     mixUserAudit(entity, options) {
-        if (!(options === null || options === void 0 ? void 0 : options.authorId)) {
+        if (!options?.authorId) {
             return entity;
         }
-        if (options === null || options === void 0 ? void 0 : options.newInstance) {
+        if (options?.newInstance) {
             entity.createdBy = options.authorId;
         }
         entity.modifiedBy = options.authorId;
         return entity;
     }
-    // ----------------------------------------------------------------------------------------------------
     _deleteWithReturn(where, options) {
         return new Promise((resolve, reject) => {
             this.find({ where })
@@ -254,7 +220,6 @@ class TzCrudRepository extends base_repository_1.AbstractTzRepository {
             });
         });
     }
-    // ----------------------------------------------------------------------------------------------------
     batchUpdate(opts) {
         const { data, keys, setKeys, whereKeys, whereRaws = [], options } = opts;
         const query = (0, utilities_1.buildBatchUpdateQuery)({
@@ -269,4 +234,3 @@ class TzCrudRepository extends base_repository_1.AbstractTzRepository {
     }
 }
 exports.TzCrudRepository = TzCrudRepository;
-//# sourceMappingURL=tz-crud.repository.js.map

package/dist/base/services/base-crud.service.js

@@ -4,6 +4,7 @@ exports.BaseCrudService = void 0;
 const common_1 = require("../controllers/common");
 const base_service_1 = require("./base.service");
 class BaseCrudService extends base_service_1.BaseService {
+    repository;
     constructor(opts) {
         const { scope, repository } = opts;
         super({ scope });
@@ -22,32 +23,28 @@ class BaseCrudService extends base_service_1.BaseService {
         return this.repository.count(where);
     }
     create(data, options) {
-        var _a;
         return this.repository.create(data, {
-            authorId: (_a = options.currentUser) === null || _a === void 0 ? void 0 : _a.userId,
+            authorId: options.currentUser?.userId,
         });
     }
     updateAll(data, where, options) {
-        var _a;
         return this.repository.updateAll(data, where, {
-            authorId: (_a = options.currentUser) === null || _a === void 0 ? void 0 : _a.userId,
+            authorId: options.currentUser?.userId,
         });
     }
     updateWithReturn(id, data, options) {
-        var _a;
         return this.repository.updateWithReturn(id, data, {
-            authorId: (_a = options.currentUser) === null || _a === void 0 ? void 0 : _a.userId,
+            authorId: options.currentUser?.userId,
         });
     }
     replaceById(id, data, options) {
         return new Promise((resolve, reject) => {
-            var _a;
             this.repository
                 .replaceById(id, data, {
-                authorId: (_a = options.currentUser) === null || _a === void 0 ? void 0 : _a.userId,
+                authorId: options.currentUser?.userId,
             })
                 .then(() => {
-                resolve(Object.assign(Object.assign({}, data), { id }));
+                resolve({ ...data, id });
             })
                 .catch(reject);
         });
@@ -64,4 +61,3 @@ class BaseCrudService extends base_service_1.BaseService {
     }
 }
 exports.BaseCrudService = BaseCrudService;
-//# sourceMappingURL=base-crud.service.js.map

package/dist/base/services/base.service.js

@@ -3,10 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseService = void 0;
 const helpers_1 = require("../../helpers");
 class BaseService {
+    logger;
     constructor(opts) {
-        var _a;
-        this.logger = helpers_1.LoggerFactory.getLogger([(_a = opts === null || opts === void 0 ? void 0 : opts.scope) !== null && _a !== void 0 ? _a : BaseService.name]);
+        this.logger = helpers_1.LoggerFactory.getLogger([opts?.scope ?? BaseService.name]);
     }
 }
 exports.BaseService = BaseService;
-//# sourceMappingURL=base.service.js.map