@minimaltech/node-infra 0.5.9-22 → 0.5.9-24

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

@@ -8,6 +8,15 @@ 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 };
 };
@@ -21,129 +30,143 @@ 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) {
-        super(entityClass, dataSource, scope ?? SearchableTzCrudRepository_1.name);
+        var _a;
+        super(entityClass, dataSource, scope !== null && scope !== void 0 ? scope : SearchableTzCrudRepository_1.name);
         this.isInclusionRelations = opts.isInclusionRelations;
-        this.searchableInclusions = opts.searchableInclusions ?? [];
+        this.searchableInclusions = (_a = opts.searchableInclusions) !== null && _a !== void 0 ? _a : [];
     }
-    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,
-            });
+    // ----------------------------------------------------------------------------------------------------
+    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 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;
-                }
-                for (const r1 of rs) {
-                    if (!r1) {
-                        continue;
+    // ----------------------------------------------------------------------------------------------------
+    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;
                     }
-                    promises.push(this.updateById(r1.id, {
-                        objectSearch: this.renderObjectSearch({ entity: r1 }),
-                    }, { ignoreMixSearchFields: true, options }));
+                    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 }));
+                    }
+                    break;
                 }
-                break;
-            }
-            case 'hasOne': {
-                break;
-            }
-            case 'hasMany':
-            case 'hasManyThrough': {
-                const rs = resolved;
-                if (!rs?.length) {
+                case 'hasOne': {
                     break;
                 }
-                for (const r1 of rs) {
-                    if (!r1?.length) {
+                case 'hasMany':
+                case 'hasManyThrough': {
+                    const rs = resolved;
+                    if (!(rs === null || rs === void 0 ? void 0 : rs.length)) {
                         break;
                     }
-                    for (const r2 of r1) {
-                        if (!rs) {
-                            continue;
+                    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 }));
                         }
-                        promises.push(this.updateById(r2.id, {
-                            objectSearch: this.renderObjectSearch({ entity: r2 }),
-                        }, { ignoreMixSearchFields: true, options }));
                     }
+                    break;
+                }
+                default: {
+                    break;
                 }
-                break;
-            }
-            default: {
-                break;
             }
-        }
-        await Promise.all(promises);
+            yield 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] });
+    // ----------------------------------------------------------------------------------------------------
+    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;
             }
-            case 'objectSearch': {
-                let currentObjectSearch = {};
-                if (where) {
-                    const found = await this.findOne({
-                        where,
-                        include: this.searchableInclusions,
-                    });
-                    if (found) {
-                        currentObjectSearch = this.renderObjectSearch({
-                            data,
-                            entity: found,
+            let resolved = [data];
+            if (this.isInclusionRelations && this.searchableInclusions.length) {
+                resolved = yield this.includeRelatedModels([data], this.searchableInclusions, options);
+            }
+            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,
                         });
+                        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');
@@ -166,8 +189,9 @@ let SearchableTzCrudRepository = SearchableTzCrudRepository_1 = class Searchable
                 .catch(reject);
         });
     }
+    // ----------------------------------------------------------------------------------------------------
     create(data, options) {
-        const tmp = this.mixUserAudit(data, { newInstance: true, authorId: options?.authorId });
+        const tmp = this.mixUserAudit(data, { newInstance: true, authorId: options === null || options === void 0 ? void 0 : options.authorId });
         return new Promise((resolve, reject) => {
             this.mixSearchFields(tmp, options)
                 .then(enriched => {
@@ -176,10 +200,11 @@ 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?.authorId });
+                const tmp = this.mixUserAudit(el, { newInstance: true, authorId: options === null || options === void 0 ? void 0 : options.authorId });
                 return this.mixSearchFields(tmp, options);
             }))
                 .then(enriched => {
@@ -188,18 +213,20 @@ let SearchableTzCrudRepository = SearchableTzCrudRepository_1 = class Searchable
                 .catch(reject);
         });
     }
