rez_core 6.5.32 → 6.5.33

package/src/module/filter/test/flatjson-filter.service.spec.ts

@@ -1,415 +0,0 @@
-import { Test, TestingModule } from '@nestjs/testing';
-import { FlatjsonFilterService } from '../service/flatjson-filter.service';
-import { EntityManager } from 'typeorm';
-import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
-import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
-import { ResolverService } from 'src/module/meta/service/resolver.service';
-import { LoggingService } from 'src/utils/service/loggingUtil.service';
-import { ConfigService } from '@nestjs/config';
-import { SavedFilterRepositoryService } from '../repository/saved-filter.repository';
-
-describe('FlatjsonFilterService - Phase 2 Tests', () => {
-  let service: FlatjsonFilterService;
-
-  const mockEntityManager = {
-    getRepository: jest.fn(),
-  };
-
-  const mockEntityMasterService = {};
-  const mockAttributeMasterService = {
-    findAttributesByMappedEntityType: jest.fn(),
-  };
-  const mockResolverService = {
-    resolveEntitiesByIds: jest.fn(),
-  };
-  const mockLoggingService = {
-    log: jest.fn(),
-  };
-  const mockConfigService = {};
-  const mockSavedFilterRepositoryService = {
-    getDetailsByCode: jest.fn(),
-  };
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        FlatjsonFilterService,
-        { provide: EntityManager, useValue: mockEntityManager },
-        { provide: EntityMasterService, useValue: mockEntityMasterService },
-        {
-          provide: AttributeMasterService,
-          useValue: mockAttributeMasterService,
-        },
-        { provide: ResolverService, useValue: mockResolverService },
-        { provide: LoggingService, useValue: mockLoggingService },
-        { provide: ConfigService, useValue: mockConfigService },
-        {
-          provide: SavedFilterRepositoryService,
-          useValue: mockSavedFilterRepositoryService,
-        },
-      ],
-    }).compile();
-
-    service = module.get<FlatjsonFilterService>(FlatjsonFilterService);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('Task 2.3: Text Conditions', () => {
-    it('should build equal condition for text', () => {
-      const condition = service['buildTextCondition'](
-        'LEAD__name',
-        'equal',
-        'John',
-        'param1',
-      );
-
-      expect(condition).not.toBeNull();
-      expect(condition?.query).toContain("json_data->>'LEAD__name'");
-      expect(condition?.query).toContain('=');
-      expect(condition?.params.param1).toBe('john'); // lowercase
-    });
-
-    it('should build contains condition with LIKE', () => {
-      const condition = service['buildTextCondition'](
-        'LEAD__name',
-        'contains',
-        'John',
-        'param1',
-      );
-
-      expect(condition?.query).toContain('LIKE');
-      expect(condition?.params.param1).toBe('%john%');
-    });
-
-    it('should build starts_with condition', () => {
-      const condition = service['buildTextCondition'](
-        'LEAD__name',
-        'starts_with',
-        'John',
-        'param1',
-      );
-
-      expect(condition?.params.param1).toBe('john%');
-    });
-
-    it('should build ends_with condition', () => {
-      const condition = service['buildTextCondition'](
-        'LEAD__name',
-        'ends_with',
-        'Smith',
-        'param1',
-      );
-
-      expect(condition?.params.param1).toBe('%smith');
-    });
-
-    it('should build empty condition', () => {
-      const condition = service['buildTextCondition'](
-        'LEAD__name',
-        'empty',
-        null,
-        'param1',
-      );
-
-      expect(condition?.query).toContain('IS NULL');
-      expect(Object.keys(condition?.params || {})).toHaveLength(0);
-    });
-  });
-
-  describe('Task 2.4: Number Conditions', () => {
-    it('should build equal condition for numbers', () => {
-      const condition = service['buildNumberCondition'](
-        'LEAD__age',
-        'equal',
-        25,
-        'param1',
-      );
-
-      expect(condition?.query).toContain('::numeric');
-      expect(condition?.query).toContain('=');
-      expect(condition?.params.param1).toBe(25);
-    });
-
-    it('should build greater_than condition', () => {
-      const condition = service['buildNumberCondition'](
-        'LEAD__age',
-        'greater_than',
-        18,
-        'param1',
-      );
-
-      expect(condition?.query).toContain('>');
-      expect(condition?.params.param1).toBe(18);
-    });
-
-    it('should build between condition with array', () => {
-      const condition = service['buildNumberCondition'](
-        'LEAD__age',
-        'between',
-        [18, 65],
-        'param1',
-      );
-
-      expect(condition?.query).toContain('BETWEEN');
-      expect(condition?.params.param1_min).toBe(18);
-      expect(condition?.params.param1_max).toBe(65);
-    });
-
-    it('should build between condition with string', () => {
-      const condition = service['buildNumberCondition'](
-        'LEAD__age',
-        'between',
-        '18, 65',
-        'param1',
-      );
-
-      expect(condition?.query).toContain('BETWEEN');
-      expect(condition?.params.param1_min).toBe(18);
-      expect(condition?.params.param1_max).toBe(65);
-    });
-  });
-
-  describe('Task 2.5: Date Conditions', () => {
-    it('should build equal condition for dates', () => {
-      const condition = service['buildDateCondition'](
-        'LEAD__created_date',
-        'equal',
-        '2024-01-01',
-        'param1',
-      );
-
-      expect(condition?.query).toContain('::bigint');
-      expect(condition?.query).toContain('=');
-      expect(typeof condition?.params.param1).toBe('number');
-    });
-
-    it('should build before condition', () => {
-      const condition = service['buildDateCondition'](
-        'LEAD__created_date',
-        'before',
-        '2024-12-31',
-        'param1',
-      );
-
-      expect(condition?.query).toContain('<');
-    });
-
-    it('should build between condition for dates', () => {
-      const condition = service['buildDateCondition'](
-        'LEAD__created_date',
-        'between',
-        ['2024-01-01', '2024-12-31'],
-        'param1',
-      );
-
-      expect(condition?.query).toContain('BETWEEN');
-      expect(condition?.params.param1_start).toBeDefined();
-      expect(condition?.params.param1_end).toBeDefined();
-    });
-
-    it('should build today condition', () => {
-      const condition = service['buildDateCondition'](
-        'LEAD__created_date',
-        'today',
-        null,
-        'param1',
-      );
-
-      expect(condition?.query).toContain('BETWEEN');
-      expect(condition?.params.param1_start).toBeDefined();
-      expect(condition?.params.param1_end).toBeDefined();
-    });
-
-    it('should build in_last_day condition', () => {
-      const condition = service['buildDateCondition'](
-        'LEAD__created_date',
-        'in_last_day',
-        7,
-        'param1',
-      );
-
-      expect(condition?.query).toContain('BETWEEN');
-    });
-  });
-
-  describe('Task 2.6: Select/Multiselect Conditions', () => {
-    it('should build equal condition for select', () => {
-      const condition = service['buildSelectCondition'](
-        'LEAD__status',
-        'equal',
-        'NEW',
-        'param1',
-      );
-
-      expect(condition?.query).toContain("json_data->>'LEAD__status'");
-      expect(condition?.params.param1).toBe('NEW');
-    });
-
-    it('should build IN condition for array values', () => {
-      const condition = service['buildSelectCondition'](
-        'LEAD__status',
-        'equal',
-        ['NEW', 'ACTIVE'],
-        'param1',
-      );
-
-      expect(condition?.query).toContain('ANY');
-      expect(Array.isArray(condition?.params.param1)).toBe(true);
-    });
-
-    it('should build contains condition for multiselect', () => {
-      const condition = service['buildMultiSelectCondition'](
-        'LEAD__languages',
-        'contains',
-        'hindi',
-        'param1',
-      );
-
-      expect(condition?.query).toContain('?');
-      expect(condition?.params.param1).toBe('hindi');
-    });
-
-    it('should build contains_all condition', () => {
-      const condition = service['buildMultiSelectCondition'](
-        'LEAD__languages',
-        'contains_all',
-        ['hindi', 'english'],
-        'param1',
-      );
-
-      expect(condition?.query).toContain('?&');
-      expect(Array.isArray(condition?.params.param1)).toBe(true);
-    });
-
-    it('should build contains_any condition', () => {
-      const condition = service['buildMultiSelectCondition'](
-        'LEAD__languages',
-        'contains_any',
-        ['hindi', 'english'],
-        'param1',
-      );
-
-      expect(condition?.query).toContain('?|');
-    });
-
-    it('should handle comma-separated string input', () => {
-      const condition = service['buildMultiSelectCondition'](
-        'LEAD__languages',
-        'contains_any',
-        'hindi, english, tamil',
-        'param1',
-      );
-
-      expect(Array.isArray(condition?.params.param1)).toBe(true);
-      expect(condition?.params.param1).toHaveLength(3);
-    });
-  });
-
-  describe('Task 2.9: Sorting', () => {
-    it('should apply numeric sorting for number fields', () => {
-      const mockQb = {
-        orderBy: jest.fn().mockReturnThis(),
-        addOrderBy: jest.fn().mockReturnThis(),
-      };
-
-      const attributeMetaMap = {
-        age: {
-          data_type: 'number',
-          flat_json_key: 'LEAD__age',
-          mapped_entity_type: 'LEAD',
-        },
-      };
-
-      const sortby = [{ sortColum: 'age', sortType: 'DESC' }];
-
-      service['applyJsonbSorting'](mockQb as any, sortby, attributeMetaMap);
-
-      expect(mockQb.orderBy).toHaveBeenCalled();
-      const call = mockQb.orderBy.mock.calls[0];
-      expect(call[0]).toContain('::numeric');
-      expect(call[1]).toBe('DESC');
-    });
-
-    it('should apply bigint sorting for date fields', () => {
-      const mockQb = {
-        orderBy: jest.fn().mockReturnThis(),
-      };
-
-      const attributeMetaMap = {
-        created_date: {
-          data_type: 'date',
-          flat_json_key: 'LEAD__created_date',
-          mapped_entity_type: 'LEAD',
-        },
-      };
-
-      const sortby = [{ sortColum: 'created_date', sortType: 'ASC' }];
-
-      service['applyJsonbSorting'](mockQb as any, sortby, attributeMetaMap);
-
-      const call = mockQb.orderBy.mock.calls[0];
-      expect(call[0]).toContain('::bigint');
-    });
-
-    it('should apply text sorting for text fields', () => {
-      const mockQb = {
-        orderBy: jest.fn().mockReturnThis(),
-      };
-
-      const attributeMetaMap = {
-        name: {
-          data_type: 'text',
-          flat_json_key: 'LEAD__name',
-          mapped_entity_type: 'LEAD',
-        },
-      };
-
-      const sortby = [{ sortColum: 'name', sortType: 'ASC' }];
-
-      service['applyJsonbSorting'](mockQb as any, sortby, attributeMetaMap);
-
-      const call = mockQb.orderBy.mock.calls[0];
-      expect(call[0]).not.toContain('::');
-      expect(call[0]).toContain("->>"); // Text extraction
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle NULL values in text conditions', () => {
-      const condition = service['buildTextCondition'](
-        'LEAD__name',
-        'equal',
-        null,
-        'param1',
-      );
-
-      expect(condition).not.toBeNull();
-      expect(condition?.params.param1).toBe('');
-    });
-
-    it('should return null for unsupported operators', () => {
-      const condition = service['buildTextCondition'](
-        'LEAD__name',
-        'invalid_operator',
-        'test',
-        'param1',
-      );
-
-      expect(condition).toBeNull();
-    });
-
-    it('should handle empty array in multiselect', () => {
-      const condition = service['buildMultiSelectCondition'](
-        'LEAD__languages',
-        'contains',
-        [],
-        'param1',
-      );
-
-      expect(condition?.query).toBe('1=1'); // Always true
-    });
-  });
-});

