rez_core 1.0.79 → 1.0.80

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "1.0.79",
+  "version": "1.0.80",
   "description": "",
   "author": "",
   "private": false,

package/src/module/meta/service/entity-service-impl.service.ts

@@ -16,6 +16,7 @@ import { ExcelsheetData } from '../../../utils/dto/excelsheet-data.dto';
 import { EntityTableService } from './entity-table.service';
 import { EntityTableColumnService } from './entity-table-column.service';
 import { ENTITYTYPE_ENTITYMASTER } from '../../../constant/global.constant';
+import { EntityValidationService } from './entity-validation.service';
 
 @Injectable()
 export class EntityServiceImpl implements EntityService<BaseEntity> {
@@ -26,12 +27,15 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
   @Inject() protected readonly reflectionHelper: ReflectionHelper;
   @Inject() protected readonly entityListService: EntityListService;
   @Inject() protected readonly loggingService: LoggingService;
+  @Inject()
+protected readonly entityValidationService: EntityValidationService;
+
 
   async createEntity(
     entityData: BaseEntity,
     loggedInUser: UserData | null,
     manager?: EntityManager,
-  ): Promise<BaseEntity> {
+  ){
     if (!entityData.entity_type) {
       throw new BadRequestException(`EntityType is missing`);
     }
@@ -39,6 +43,16 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
       entityData.entity_type,
     );
 
+    const validationErrors = await this.entityValidationService.validateEntityData(entityData,entityMaster);
+    if (validationErrors.length > 0) {
+      
+     return {
+        success: false,
+        errors: validationErrors,
+      };
+     
+    }
+
     const repo = manager
       ? manager.getRepository(entityMaster.entity_data_class) // <-- Use transaction-safe repo
       : this.reflectionHelper.getRepoService(entityMaster.entity_data_class);

package/src/module/meta/service/entity-validation.service.ts

@@ -2,6 +2,7 @@ import { Injectable } from '@nestjs/common';
 import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
 import { AttributeMaster } from '../entity/attribute-master.entity';
 import { ReflectionHelper } from 'src/utils/service/reflection-helper.service';
+import { DataSource } from 'typeorm';
 
 interface ValidationError {
   field: string;
@@ -12,7 +13,8 @@ interface ValidationError {
 export class EntityValidationService {
   constructor(
     private readonly attributeMasterService: AttributeMasterService,
-    private readonly reflectionHelper: ReflectionHelper 
+    private readonly reflectionHelper: ReflectionHelper,
+    private dataSource: DataSource
   ) {}
 
   /**
@@ -27,11 +29,11 @@ export class EntityValidationService {
     attributeData
       .filter(attr => attr.required)
       .forEach(attr => {
-        const value = entityData[attr.code];
+        const value = entityData[attr.attribute_key];
         if (!this.hasValidValue(value)) {
           errors.push({
-            field: attr.code,
-            message: `Field "${attr.code}" is required.`,
+            field: attr.name,
+            message: `Field ${attr.name} is required.`,
           });
         }
       });
@@ -45,24 +47,27 @@ export class EntityValidationService {
   async validateUniqueFields(
     entityData: Record<string, any>,
     attributeData: AttributeMaster[],
-    entityType: string
+    entityType: string,
+    db_table_name: string
   ): Promise<ValidationError[]> {
     const errors: ValidationError[] = [];
   
-    const repo = this.reflectionHelper.getRepoService(entityData.entity_type);
-  
-    if (!repo) {
-      throw new Error(`Repository service not found for entityType: ${entityType}`);
-    }
-  
     for (const attr of attributeData.filter(a => a.is_unique)) {
-      const value = entityData[attr.code];
+      const value = entityData[attr.attribute_key];
+  
       if (this.hasValidValue(value)) {
-        const existing = await repo.findOne({ where: { [attr.code]: value } });
+        const existing = await this.dataSource
+          .createQueryBuilder()
+          .select("*")
+          .from(db_table_name, db_table_name)
+          .where(`${db_table_name}.${attr.attribute_key} = :value`, { value })
+          .limit(1)
+          .getRawOne();
+  
         if (existing) {
           errors.push({
-            field: attr.code,
-            message: `Field "${attr.code}" must be unique. Value "${value}" already exists.`,
+            field: attr.name,
+            message: `Field ${attr.name} must be unique. Value ${value} already exists.`,
           });
         }
       }
@@ -71,17 +76,17 @@ export class EntityValidationService {
     return errors;
   }
   
-
   /**
    * Validates both required and unique fields for a given entity type.
    */
   async validateEntityData(
-    entityData: Record<string, any>
+    entityData: Record<string, any>,
+    entityMaster
   ): Promise<ValidationError[]> {
     const attributes = await this.attributeMasterService.findAttributesByMappedEntityType(entityData.entity_type);
   
     const requiredErrors = this.validateRequiredFields(entityData, attributes);
-    const uniqueErrors = await this.validateUniqueFields(entityData, attributes, entityData.entity_type);
+    const uniqueErrors = await this.validateUniqueFields(entityData, attributes, entityData.entity_type,entityMaster.db_table_name);
   
     return [...requiredErrors, ...uniqueErrors];
   }