+    // ----------------------------------------------------------------------------------------------------
     updateById(id, data, options) {
-        const tmp = this.mixUserAudit(data, { newInstance: false, authorId: options?.authorId });
+        const tmp = this.mixUserAudit(data, { newInstance: false, authorId: options === null || options === void 0 ? void 0 : options.authorId });
         return new Promise((resolve, reject) => {
-            this.mixSearchFields(tmp, { ...options, where: { id } })
+            this.mixSearchFields(tmp, Object.assign(Object.assign({}, 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?.authorId });
+        const tmp = this.mixUserAudit(data, { newInstance: false, authorId: options === null || options === void 0 ? void 0 : options.authorId });
         return new Promise((resolve, reject) => {
             this.mixSearchFields(tmp, options)
                 .then(enriched => {
@@ -208,6 +235,7 @@ 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 => {
@@ -236,30 +264,33 @@ let SearchableTzCrudRepository = SearchableTzCrudRepository_1 = class Searchable
         });
         return this.execute(query, undefined, options);
     }
-    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;
+    // ----------------------------------------------------------------------------------------------------
+    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;
+                }
             }
-        }
-        await (0, utilities_1.executePromiseWithLimit)({ tasks, limit: 5 });
-        this.logger.info('[syncSearchFields] End sync searchable fields | Took: %d (ms)', performance.now() - t);
-        return;
+            yield (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;

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

@@ -1,4 +1,13 @@
 "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 };
 };
@@ -8,10 +17,12 @@ 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)
@@ -21,44 +32,54 @@ class TzCrudRepository extends base_repository_1.AbstractTzRepository {
                 .catch(reject);
         });
     }
+    // ----------------------------------------------------------------------------------------------------
     create(data, options) {
+        var _a;
         let enriched = this.mixTimestamp(data, {
             newInstance: true,
-            ignoreModified: options?.ignoreModified ?? false,
+            ignoreModified: (_a = options === null || options === void 0 ? void 0 : options.ignoreModified) !== null && _a !== void 0 ? _a : false,
         });
         enriched = this.mixUserAudit(enriched, {
             newInstance: true,
-            authorId: options?.authorId,
+            authorId: options === null || options === void 0 ? void 0 : 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: options?.ignoreModified ?? false,
+                ignoreModified: (_a = options === null || options === void 0 ? void 0 : options.ignoreModified) !== null && _a !== void 0 ? _a : false,
             });
             return this.mixUserAudit(tmp, {
                 newInstance: true,
-                authorId: options?.authorId,
+                authorId: options === null || options === void 0 ? void 0 : 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: options?.ignoreModified ?? false,
+            ignoreModified: (_a = options === null || options === void 0 ? void 0 : options.ignoreModified) !== null && _a !== void 0 ? _a : false,
         });
         enriched = this.mixUserAudit(enriched, {
             newInstance: false,
-            authorId: options?.authorId,
+            authorId: options === null || options === void 0 ? void 0 : options.authorId,
         });
         return super.updateById(id, enriched, options);
     }
+    // ----------------------------------------------------------------------------------------------------
     updateWithReturn(id, data, options) {
         return new Promise((resolve, reject) => {
             this.updateById(id, data, options)
@@ -72,45 +93,55 @@ class TzCrudRepository extends base_repository_1.AbstractTzRepository {
                 .catch(reject);
         });
     }
+    // ----------------------------------------------------------------------------------------------------
     updateAll(data, where, options) {
+        var _a;
         let enriched = this.mixTimestamp(data, {
             newInstance: false,
-            ignoreModified: options?.ignoreModified ?? false,
+            ignoreModified: (_a = options === null || options === void 0 ? void 0 : options.ignoreModified) !== null && _a !== void 0 ? _a : false,
         });
         enriched = this.mixUserAudit(enriched, {
             newInstance: false,
-            authorId: options?.authorId,
+            authorId: options === null || options === void 0 ? void 0 : options.authorId,
         });
         return super.updateAll(enriched, where, 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);
+    // ----------------------------------------------------------------------------------------------------
+    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);
             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: options?.ignoreModified ?? false,
+            ignoreModified: (_a = options === null || options === void 0 ? void 0 : options.ignoreModified) !== null && _a !== void 0 ? _a : false,
         });
         enriched = this.mixUserAudit(enriched, {
             newInstance: false,
-            authorId: options?.authorId,
+            authorId: options === null || options === void 0 ? void 0 : 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 ?? {};
+            const { databaseSchema, connectorType = 'postgresql', softDeleteField = 'isDeleted', useIgnoreModified = false, authorId, } = options !== null && options !== void 0 ? 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) {
@@ -121,8 +152,9 @@ 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(databaseSchema ?? schema ?? 'public')
+                    .withSchema((_a = databaseSchema !== null && databaseSchema !== void 0 ? databaseSchema : schema) !== null && _a !== void 0 ? _a : 'public')
                     .from(tableName)
                     .update({ [softDeleteColumnName]: true })
                     .whereIn('id', rs.map(el => el.id));
@@ -164,11 +196,12 @@ class TzCrudRepository extends base_repository_1.AbstractTzRepository {
             });
         });
     }