package/src/module/linked_attributes/dto/create-linked-attribute-smart.dto.ts

@@ -1,54 +0,0 @@
-import {
-  IsString,
-  IsNotEmpty,
-  IsArray,
-  IsOptional,
-  IsBoolean,
-  ValidateNested,
-} from 'class-validator';
-import { Type } from 'class-transformer';
-
-export class FilterConditionDto {
-  @IsString()
-  @IsNotEmpty()
-  filter_attribute: string;
-
-  @IsString()
-  @IsNotEmpty()
-  filter_operator: string;
-
-  @IsNotEmpty()
-  filter_value: any;
-}
-
-export class CreateLinkedAttributeSmartDto {
-  @IsString()
-  @IsNotEmpty()
-  field_name: string;
-
-  @IsString()
-  @IsNotEmpty()
-  mapped_entity_type: string;
-
-  @IsString()
-  @IsNotEmpty()
-  applicable_entity_type: string;
-
-  @IsString()
-  @IsNotEmpty()
-  applicable_attribute_key: string;
-
-  @IsString()
-  @IsNotEmpty()
-  saved_filter_code: string;
-
-  // @IsArray()
-  // @IsOptional()
-  // @ValidateNested({ each: true })
-  // @Type(() => FilterConditionDto)
-  // filter_conditions?: FilterConditionDto[];
-
-  @IsBoolean()
-  @IsOptional()
-  backfill?: boolean;
-}

