@punks/backend-entity-manager 0.0.80 → 0.0.82

package/dist/cjs/index.js

@@ -516,18 +516,24 @@ class EntityCreateAction {
 class EntityDeleteAction {
     constructor(services) {
         this.services = services;
+        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Delete`);
     }
     async execute(id) {
+        this.logger.debug("Delete action started", { id });
         await this.services.resolveDeleteCommand().execute(id);
+        this.logger.debug("Delete action completed", { id });
     }
 }
 
 class EntitiesDeleteAction {
     constructor(services) {
         this.services = services;
+        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> DeleteItems`);
     }
     async execute(params) {
+        this.logger.debug("DeleteItems action started");
         await this.services.resolveDeleteItemsCommand().execute(params);
+        this.logger.debug("DeleteItems action completed");
     }
 }
 
@@ -574,28 +580,36 @@ class EntitiesSearchAction {
 class EntityUpdateAction {
     constructor(services) {
         this.services = services;
+        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Update`);
     }
     async execute(id, input) {
+        this.logger.debug("Update action started", { id, input });
         const converter = this.services.resolveConverter();
         const updateInput = converter?.updateDtoToEntity(input) ?? input;
         const entity = await this.services
             .resolveUpdateCommand()
             .execute(id, updateInput);
-        return converter?.toEntityDto(entity) ?? entity;
+        const result = converter?.toEntityDto(entity) ?? entity;
+        this.logger.debug("Update action started", { id, input, result });
+        return result;
     }
 }
 
 class EntityUpsertAction {
     constructor(services) {
         this.services = services;
+        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Upsert`);
     }
     async execute(id, input) {
+        this.logger.debug("Upsert action started", { id, input });
         const converter = this.services.resolveConverter();
         const updateInput = converter?.updateDtoToEntity(input) ?? input;
         const entity = await this.services
             .resolveUpsertCommand()
             .execute(id, updateInput);
-        return converter?.toEntityDto(entity) ?? entity;
+        const result = converter?.toEntityDto(entity) ?? entity;
+        this.logger.debug("Upsert action started", { id, input, result });
+        return result;
     }
 }
 
@@ -21023,14 +21037,16 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
 class TypeOrmRepository {
     constructor(innerRepository) {
         this.innerRepository = innerRepository;
+        this.logger = backendCore.Log.getLogger("TypeOrm Repository");
     }
     getInnerRepository() {
         return this.innerRepository;
     }
     async exists(id) {
-        if (typeof id === "undefined") {
+        if (backendCore.isNullOrUndefined(id)) {
             throw new Error("Invalid 'id' parameter.");
         }
+        this.logger.debug("Checking entity exists by id", { id });
         return await this.innerRepository.exist({
             where: {
                 id: id,
@@ -21038,12 +21054,14 @@ class TypeOrmRepository {
         });
     }
     async existsBy(condition) {
+        this.logger.debug("Checking entity exists by condition", { condition });
         return await this.innerRepository.exist(condition);
     }
     async get(id) {
-        if (typeof id === "undefined") {
+        if (backendCore.isNullOrUndefined(id)) {
             throw new Error("Invalid 'id' parameter.");
         }
+        this.logger.debug("Getting entity by id", { id });
         const result = await this.innerRepository.findOne({
             where: {
                 id: id,
@@ -21052,35 +21070,46 @@ class TypeOrmRepository {
         return result ?? undefined;
     }
     async getBy(condition) {
+        this.logger.debug("Getting entity by condition", { condition });
         const result = await this.innerRepository.findOne(condition);
         return result ?? undefined;
     }
     async all() {
+        this.logger.debug("Getting all entities");
         return await this.innerRepository.find();
     }
     async count(condition) {
+        this.logger.debug("Counting entities", { condition });
         return await this.innerRepository.count(condition);
     }
     async find(condition) {
+        this.logger.debug("Finding entities by condition", { condition });
         return await this.innerRepository.find(condition);
     }
     async findById(id) {
+        this.logger.debug("Finding entities by id", { id });
         return await this.innerRepository.findBy({
             id: typeorm.In(id),
         });
     }
     async delete(id) {
+        if (backendCore.isNullOrUndefined(id)) {
+            throw new Error("Invalid 'id' parameter.");
+        }
+        this.logger.debug("Deleting entity by id", { id });
         await this.innerRepository.delete({
             id: id,
         });
     }
     async deleteBy(condition) {
         const result = await this.innerRepository.delete(condition);
+        this.logger.debug("Deleting entities by condition", { condition, result });
         return {
             deletedCount: result.affected,
         };
     }
     async create(entity) {
+        this.logger.debug("Creating entity", { entity });
         const createResult = await this.innerRepository.insert(entity);
         const current = await this.get(createResult.identifiers[0].id);
         if (!current) {
@@ -21089,6 +21118,10 @@ class TypeOrmRepository {
         return current;
     }
     async update(id, entity) {
+        if (backendCore.isNullOrUndefined(id)) {
+            throw new Error("Invalid 'id' parameter.");
+        }
+        this.logger.debug("Updating entity", { id, entity });
         await this.innerRepository.update(id, entity);
         const current = await this.get(id);
         if (!current) {
@@ -21097,10 +21130,15 @@ class TypeOrmRepository {
         return current;
     }
     async updateBy(entity, condition) {
+        this.logger.debug("Updating entities by condition", { entity, condition });
         const updateResult = await this.innerRepository.update(condition, entity);
         return await this.findById(updateResult.generatedMaps.map((x) => x.id));
     }
     async upsert(id, entity) {
+        if (backendCore.isNullOrUndefined(id)) {
+            throw new Error("Invalid 'id' parameter.");
+        }
+        this.logger.debug("Upserting entity", { id, entity });
         if (await this.exists(id)) {
             return await this.update(id, entity);
         }