rez_core 4.0.246 → 4.0.291

package/package.json

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

package/src/module/entity_json/entity_json.module.ts

@@ -6,12 +6,11 @@ import { EntityJSONController } from './controller/entity_json.controller';
 import { FilterModule } from '../filter/filter.module';
 import { UtilsModule } from 'src/utils/utils.module';
 import { EntityJson } from './entity/entityJson.entity';
-import { EntityJSONRepository } from './service/entityJson.repository';
 
 @Module({
   imports: [EntityModule, TypeOrmModule.forFeature([EntityJson]),FilterModule,UtilsModule],
   controllers: [EntityJSONController],
-  providers: [EntityJSONService,EntityJSONRepository],
+  providers: [EntityJSONService],
   exports: [],
 })
 export class EntityJSONModule {}

package/src/module/entity_json/service/entity_json.service.ts

@@ -6,15 +6,13 @@ import { EntityRelation } from 'src/module/meta/entity/entity-relation.entity';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { LoggingService } from 'src/utils/service/loggingUtil.service';
 import { DataSource } from 'typeorm';
-import { EntityJSONRepository } from './entityJson.repository';
 
 @Injectable()
 export class EntityJSONService extends EntityServiceImpl {
   constructor(
     private readonly dataSource: DataSource,
     private readonly filterService: FilterService,
-    private readonly loggerService: LoggingService,
-    private readonly EntityJSONRepository:EntityJSONRepository
+    private readonly loggerService: LoggingService, // <-- inject logging service
   ) {
     super();
   }
@@ -25,18 +23,27 @@ export class EntityJSONService extends EntityServiceImpl {
     flag?: 'flat_json' | 'dropdown' | 'all',
   ) {
     const orgId = loggedInUser.organization_id;
-
-    await this.loggerService.log('info', 'EntityJSONService', 'getAttributeForFlatJSON', `Loading attributes for entity: ${entityType}, org: ${orgId}`);
+    await this.loggerService.log(
+      'info',
+      'EntityJSONService',
+      'getAttributeForFlatJSON',
+      `Loading attributes for entity: ${entityType}, org: ${orgId}`,
+    );
 
     const mainAttributes = await this.dataSource
       .getRepository(AttributeMaster)
       .createQueryBuilder('attr')
-      .select(['attr.id', 'attr.name', 'attr.flat_json_key', 'attr.attribute_key'])
+      .select(['attr.id', 'attr.name', 'attr.flat_json_key','attr.attribute_key'])
       .where('attr.mapped_entity_type = :entityType', { entityType })
       .andWhere('attr.organization_id = :orgId', { orgId })
       .getMany();
 
-    await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Loaded ${mainAttributes.length} main attributes`);
+    await this.loggerService.log(
+      'debug',
+      'EntityJSONService',
+      'getAttributeForFlatJSON',
+      `Loaded ${mainAttributes.length} main attributes`,
+    );
 
     const relatedEntityTypes = await this.dataSource
       .getRepository(EntityRelation)
@@ -44,24 +51,44 @@ export class EntityJSONService extends EntityServiceImpl {
       .select(['rel.target_entity_type'])
       .where('rel.source_entity_type = :entityType', { entityType })
       .andWhere('rel.organization_id = :orgId', { orgId })
-      .andWhere('rel.relation_type = :relationType', { relationType: 'ONE_TO_ONE' })
+      .andWhere('rel.relation_type = :relationType', {
+        relationType: 'ONE_TO_ONE',
+      })
       .getRawMany();
 
-    const relatedTypesList = relatedEntityTypes.map(x => x.rel_target_entity_type);
-
-    await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Found ${relatedTypesList.length} ONE-TO-ONE related entity types`);
+    const relatedTypesList = relatedEntityTypes.map(
+      (x) => x.rel_target_entity_type,
+    );
+    await this.loggerService.log(
+      'debug',
+      'EntityJSONService',
+      'getAttributeForFlatJSON',
+      `Found ${relatedTypesList.length} ONE-TO-ONE related entity types`,
+    );
 
     const relatedAttributes = relatedTypesList.length
       ? await this.dataSource
           .getRepository(AttributeMaster)
           .createQueryBuilder('attr')
-          .select(['attr.id', 'attr.name', 'attr.flat_json_key', 'attr.mapped_entity_type', 'attr.attribute_key'])
-          .where('attr.mapped_entity_type IN (:...types)', { types: relatedTypesList })
+          .select([
+            'attr.id',
+            'attr.name',
+            'attr.flat_json_key',
+            'attr.mapped_entity_type',
+            'attr.attribute_key',
+          ])
+          .where('attr.mapped_entity_type IN (:...types)', {
+            types: relatedTypesList,
+          })
           .andWhere('attr.organization_id = :orgId', { orgId })
           .getMany()
       : [];
-
-    await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Loaded ${relatedAttributes.length} related attributes`);
+    await this.loggerService.log(
+      'debug',
+      'EntityJSONService',
+      'getAttributeForFlatJSON',
+      `Loaded ${relatedAttributes.length} related attributes`,
+    );
 
     const linkedAttributes = await this.dataSource
       .getRepository(LinkedAttributes)
@@ -72,67 +99,103 @@ export class EntityJSONService extends EntityServiceImpl {
         'fla.applicable_entity_type = attr.mapped_entity_type AND fla.applicable_attribute_key = attr.attribute_key',
       )
       .select([
-        'fla.applicable_entity_type AS applicable_entity_type',
-        'fla.applicable_attribute_key AS applicable_attribute_key',
-        'fla.attribute_key AS target_attribute_key',
-        'fla.saved_filter_code AS saved_filter_code',
-        'attr.name AS name',
-        'attr.id AS id',
+        'fla.applicable_entity_type',
+        'attr.id',
+        'attr.name',
+        'attr.attribute_key',
       ])
       .where('attr.organization_id = :orgId', { orgId })
       .getRawMany();
-
-    await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Loaded ${linkedAttributes.length} linked attributes`);
+    await this.loggerService.log(
+      'debug',
+      'EntityJSONService',
+      'getAttributeForFlatJSON',
+      `Loaded ${linkedAttributes.length} linked attributes`,
+    );
 
     if (flag === 'flat_json' || flag === 'all') {
       const result: Record<string, null> = {};
-      mainAttributes.forEach(attr => { if (attr.flat_json_key) result[attr.flat_json_key] = null; });
-      relatedAttributes.forEach(attr => { if (attr.flat_json_key) result[attr.flat_json_key] = null; });
-      linkedAttributes.forEach(link => { if (link.target_attribute_key) result[link.target_attribute_key] = null; });
-
-      if (flag === 'all') {
-        return { flat_json: result, attributes: { mainAttributes, relatedAttributes, linkedAttributes } };
-      }
-
-      return result;
+      mainAttributes.forEach((attr) => {
+        if (attr.flat_json_key) result[attr.flat_json_key] = null;
+      });
+      relatedAttributes.forEach((attr) => {
+        if (attr.flat_json_key) result[attr.flat_json_key] = null;
+      });
+      linkedAttributes.forEach((link) => {
+        if (link.applicable_attribute_key)
+          result[link.applicable_attribute_key] = null;
+      });
+      if(flag === 'all')
+        return {flat_json: result,attributes: {mainAttributes,relatedAttributes,linkedAttributes}};
+
+        return result;
     }
 
     const dropdown: any[] = [];