package/src/module/linked_attributes/test/linked-attributes.service.spec.ts

@@ -1,244 +0,0 @@
-import { Test, TestingModule } from '@nestjs/testing';
-import { LinkedAttributesService } from '../service/linked_attributes.service';
-import { DataSource } from 'typeorm';
-import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
-import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
-import { SavedFilterService } from 'src/module/filter/service/saved-filter.service';
-import { SavedFilterDetailRepository } from 'src/module/filter/repository/saved.filter-detail.repository';
-import { EntityJSONService } from 'src/module/entity_json/service/entity_json.service';
-
-describe('LinkedAttributesService - Phase 1 Tests', () => {
-  let service: LinkedAttributesService;
-  let dataSource: DataSource;
-  let entityMasterService: EntityMasterService;
-  let attributeMasterService: AttributeMasterService;
-
-  const mockDataSource = {
-    getRepository: jest.fn(),
-    transaction: jest.fn(),
-  };
-
-  const mockEntityMasterService = {
-    getEntityData: jest.fn(),
-  };
-
-  const mockAttributeMasterService = {
-    findAttributesByMappedEntityType: jest.fn(),
-  };
-
-  const mockSavedFilterService = {
-    createEntity: jest.fn(),
-  };
-
-  const mockSavedFilterDetailRepository = {
-    findByMappedFilterCode: jest.fn(),
-  };
-
-  const mockEntityJSONService = {
-    updateEntityJSON: jest.fn(),
-  };
-
-  const mockLoggedInUser = {
-    id: 1,
-    organization_id: 100,
-    level_type: 'ORG',
-    level_id: 100,
-  };
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        LinkedAttributesService,
-        { provide: DataSource, useValue: mockDataSource },
-        { provide: EntityMasterService, useValue: mockEntityMasterService },
-        {
-          provide: AttributeMasterService,
-          useValue: mockAttributeMasterService,
-        },
-        { provide: 'SavedFilterService', useValue: mockSavedFilterService },
-        {
-          provide: SavedFilterDetailRepository,
-          useValue: mockSavedFilterDetailRepository,
-        },
-        { provide: EntityJSONService, useValue: mockEntityJSONService },
-      ],
-    }).compile();
-
-    service = module.get<LinkedAttributesService>(LinkedAttributesService);
-    dataSource = module.get<DataSource>(DataSource);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('Task 1.1: generateAttributeKey', () => {
-    it('should generate correct attribute key format', () => {
-      const result = service.generateAttributeKey('LFMG', 'name', 1);
-      expect(result).toBe('LFMG__name__1');
-    });
-
-    it('should handle different sequences', () => {
-      expect(service.generateAttributeKey('LFMG', 'name', 1)).toBe(
-        'LFMG__name__1',
-      );
-      expect(service.generateAttributeKey('LFMG', 'name', 2)).toBe(
-        'LFMG__name__2',
-      );
-      expect(service.generateAttributeKey('LFMG', 'name', 99)).toBe(
-        'LFMG__name__99',
-      );
-    });
-
-    it('should throw error for empty entity_type', () => {
-      expect(() => service.generateAttributeKey('', 'name', 1)).toThrow(
-        'applicable_entity_type is required and cannot be empty',
-      );
-    });
-
-    it('should throw error for empty attribute_key', () => {
-      expect(() => service.generateAttributeKey('LFMG', '', 1)).toThrow(
-        'applicable_attribute_key is required and cannot be empty',
-      );
-    });
-
-    it('should throw error for invalid sequence', () => {
-      expect(() => service.generateAttributeKey('LFMG', 'name', 0)).toThrow(
-        'sequence must be a positive integer greater than 0',
-      );
-      expect(() => service.generateAttributeKey('LFMG', 'name', -1)).toThrow(
-        'sequence must be a positive integer greater than 0',
-      );
-      expect(() => service.generateAttributeKey('LFMG', 'name', 1.5)).toThrow(
-        'sequence must be a positive integer greater than 0',
-      );
-    });
-
-    it('should trim whitespace from inputs', () => {
-      expect(() =>
-        service.generateAttributeKey('  ', 'name', 1),
-      ).toThrow();
-      expect(() =>
-        service.generateAttributeKey('LFMG', '  ', 1),
-      ).toThrow();
-    });
-  });
-
-  describe('Task 1.2: Validation Engine', () => {
-    it('should validate required fields', async () => {
-      const payload = {
-        field_name: '',
-        mapped_entity_type: 'LEAD',
-        applicable_entity_type: 'LFMG',
-        applicable_attribute_key: 'name',
-        organization_id: 100,
-      };
-
-      const result = await service.validateLinkedAttribute(
-        payload,
-        mockLoggedInUser,
-      );
-
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain(
-        "Required field 'field_name' is missing or empty",
-      );
-    });
-
-    it('should validate entity type exists', async () => {
-      mockEntityMasterService.getEntityData.mockRejectedValue(
-        new Error('Not found'),
-      );
-
-      const payload = {
-        field_name: 'Father Name',
-        mapped_entity_type: 'INVALID',
-        applicable_entity_type: 'LFMG',
-        applicable_attribute_key: 'name',
-        organization_id: 100,
-      };
-
-      const result = await service.validateLinkedAttribute(
-        payload,
-        mockLoggedInUser,
-      );
-
-      expect(result.valid).toBe(false);
-      expect(
-        result.errors.some((e) => e.includes('does not exist')),
-      ).toBe(true);
-    });
-
-    it('should pass validation for valid payload', async () => {
-      // Mock successful validations
-      mockEntityMasterService.getEntityData
-        .mockResolvedValueOnce({ id: 1 }) // mapped_entity_type
-        .mockResolvedValueOnce({ id: 2 }); // applicable_entity_type
-
-      mockAttributeMasterService.findAttributesByMappedEntityType.mockResolvedValue(
-        [{ attribute_key: 'name' }],
-      );
-
-      const mockRepository = {
-        createQueryBuilder: jest.fn().mockReturnValue({
-          where: jest.fn().mockReturnThis(),
-          andWhere: jest.fn().mockReturnThis(),
-          getOne: jest.fn().mockResolvedValue(null), // No duplicate
-        }),
-      };
-
-      mockDataSource.getRepository.mockReturnValue(mockRepository);
-
-      const payload = {
-        field_name: 'Father Name',
-        mapped_entity_type: 'LEAD',
-        applicable_entity_type: 'LFMG',
-        applicable_attribute_key: 'name',
-        organization_id: 100,
-      };
-
-      const result = await service.validateLinkedAttribute(
-        payload,
-        mockLoggedInUser,
-      );
-
-      expect(result.valid).toBe(true);
-      expect(result.errors).toHaveLength(0);
-    });
-  });
-
-  describe('Task 1.4: Smart Create Method', () => {
-    it('should throw BadRequestException on validation failure', async () => {
-      // Mock validation failure
-      mockEntityMasterService.getEntityData.mockRejectedValue(
-        new Error('Not found'),
-      );
-
-      const dto = {
-        field_name: 'Father Name',
-        mapped_entity_type: 'INVALID',
-        applicable_entity_type: 'LFMG',
-        applicable_attribute_key: 'name',
-      };
-
-      await expect(
-        service.createLinkedAttributeSmart(dto, mockLoggedInUser),
-      ).rejects.toThrow();
-    });
-  });
-
-  describe('Integration Tests', () => {
-    it('should handle end-to-end attribute key generation', () => {
-      // Test the full flow: sequence 1, 2, 3
-      expect(service.generateAttributeKey('LFMG', 'name', 1)).toBe(
-        'LFMG__name__1',
-      );
-      expect(service.generateAttributeKey('LFMG', 'email', 1)).toBe(
-        'LFMG__email__1',
-      );
-      expect(service.generateAttributeKey('CONTACT', 'phone', 1)).toBe(
-        'CONTACT__phone__1',
-      );
-    });
-  });
-});