@punks/backend-entity-manager 0.0.80 → 0.0.82

package/dist/cjs/types/actions/delete.d.ts

@@ -2,6 +2,7 @@ import { IEntityDeleteAction } from "../abstractions/actions";
 import { EntityServiceLocator } from "../providers/services";
 export declare class EntityDeleteAction<TEntity, TEntityId> implements IEntityDeleteAction<TEntity, TEntityId> {
     private readonly services;
+    private readonly logger;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
     execute(id: TEntityId): Promise<void>;
 }

package/dist/cjs/types/actions/deleteItems.d.ts

@@ -3,6 +3,7 @@ import { IEntitiesDeleteParameters } from "../abstractions/commands";
 import { EntityServiceLocator } from "../providers/services";
 export declare class EntitiesDeleteAction<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting> implements IEntitiesDeleteAction<TEntity, TEntitiesDeleteParameters, TSorting> {
     private readonly services;
+    private readonly logger;
     constructor(services: EntityServiceLocator<TEntity, unknown>);
     execute(params: TEntitiesDeleteParameters): Promise<void>;
 }

package/dist/cjs/types/actions/update.d.ts

@@ -2,6 +2,7 @@ import { IEntityUpdateAction } from "../abstractions/actions";
 import { EntityServiceLocator } from "../providers/services";
 export declare class EntityUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto> implements IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto> {
     private readonly services;
+    private readonly logger;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
     execute(id: TEntityId, input: TEntityUpdateData): Promise<TEntityDto>;
 }

package/dist/cjs/types/actions/upsert.d.ts

@@ -2,6 +2,7 @@ import { IEntityUpsertAction } from "../abstractions/actions";
 import { EntityServiceLocator } from "../providers/services";
 export declare class EntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto> implements IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto> {
     private readonly services;
+    private readonly logger;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
     execute(id: TEntityId, input: TEntityUpdateData): Promise<TEntityDto>;
 }

package/dist/cjs/types/integrations/repository/typeorm/repository.d.ts

@@ -5,6 +5,7 @@ export type UpdateCriteria<TEntity extends ObjectLiteral> = string | string[] |
 export type DeleteCriteria<TEntity extends ObjectLiteral> = string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | FindOptionsWhere<TEntity>;
 export declare class TypeOrmRepository<TEntity extends ObjectLiteral, TEntityId> implements IEntityRepository<TEntity, TEntityId, FindOneOptions<TEntity>, FindManyOptions<TEntity>, UpdateCriteria<TEntity>, DeleteCriteria<TEntity>> {
     protected readonly innerRepository: Repository<TEntity>;
+    private readonly logger;
     constructor(innerRepository: Repository<TEntity>);
     getInnerRepository(): Repository<TEntity>;
     exists(id: TEntityId): Promise<boolean>;

package/dist/esm/index.js

@@ -508,18 +508,24 @@ class EntityCreateAction {
 class EntityDeleteAction {
     constructor(services) {
         this.services = services;
+        this.logger = 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 = 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");
     }
 }
 
@@ -566,28 +572,36 @@ class EntitiesSearchAction {
 class EntityUpdateAction {
     constructor(services) {
         this.services = services;
+        this.logger = 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 = 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;
     }
 }
 
@@ -21015,14 +21029,16 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
 class TypeOrmRepository {
     constructor(innerRepository) {
         this.innerRepository = innerRepository;
+        this.logger = Log.getLogger("TypeOrm Repository");
     }
     getInnerRepository() {
         return this.innerRepository;
     }
     async exists(id) {
-        if (typeof id === "undefined") {
+        if (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,
@@ -21030,12 +21046,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 (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,
@@ -21044,35 +21062,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: In(id),
         });
     }
     async delete(id) {
+        if (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) {
@@ -21081,6 +21110,10 @@ class TypeOrmRepository {
         return current;
     }
     async update(id, entity) {
+        if (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) {
@@ -21089,10 +21122,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 (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);
         }