-    dropdown.push(...mainAttributes.map(a => ({ label: a.name, value: a.flat_json_key })));
-    dropdown.push(...relatedAttributes.map(a => ({ label: a.name, value: a.flat_json_key })));
+    dropdown.push(
+      ...mainAttributes.map((a) => ({ label: a.name, value: a.flat_json_key })),
+    );
+    dropdown.push(
+      ...relatedAttributes.map((a) => ({
+        label: a.name,
+        value: a.flat_json_key,
+      })),
+    );
     if (linkedAttributes.length > 0) {
-      dropdown.push(...linkedAttributes.map(a => ({ label: a.name, value: a.attribute_key })));
+      dropdown.push({
+        ...linkedAttributes.map((a) => ({
+          label: a.name,
+          value: a.attribute_key,
+        })),
+      });
     }
-
     return dropdown;
   }
 
   async updateEntityJSON(entityType: string, entityId: number, loggedInUser) {
-    await this.loggerService.log('info', 'EntityJSONService', 'updateEntityJSON', `Building flat JSON for entity: ${entityType}#${entityId}`);
-
+    await this.loggerService.log(
+      'info',
+      'EntityJSONService',
+      'updateEntityJSON',
+      `Building flat JSON for entity: ${entityType}#${entityId}`,
+    );
+  
+    // 1. Load flat JSON template + attributes
     const response = await this.getAttributeForFlatJSON(entityType, loggedInUser, 'all');
-
+  
+    // ---- Structural validation ----
     if (!response || !('flat_json' in response) || !('attributes' in response) || !response.attributes) {
-      await this.loggerService.log('error', 'EntityJSONService', 'updateEntityJSON', `getAttributeForFlatJSON() did not return expected structure`);
+      await this.loggerService.log(
+        'error',
+        'EntityJSONService',
+        'updateEntityJSON',
+        `getAttributeForFlatJSON() did not return expected structure`,
+      );
       return null;
     }
-
+  
     const { flat_json: flatJson, attributes } = response;
     if (!flatJson) return null;
-
+  
+    // ---- Strong safety fix ----
     const safeAttributes = {
       mainAttributes: attributes.mainAttributes || [],
       relatedAttributes: attributes.relatedAttributes || [],
       linkedAttributes: attributes.linkedAttributes || [],
     };
-
+  
+    // 2. Build attribute_key → flat_json_key map
     const attrMap: Record<string, string> = {};
     const allAttrs = [...safeAttributes.mainAttributes, ...safeAttributes.relatedAttributes];
-    allAttrs.forEach(attr => { if (attr.attribute_key) attrMap[attr.attribute_key] = attr.flat_json_key || attr.attribute_key; });
-
+    allAttrs.forEach(attr => {
+      if (attr.attribute_key) attrMap[attr.attribute_key] = attr.flat_json_key || attr.attribute_key;
+    });
+  
+    // 3. Merge main entity data
     const mainData = await this.getResolvedEntityData(entityType, entityId, loggedInUser);
     this.mergeEntityDataIntoFlatJson(flatJson, mainData, attrMap);
-
+  
+    // 4. Merge ONE-TO-ONE related entities
     const relations = await this.dataSource
       .getRepository('frm_entity_relation_data')
       .createQueryBuilder('erd')
@@ -141,62 +204,67 @@ export class EntityJSONService extends EntityServiceImpl {
       .andWhere('erd.source_entity_id = :entityId', { entityId })
       .andWhere('erd.relation_type = :rt', { rt: 'ONE_TO_ONE' })
       .getRawMany();
-
+  
     for (const rel of relations) {
       const relatedData = await this.getResolvedEntityData(rel.target_entity_type, rel.target_entity_id, loggedInUser);
       this.mergeEntityDataIntoFlatJson(flatJson, relatedData, attrMap);
     }
-
+  
+    // 5. Merge linked attributes using saved filters
     for (const linkAttr of safeAttributes.linkedAttributes) {
-      const childEntityType = linkAttr.applicable_entity_type;
-      const sourceKey = linkAttr.applicable_attribute_key;
-      const targetKey = linkAttr.target_attribute_key;
-
-      if (!childEntityType || !sourceKey || !targetKey) continue;
-
-      const mappingValue = mainData?.[sourceKey] ?? null;
-
+      if (!linkAttr.applicable_entity_type || !linkAttr.applicable_attribute_key) continue;
+  
+      const mappingValue = mainData?.[linkAttr.parent_attribute_key || ''] ?? null;
       const value = await this.applyLinkedFilterUsingSavedFilter(
-        childEntityType,
+        linkAttr.applicable_entity_type,
         linkAttr.saved_filter_code,
-        sourceKey,
+        linkAttr.applicable_attribute_key,
         mappingValue,
-        targetKey,
+        linkAttr.target_attribute_key || linkAttr.applicable_attribute_key,
         loggedInUser,
         entityId,
       );
-
+  
       if (value !== null && value !== undefined) {
-        flatJson[targetKey] = value;
+        const flatKey = attrMap[linkAttr.target_attribute_key || linkAttr.applicable_attribute_key]
+          || (linkAttr.target_attribute_key || linkAttr.applicable_attribute_key);
+        flatJson[flatKey] = value;
       }
     }
-
-    await this.loggerService.log('info', 'EntityJSONService', 'updateEntityJSON', `Saving flat JSON for entity: ${entityType}#${entityId}`);
-    let JsonData = {
-      entity_type: entityType,
-      entity_id: entityId,
-      json_data: flatJson,
-      created_by: loggedInUser.id,
-    }
-    
-    await this.EntityJSONRepository.create(JsonData);
-
+  
+    // 6. Save JSON
+    await this.dataSource.query(
+      `INSERT INTO frm_entity_json (entity_type, entity_id, json_data, created_by)
+         VALUES (?, ?, ?, ?)
+         ON DUPLICATE KEY UPDATE json_data = VALUES(json_data), updated_by = VALUES(created_by)`,
+      [entityType, entityId, JSON.stringify(flatJson), loggedInUser.id],
+    );
+  
     return flatJson;
   }
-
-  private mergeEntityDataIntoFlatJson(flatJson: Record<string, any>, entityData: any | any[], attrMap: Record<string, string>) {
+  
+  
+  // Helper: Merge entity data using attribute_key → flat_json_key mapping
+  private mergeEntityDataIntoFlatJson(
+    flatJson: Record<string, any>,
+    entityData: any | any[], // accept both object or array
+    attrMap: Record<string, string>,
+  ) {
     const records = Array.isArray(entityData) ? entityData : [entityData];
-
+  
     for (const record of records) {
       if (!record || typeof record !== 'object') continue;
+  
       for (const key of Object.keys(record)) {
-        const flatKey = attrMap[key] || key;
+        const flatKey = attrMap[key] || key; // map to flat_json_key if exists
         if (flatJson.hasOwnProperty(flatKey)) {
           flatJson[flatKey] = record[key];
         }
       }
     }
   }
+  
+  
 
   private async applyLinkedFilterUsingSavedFilter(
     childEntityType: string,
@@ -207,7 +275,11 @@ export class EntityJSONService extends EntityServiceImpl {
     loggedInUser,
     entity_id
   ) {
-    if (!savedFilterCode && (mappingValue === null || mappingValue === undefined)) return null;
+    if (
+      !savedFilterCode &&
+      (mappingValue === null || mappingValue === undefined)
+    )
+      return null;
 
     const dto: any = {
       entity_type: childEntityType,
@@ -217,18 +289,30 @@ export class EntityJSONService extends EntityServiceImpl {
       size: 1,
     };
 
-    if (mappingValue !== null && mappingValue !== undefined && mappingValue !== '') {
+    if (
+      mappingValue !== null &&
+      mappingValue !== undefined &&
+      mappingValue !== ''
+    ) {
       dto.quickFilter = [
-        { filter_attribute: childFilterAttribute, filter_operator: 'equal', filter_value: mappingValue },
+        {
+          filter_attribute: childFilterAttribute,
+          filter_operator: 'equal',
+          filter_value: mappingValue,
+        },
       ];
     }
 
     dto.quickFilter = [
-      { filter_attribute: 'parent_id', filter_operator: 'equal', filter_value: [entity_id] },
+      {
+        filter_attribute: 'parent_id',
+        filter_operator: 'equal',
+        filter_value: entity_id,
+      },
     ];
 
     const result = await this.filterService.applyFilter(dto);
     const rows = result?.data?.entity_list || [];
-    return rows.length ? (rows[0][childFilterAttribute] ?? null) : null;
+    return rows.length ? (rows[0][targetAttribute] ?? null) : null;
   }
 }

package/src/module/filter/service/filter.service.ts

@@ -848,13 +848,107 @@ export class FilterService {
   }
 
   private buildDateCondition(attr: string, op: string, val: any, key: string) {
+    const dateColumn = `DATE(e.${attr})`;
+    const monthColumn = `DATE_TRUNC('month', e.${attr})`;
+
+    const numVal = Number(val);
+
     switch (op) {
+      // ===== BASIC COMPARISONS =====
       case 'equal':
-        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
+      case 'is':
+        return {
+          query: `${dateColumn} = :${key}`,
+          params: { [key]: val },
+        };
+
       case 'before':
-        return { query: `e.${attr} < :${key}`, params: { [key]: val } };
+      case 'is_before':
+        return {
+          query: `${dateColumn} < :${key}`,
+          params: { [key]: val },
+        };
+
       case 'after':
-        return { query: `e.${attr} > :${key}`, params: { [key]: val } };
+      case 'is_after':
+        return {
+          query: `${dateColumn} > :${key}`,
+          params: { [key]: val },
+        };
+
+      case 'is_on_or_before':
+        return {
+          query: `${dateColumn} <= :${key}`,
+          params: { [key]: val },
+        };
+
+      case 'is_on_or_after':
+        return {
+          query: `${dateColumn} >= :${key}`,
+          params: { [key]: val },
+        };
+
+      // ===== MONTH COMPARISONS (NUMERIC OR DATE) =====
+      case 'is_month_before':
+        if (!isNaN(numVal)) {
+          const target = moment()
+            .subtract(numVal, 'months')
+            .startOf('month')
+            .format('YYYY-MM-DD');
+          return {
+            query: `${monthColumn} < DATE_TRUNC('month', :${key})`,
+            params: { [key]: target },
+          };
+        }
+        return {
+          query: `${monthColumn} < DATE_TRUNC('month', :${key})`,
+          params: { [key]: val },
+        };
+
+      case 'is_month_after':
+        if (!isNaN(numVal)) {
+          const target = moment()
+            .add(numVal, 'months')
+            .startOf('month')
+            .format('YYYY-MM-DD');
+          return {
+            query: `${monthColumn} > DATE_TRUNC('month', :${key})`,
+            params: { [key]: target },
+          };
+        }
+        return {
+          query: `${monthColumn} > DATE_TRUNC('month', :${key})`,
+          params: { [key]: val },
+        };
+
+      // ===== DAY BEFORE / AFTER WITH MOMENT =====
+      case 'is_day_before':
+        if (isNaN(numVal))
+          throw new BadRequestException(
+            'Value must be a number for is_day_before',
+          );
+
+        return {
+          query: `${dateColumn} < :${key}`,
+          params: {
+            [key]: moment().subtract(numVal, 'days').format('YYYY-MM-DD'),
+          },
+        };
+
+      case 'is_day_after':
+        if (isNaN(numVal))
+          throw new BadRequestException(
+            'Value must be a number for is_day_after',
+          );
+
+        return {
+          query: `${dateColumn} > :${key}`,
+          params: {
+            [key]: moment().add(numVal, 'days').format('YYYY-MM-DD'),
+          },
+        };
+
+      // ===== BETWEEN =====
       case 'between': {
         if (typeof val === 'string') {
           val = val.split(',').map((v) => v.trim());
@@ -866,12 +960,12 @@ export class FilterService {
           val[0] === '' ||
           val[1] === ''
         ) {
-          // throw new BadRequestException(`Invalid value for in_between: ${val}`);
-          console.log(`Invalid value for in_between: ${val}`);
+          console.log(`Invalid value for between: ${val}`);
           return null;
         }
+
         return {
-          query: `e.${attr} BETWEEN :${key}_start AND :${key}_end`,
+          query: `${dateColumn} BETWEEN :${key}_start AND :${key}_end`,
           params: {
             [`${key}_start`]: val[0],
             [`${key}_end`]: val[1],
@@ -879,30 +973,29 @@ export class FilterService {
         };
       }
 
+      // ===== TODAY =====
       case 'today': {
-        const today = new Date().toISOString().split('T')[0]; // 'YYYY-MM-DD'
-
+        const today = moment().format('YYYY-MM-DD');
         return {
-          query: `DATE(e.${attr}) = :today`,
-          params: {
-            today,
-          },
+          query: `${dateColumn} = :today`,
+          params: { today },
         };
       }
 
-      case 'empty': {
+      // ===== EMPTY =====
+      case 'empty':
+      case 'is_empty':
         return {
           query: `e.${attr} IS NULL`,
           params: {},
         };
-      }
 
-      case 'not_empty': {
+      case 'not_empty':
         return {
           query: `e.${attr} IS NOT NULL`,
           params: {},
         };
-      }
+
       default:
         throw new BadRequestException(`Unsupported operator for date: ${op}`);
     }

package/dist/module/entity_json/service/entityJson.repository.d.ts

@@ -1,7 +0,0 @@
-import { Repository } from "typeorm";
-import { EntityJson } from "../entity/entityJson.entity";
-export declare class EntityJSONRepository {
-    private readonly entityJSONRepository;
-    constructor(entityJSONRepository: Repository<EntityJson>);
-    create(flatJson: Partial<EntityJson>): Promise<EntityJson | null>;
-}

package/dist/module/entity_json/service/entityJson.repository.js

@@ -1,45 +0,0 @@
-"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);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityJSONRepository = void 0;
-const common_1 = require("@nestjs/common");
-const typeorm_1 = require("@nestjs/typeorm");
-const typeorm_2 = require("typeorm");
-const entityJson_entity_1 = require("../entity/entityJson.entity");
-let EntityJSONRepository = class EntityJSONRepository {
-    constructor(entityJSONRepository) {
-        this.entityJSONRepository = entityJSONRepository;
-    }
-    async create(flatJson) {
-        const { entity_type, entity_id } = flatJson;
-        const existing = await this.entityJSONRepository.findOne({
-            where: { entity_type, entity_id },
-        });
-        if (existing) {
-            await this.entityJSONRepository.update(existing.id, flatJson);
-            return this.entityJSONRepository.findOne({
-                where: { id: existing.id },
-            });
-        }
-        const created = this.entityJSONRepository.create(flatJson);
-        return this.entityJSONRepository.save(created);
-    }
-};
-exports.EntityJSONRepository = EntityJSONRepository;
-exports.EntityJSONRepository = EntityJSONRepository = __decorate([
-    (0, common_1.Injectable)(),
-    __param(0, (0, typeorm_1.InjectRepository)(entityJson_entity_1.EntityJson)),
-    __metadata("design:paramtypes", [typeorm_2.Repository])
-], EntityJSONRepository);
-//# sourceMappingURL=entityJson.repository.js.map

package/dist/module/entity_json/service/entityJson.repository.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"entityJson.repository.js","sourceRoot":"","sources":["../../../../src/module/entity_json/service/entityJson.repository.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,2CAA4C;AAC5C,6CAAmD;AACnD,qCAAqC;AACrC,mEAAyD;AAKlD,IAAM,oBAAoB,GAA1B,MAAM,oBAAoB;IAC/B,YAEmB,oBAA4C;QAA5C,yBAAoB,GAApB,oBAAoB,CAAwB;IAC5D,CAAC;IAEJ,KAAK,CAAC,MAAM,CAAC,QAA6B;QACxC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,GAAG,QAAQ,CAAC;QAG5C,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;YACvD,KAAK,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE;SAClC,CAAC,CAAC;QAEH,IAAI,QAAQ,EAAE,CAAC;YAEb,MAAM,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;YAG9D,OAAO,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;gBACvC,KAAK,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,EAAE,EAAE;aAC3B,CAAC,CAAC;QACL,CAAC;QAGD,MAAM,OAAO,GAAG,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC3D,OAAO,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACjD,CAAC;CACF,CAAA;AA5BY,oDAAoB;+BAApB,oBAAoB;IADhC,IAAA,mBAAU,GAAE;IAGR,WAAA,IAAA,0BAAgB,EAAC,8BAAU,CAAC,CAAA;qCACU,oBAAU;GAHxC,oBAAoB,CA4BhC"}

package/src/module/entity_json/service/entityJson.repository.ts

@@ -1,37 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { InjectRepository } from "@nestjs/typeorm";
-import { Repository } from "typeorm";
-import { EntityJson } from "../entity/entityJson.entity";
-import { create } from "domain";
-
-
-@Injectable()
-export class EntityJSONRepository {
-  constructor(
-    @InjectRepository(EntityJson)
-    private readonly entityJSONRepository: Repository<EntityJson>,
-  ) {}
-
-  async create(flatJson: Partial<EntityJson>) {
-    const { entity_type, entity_id } = flatJson;
-
-    // Step 1 — check if exists by unique keys
-    const existing = await this.entityJSONRepository.findOne({
-      where: { entity_type, entity_id },
-    });
-
-    if (existing) {
-      // Step 2 — normal update (no merge)
-      await this.entityJSONRepository.update(existing.id, flatJson);
-
-      // Optionally return updated row (common practice)
-      return this.entityJSONRepository.findOne({
-        where: { id: existing.id },
-      });
-    }
-
-    // Step 3 — insert new
-    const created = this.entityJSONRepository.create(flatJson);
-    return this.entityJSONRepository.save(created);
-  }
-}