+    // ----------------------------------------------------------------------------------------------------
     mixTimestamp(entity, options = {
         newInstance: false,
         ignoreModified: false,
     }) {
-        if (options?.newInstance) {
+        if (options === null || options === void 0 ? void 0 : options.newInstance) {
             entity.createdAt = new Date();
         }
         if (!options.ignoreModified) {
@@ -177,15 +210,16 @@ class TzCrudRepository extends base_repository_1.AbstractTzRepository {
         return entity;
     }
     mixUserAudit(entity, options) {
-        if (!options?.authorId) {
+        if (!(options === null || options === void 0 ? void 0 : options.authorId)) {
             return entity;
         }
-        if (options?.newInstance) {
+        if (options === null || options === void 0 ? void 0 : options.newInstance) {
             entity.createdBy = options.authorId;
         }
         entity.modifiedBy = options.authorId;
         return entity;
     }
+    // ----------------------------------------------------------------------------------------------------
     _deleteWithReturn(where, options) {
         return new Promise((resolve, reject) => {
             this.find({ where })
@@ -220,6 +254,7 @@ class TzCrudRepository extends base_repository_1.AbstractTzRepository {
             });
         });
     }
+    // ----------------------------------------------------------------------------------------------------
     batchUpdate(opts) {
         const { data, keys, setKeys, whereKeys, whereRaws = [], options } = opts;
         const query = (0, utilities_1.buildBatchUpdateQuery)({

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

@@ -4,7 +4,6 @@ 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 });
@@ -23,28 +22,32 @@ class BaseCrudService extends base_service_1.BaseService {
         return this.repository.count(where);
     }
     create(data, options) {
+        var _a;
         return this.repository.create(data, {
-            authorId: options.currentUser?.userId,
+            authorId: (_a = options.currentUser) === null || _a === void 0 ? void 0 : _a.userId,
         });
     }
     updateAll(data, where, options) {
+        var _a;
         return this.repository.updateAll(data, where, {
-            authorId: options.currentUser?.userId,
+            authorId: (_a = options.currentUser) === null || _a === void 0 ? void 0 : _a.userId,
         });
     }
     updateWithReturn(id, data, options) {
+        var _a;
         return this.repository.updateWithReturn(id, data, {
-            authorId: options.currentUser?.userId,
+            authorId: (_a = options.currentUser) === null || _a === void 0 ? void 0 : _a.userId,
         });
     }
     replaceById(id, data, options) {
         return new Promise((resolve, reject) => {
+            var _a;
             this.repository
                 .replaceById(id, data, {
-                authorId: options.currentUser?.userId,
+                authorId: (_a = options.currentUser) === null || _a === void 0 ? void 0 : _a.userId,
             })
                 .then(() => {
-                resolve({ ...data, id });
+                resolve(Object.assign(Object.assign({}, data), { id }));
             })
                 .catch(reject);
         });

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

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseService = void 0;
 const helpers_1 = require("../../helpers");
 class BaseService {
-    logger;
     constructor(opts) {
-        this.logger = helpers_1.LoggerFactory.getLogger([opts?.scope ?? BaseService.name]);
+        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]);
     }
 }
 exports.BaseService = BaseService;