@mondart/nestjs-common-module 1.1.22 → 1.1.24

package/dist/dto/response/base-kafka-error-response.dto.d.ts

@@ -1,4 +1,4 @@
-import { BaseErrorResponse } from "./error-response.dto";
+import { BaseErrorResponse } from './error-response.dto';
 export declare class BaseKafkaErrorResponseDto {
     topic?: string;
     event_source: string;

package/dist/dto/response/kafka-success-response.dto.d.ts

@@ -1,5 +1,5 @@
 import { KafkaSuccessResponseInterface } from '../../interface/kafka-success-response.interface';
-import { BaseKafkaEventDto } from "./base-kafka-response.dto";
+import { BaseKafkaEventDto } from './base-kafka-response.dto';
 export declare class KafkaSuccessResponse<type> extends BaseKafkaEventDto<type> {
     constructor({ data, event_source, topic, model, event_key, partition, status, }: KafkaSuccessResponseInterface<type>);
     stringify(): string;

package/dist/entities/base-model-with-admin-actions.entity.d.ts

@@ -1,4 +1,4 @@
-import { BaseModelWithDatesEntity } from "./base-model-with-dates.entity";
+import { BaseModelWithDatesEntity } from './base-model-with-dates.entity';
 export declare class BaseModelWithAdminActionsEntity extends BaseModelWithDatesEntity {
     createdByAdmin?: string;
     updatedByAdmin?: string;

package/dist/entities/base-model-with-admin-and-user-actions.entity.d.ts

@@ -1,4 +1,4 @@
-import { BaseModelWithDatesEntity } from "./base-model-with-dates.entity";
+import { BaseModelWithDatesEntity } from './base-model-with-dates.entity';
 export declare class BaseModelWithAdminAndUserActionsEntity extends BaseModelWithDatesEntity {
     createdByAdmin?: string;
     updatedByAdmin?: string;

package/dist/entities/base-model-with-dates.entity.d.ts

@@ -1,4 +1,4 @@
-import { BaseModelEntity } from "./base-model.entity";
+import { BaseModelEntity } from './base-model.entity';
 export declare class BaseModelWithDatesEntity extends BaseModelEntity {
     createdAt: Date;
     updatedAt: Date;

package/dist/entities/base-model-with-user-actions.entity.d.ts

@@ -1,4 +1,4 @@
-import { BaseModelWithDatesEntity } from "./base-model-with-dates.entity";
+import { BaseModelWithDatesEntity } from './base-model-with-dates.entity';
 export declare class BaseModelWithUserActionsEntity extends BaseModelWithDatesEntity {
     createdByUser?: string;
     updatedByUser?: string;

package/dist/interface/{core-crud-service.option.d.ts → crud-service.option.d.ts}

@@ -1,6 +1,6 @@
 import { EntityManager } from 'typeorm';
 import { FindOptionsRelations } from 'typeorm/find-options/FindOptionsRelations';
-export declare class CoreCrudServiceOption<T> {
+export declare class CrudServiceOption<T> {
     entityManager?: EntityManager;
     relations?: FindOptionsRelations<T>;
     existsCheck?: boolean;

package/dist/interface/{core-crud-service.option.js → crud-service.option.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoreCrudServiceOption = void 0;
-class CoreCrudServiceOption {
+exports.CrudServiceOption = void 0;
+class CrudServiceOption {
     constructor() {
         this.existsCheck = true;
     }
 }
-exports.CoreCrudServiceOption = CoreCrudServiceOption;
+exports.CrudServiceOption = CrudServiceOption;

package/dist/interface/index.d.ts

@@ -1,2 +1,2 @@
-export * from './core-crud-service.option';
-export * from './core-crud-service.option';
+export * from './crud-service.option';
+export * from './crud-service.option';

package/dist/interface/index.js

@@ -14,5 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./core-crud-service.option"), exports);
-__exportStar(require("./core-crud-service.option"), exports);
+__exportStar(require("./crud-service.option"), exports);
+__exportStar(require("./crud-service.option"), exports);

package/dist/interface/kafka-failed-response.interface.d.ts

@@ -1,4 +1,4 @@
-import { BaseErrorResponse } from "../dto";
+import { BaseErrorResponse } from '../dto';
 export interface KafkaFailedResponseInterface {
     data?: BaseErrorResponse;
     event_source: string;

package/dist/services/core-crud.service.d.ts

@@ -3,29 +3,31 @@ import { BaseModelEntity } from '../entities';
 import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
 import { Paginated } from 'nestjs-paginate';
 import { PaginateConfig } from 'nestjs-paginate/lib/paginate';
-import { ObjectId } from 'typeorm/driver/mongodb/typings';
 import { PaginationQueryCustom } from '../interface/pagination-query';
 import { InsertResult } from 'typeorm/query-builder/result/InsertResult';
-import { CoreCrudServiceOption } from '../interface';
+import { CrudServiceOption } from '../interface';
 import { UpsertOptions } from 'typeorm/repository/UpsertOptions';
 export declare abstract class CoreCrudService<T extends BaseModelEntity, CreateDto, UpdateDto> {
     protected readonly repository: Repository<T>;
     private readonly relationsPath;
     protected constructor(repository: Repository<T>);
-    create(createDto: CreateDto, options?: CoreCrudServiceOption<T>): Promise<T>;
-    findAllWithPagination(query: PaginationQueryCustom, paginateConfig: PaginateConfig<T>, options?: CoreCrudServiceOption<T>): Promise<Paginated<T>>;
-    findAll(query: FindManyOptions<T>, options?: CoreCrudServiceOption<T>): Promise<T[]>;
-    findOneById(id: number, options?: CoreCrudServiceOption<T>): Promise<T>;
-    findOne(query: FindManyOptions<T>, options?: CoreCrudServiceOption<T>): Promise<T>;
-    isExists(query: FindManyOptions<T>, options?: CoreCrudServiceOption<T>): Promise<boolean>;
-    count(query: FindManyOptions<T>, options?: CoreCrudServiceOption<T>): Promise<number>;
-    upsert(upsertDto: QueryDeepPartialEntity<T>, upsertOptions: UpsertOptions<T>, options?: CoreCrudServiceOption<T>): Promise<InsertResult>;
-    update(id: number, updateDto: Partial<UpdateDto> | DeepPartial<T> | QueryDeepPartialEntity<T>, options?: CoreCrudServiceOption<T>): Promise<UpdateResult>;
-    softDelete(criteria: string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | FindOptionsWhere<T>, options?: CoreCrudServiceOption<T>): Promise<UpdateResult>;
-    softDeleteById(id: number, options?: CoreCrudServiceOption<T>): Promise<UpdateResult>;
-    delete(criteria: string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | FindOptionsWhere<T>, options?: CoreCrudServiceOption<T>): Promise<DeleteResult>;
-    deleteById(id: number, options?: CoreCrudServiceOption<T>): Promise<DeleteResult>;
-    private validateWhereQuery;
+    create(createDto: CreateDto, options?: CrudServiceOption<T>): Promise<T>;
+    findAllWithPagination(query: PaginationQueryCustom, paginateConfig: PaginateConfig<T>, options?: CrudServiceOption<T>): Promise<Paginated<T>>;
+    findAll(query: FindManyOptions<T>, options?: CrudServiceOption<T>): Promise<T[]>;
+    findOneById(id: number, options?: CrudServiceOption<T>): Promise<T>;
+    findOne(query: FindManyOptions<T>, options?: CrudServiceOption<T>): Promise<T>;
+    isExists(query: FindManyOptions<T>, options?: CrudServiceOption<T>): Promise<boolean>;
+    count(query: FindManyOptions<T>, options?: CrudServiceOption<T>): Promise<number>;
+    upsert(upsertDto: QueryDeepPartialEntity<T>, upsertOptions: UpsertOptions<T>, options?: CrudServiceOption<T>): Promise<InsertResult>;
+    update(id: number, updateDto: Partial<UpdateDto> | DeepPartial<T> | QueryDeepPartialEntity<T>, options?: CrudServiceOption<T>): Promise<UpdateResult>;
+    softDelete(query: FindOptionsWhere<T>, options?: CrudServiceOption<T>): Promise<UpdateResult>;
+    softDeleteById(id: string | string[] | number | number[], options?: CrudServiceOption<T>): Promise<UpdateResult>;
+    delete(query: FindOptionsWhere<T>, options?: CrudServiceOption<T>): Promise<DeleteResult>;
+    deleteById(id: string | string[] | number | number[], options?: CrudServiceOption<T>): Promise<DeleteResult>;
+    private relatedPropertyTransformer;
+    private whereQueryTransformer;
     private isObject;
     private isArray;
+    private isArrayOfObjectId;
+    private isArrayOfNumbers;
 }

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

@@ -1,33 +1,18 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoreCrudService = void 0;
-const typeorm_1 = require("typeorm");
 const common_1 = require("@nestjs/common");
 const nestjs_paginate_1 = require("nestjs-paginate");
 const enums_1 = require("../enums");
 const helpers_1 = require("../helpers");
-let CoreCrudService = class CoreCrudService {
+class CoreCrudService {
     constructor(repository) {
         this.repository = repository;
         const metadata = this.repository.metadata;
         this.relationsPath = metadata.relations.map((relation) => relation.propertyPath);
     }
     async create(createDto, options) {
-        const relationEntityName = Object.keys(createDto).filter((item) => this.relationsPath.includes(item) && createDto[item]);
-        relationEntityName.map((item) => {
-            createDto[item] = createDto[item].map((id) => {
-                return { id };
-            });
-        });
+        createDto = this.relatedPropertyTransformer(createDto);
         const entity = this.repository.create(createDto);
         if (options?.entityManager) {
             return await options.entityManager.save(entity);
@@ -44,18 +29,19 @@ let CoreCrudService = class CoreCrudService {
     }
     async findAll(query, options) {
         let result;
+        query.where = this.whereQueryTransformer(query.where) ?? undefined;
         if (!options?.entityManager)
             result = await this.repository.find({
-                relations: this.relationsPath,
+                relations: options?.relations ? options?.relations : this.relationsPath,
                 ...query,
             });
         else
             result = await options.entityManager.find(this.repository.target, {
-                relations: this.relationsPath,
+                relations: options?.relations ? options?.relations : this.relationsPath,
                 ...query,
             });
         if (options?.existsCheck && !result) {
-            throw new common_1.NotFoundException(enums_1.SharedMessages.RESOURCE_NOT_FOUND);
+            throw new common_1.NotFoundException(helpers_1.MessageFormatter.replace(enums_1.SharedMessages.RESOURCE_NOT_FOUND, `${helpers_1.ConvertStringCaseHelper.snakeToKebab(this.repository.metadata?.tableName)}`));
         }
         return result;
     }
@@ -83,15 +69,11 @@ let CoreCrudService = class CoreCrudService {
         return result;
     }
     async findOne(query, options) {
-        const whereQuery = this.validateWhereQuery(query.where);
-        if (!whereQuery) {
-            return undefined;
-        }
-        query.where = whereQuery;
         let result;
+        query.where = this.whereQueryTransformer(query.where) ?? undefined;
         if (options?.entityManager) {
             result = await options?.entityManager.findOne(this.repository.target, {
-                relations: this.relationsPath,
+                relations: options?.relations ? options?.relations : this.relationsPath,
                 ...query,
             });
         }
@@ -102,12 +84,13 @@ let CoreCrudService = class CoreCrudService {
             });
         }
         if (options?.existsCheck && !result) {
-            throw new common_1.NotFoundException(enums_1.SharedMessages.RESOURCE_NOT_FOUND);
+            throw new common_1.NotFoundException(helpers_1.MessageFormatter.replace(enums_1.SharedMessages.RESOURCE_NOT_FOUND, `${helpers_1.ConvertStringCaseHelper.snakeToKebab(this.repository.metadata?.tableName)}`));
         }
         return result;
     }
     async isExists(query, options) {
         let result;
+        query.where = this.whereQueryTransformer(query.where) ?? undefined;
         if (options?.entityManager) {
             result = await options?.entityManager.exists(this.repository.target, {
                 relations: query?.relations ? query?.relations : this.relationsPath,
@@ -123,12 +106,8 @@ let CoreCrudService = class CoreCrudService {
         return result;
     }
     async count(query, options) {
-        const whereQuery = this.validateWhereQuery(query.where);
-        if (!whereQuery) {
-            return undefined;
-        }
-        query.where = whereQuery;
         let result;
+        query.where = this.whereQueryTransformer(query.where) ?? undefined;
         if (options?.entityManager) {
             result = await options?.entityManager.count(this.repository.target, {
                 relations: query?.relations ? query?.relations : this.relationsPath,
@@ -145,6 +124,7 @@ let CoreCrudService = class CoreCrudService {
     }
     async upsert(upsertDto, upsertOptions, options) {
         try {
+            upsertDto = this.relatedPropertyTransformer(upsertDto);
             let conflictPaths = [];
             let findWhereQuery = {};
             if (this.isArray(upsertOptions.conflictPaths)) {
@@ -159,16 +139,17 @@ let CoreCrudService = class CoreCrudService {
                     [path]: upsertDto[path],
                 };
             });
+            const formatedQuery = this.whereQueryTransformer(findWhereQuery) ?? undefined;
             if (!options?.entityManager) {
                 const existEntity = await this.repository.findOne({
-                    where: findWhereQuery,
+                    where: formatedQuery,
                     select: ['id'],
                 });
                 return await this.repository.upsert({ id: existEntity.id, ...upsertDto }, upsertOptions);
             }
             else {
                 const existEntity = await options?.entityManager.findOne(this.repository.target, {
-                    where: findWhereQuery,
+                    where: formatedQuery,
                     select: ['id'],
                 });
                 return await options?.entityManager.upsert(this.repository.target, { id: existEntity.id, ...upsertDto }, upsertOptions);
@@ -179,20 +160,14 @@ let CoreCrudService = class CoreCrudService {
         }
     }
     async update(id, updateDto, options) {
+        updateDto = this.relatedPropertyTransformer(updateDto);
         if (!options?.entityManager) {
             const fetchedItem = await this.repository.findOne({
                 where: { id },
-                relations: this.relationsPath,
+                relations: options?.relations ? options?.relations : this.relationsPath,
             });
             if (!fetchedItem)
-                throw new common_1.NotFoundException(enums_1.SharedMessages.RESOURCE_NOT_FOUND);
-            const relationEntityName = Object.keys(updateDto).filter((item) => this.relationsPath.includes(item) && updateDto[item]);
-            relationEntityName.map((item) => {
-                delete fetchedItem[item];
-                updateDto[item] = updateDto[item].map((id) => {
-                    return { id };
-                });
-            });
+                throw new common_1.NotFoundException(helpers_1.MessageFormatter.replace(enums_1.SharedMessages.RESOURCE_NOT_FOUND, `${helpers_1.ConvertStringCaseHelper.snakeToKebab(this.repository.metadata?.tableName)}`));
             const merged = this.repository.merge(fetchedItem, updateDto);
             await this.repository.save(merged);
             return {
@@ -207,14 +182,7 @@ let CoreCrudService = class CoreCrudService {
                 relations: this.relationsPath,
             });
             if (!fetchedItem)
-                throw new common_1.NotFoundException(enums_1.SharedMessages.RESOURCE_NOT_FOUND);
-            const relationEntityName = Object.keys(updateDto).filter((item) => this.relationsPath.includes(item) && updateDto[item]);
-            relationEntityName.map((item) => {
-                delete fetchedItem[item];
-                updateDto[item] = updateDto[item].map((id) => {
-                    return { id };
-                });
-            });
+                throw new common_1.NotFoundException(helpers_1.MessageFormatter.replace(enums_1.SharedMessages.RESOURCE_NOT_FOUND, `${helpers_1.ConvertStringCaseHelper.snakeToKebab(this.repository.metadata?.tableName)}`));
             const merged = options?.entityManager.merge(this.repository.target, fetchedItem, updateDto);
             await options?.entityManager.save(merged);
             return {
@@ -224,12 +192,13 @@ let CoreCrudService = class CoreCrudService {
             };
         }
     }
-    async softDelete(criteria, options) {
+    async softDelete(query, options) {
+        const formatedQuery = this.whereQueryTransformer(query) ?? undefined;
         if (options?.entityManager) {
-            return await options?.entityManager.softDelete(this.repository.target, criteria);
+            return await options?.entityManager.softDelete(this.repository.target, formatedQuery);
         }
         else {
-            return await this.repository.softDelete(criteria);
+            return await this.repository.softDelete(formatedQuery);
         }
     }
     async softDeleteById(id, options) {
@@ -240,12 +209,13 @@ let CoreCrudService = class CoreCrudService {
             return await this.repository.softDelete(id);
         }
     }
-    async delete(criteria, options) {
+    async delete(query, options) {
+        const formatedQuery = this.whereQueryTransformer(query) ?? undefined;
         if (options?.entityManager) {
-            return await options?.entityManager.delete(this.repository.target, criteria);
+            return await options?.entityManager.delete(this.repository.target, formatedQuery);
         }
         else {
-            return await this.repository.delete(criteria);
+            return await this.repository.delete(formatedQuery);
         }
     }
     async deleteById(id, options) {
@@ -256,52 +226,58 @@ let CoreCrudService = class CoreCrudService {
             return await this.repository.delete(id);
         }
     }
-    validateWhereQuery(query) {
-        if (this.isArray(query)) {
-            const newArrayQuery = [];
-            query = query;
-            if (query.length !== 0) {
-                query.map((key, index) => {
-                    if (this.isArray(query[index])) {
-                        return query[index].map((item) => this.validateWhereQuery(item));
-                    }
-                    if (this.isObject(query[index])) {
-                        this.validateWhereQuery(query[index]);
-                    }
-                    if (query[index] !== undefined) {
-                        newArrayQuery.push({
-                            [index]: query[index],
-                        });
-                    }
+    relatedPropertyTransformer(dtoObject) {
+        const relationEntityName = Object.keys(dtoObject).filter((item) => this.relationsPath.includes(item) && dtoObject[item]);
+        relationEntityName.map((item) => {
+            let relatedItem;
+            if (this.isArrayOfNumbers(dtoObject[item])) {
+                relatedItem = dtoObject[item].map((id) => {
+                    return { id };
                 });
             }
-            if (Object.keys(newArrayQuery).length === 0)
-                return undefined;
-            return newArrayQuery;
+            else {
+                relatedItem = dtoObject[item];
+            }
+            dtoObject[item] = relatedItem;
+        });
+        return dtoObject;
+    }
+    whereQueryTransformer(query) {
+        if (typeof query === 'object' && Array.isArray(query)) {
+            const newArrayQuery = query
+                .map((item) => this.whereQueryTransformer(item))
+                .filter((item) => item !== undefined);
+            return newArrayQuery.length > 0 ? newArrayQuery : undefined;
         }
-        else {
-            let newQuery = {};
-            const queryKeys = Object.keys(query);
-            if (queryKeys.length !== 0) {
-                queryKeys.map((key) => {
-                    if (this.isArray(query[key])) {
-                        return query[key].map((item) => this.validateWhereQuery(item));
+        else if (this.isObject(query)) {
+            const newQuery = {};
+            for (const key in query) {
+                if (query.hasOwnProperty(key)) {
+                    const value = query[key];
+                    if (typeof value === 'object' && Array.isArray(value)) {
+                        const validatedArray = value
+                            .map((item) => this.whereQueryTransformer(item))
+                            .filter((item) => item !== undefined);
+                        if (validatedArray.length > 0) {
+                            newQuery[key] = validatedArray;
+                        }
                     }
-                    if (this.isObject(query[key])) {
-                        this.validateWhereQuery(query[key]);
+                    else if (value !== null &&
+                        typeof value === 'object' &&
+                        !Array.isArray(value)) {
+                        const validatedObject = this.whereQueryTransformer(value);
+                        if (validatedObject !== undefined) {
+                            newQuery[key] = validatedObject;
+                        }
                     }
-                    if (query[key] !== undefined) {
-                        newQuery = {
-                            ...newQuery,
-                            [key]: query[key],
-                        };
+                    else if (value !== undefined) {
+                        newQuery[key] = value;
                     }
-                });
+                }
             }
-            if (Object.keys(newQuery).length === 0)
-                return undefined;
-            return newQuery;
+            return Object.keys(newQuery).length > 0 ? newQuery : undefined;
         }
+        return undefined;
     }
     isObject(value) {
         return value !== null && typeof value === 'object' && !Array.isArray(value);
@@ -309,9 +285,12 @@ let CoreCrudService = class CoreCrudService {
     isArray(value) {
         return value !== null && typeof value === 'object' && Array.isArray(value);
     }
-};
+    isArrayOfObjectId(value) {
+        return (this.isArray(value) &&
+            value.every((item) => this.isObject(item) && item?.id));
+    }
+    isArrayOfNumbers(value) {
+        return (this.isArray(value) && value.every((item) => typeof item === 'number'));
+    }
+}
 exports.CoreCrudService = CoreCrudService;
-exports.CoreCrudService = CoreCrudService = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [typeorm_1.Repository])
-], CoreCrudService);