rez_core 6.5.58 → 6.5.61

package/src/module/entity_json/docs/FlatJson_Filterin_System.md

@@ -0,0 +1,2804 @@
+# Flatjson Filtering System - Complete Implementation Guide
+
+## Project Overview
+We are migrating from MySQL to PostgreSQL and implementing a sophisticated flatjson system for optimized entity data querying. This involves:
+1. Automating Linked Attribute creation (custom 1:M to 1:1 mappings)
+2. Building a new filtering service that queries JSONB flatjson directly
+3. Maintaining backward compatibility with existing FilterService
+
+## Technology Stack
+- **Backend:** Node.js 18+, TypeScript 5.x, NestJS
+- **Database:** PostgreSQL 14+ with JSONB support
+- **ORM:** TypeORM
+- **Testing:** Jest
+
+## Project Structure
+```
+src/
+├── module/
+│   ├── filter/                  # Existing filter logic (keep intact)
+│   │   ├── service/
+│   │   │   ├── filter.service.ts
+│   │   │   ├── filter-evaluator.service.ts
+│   │   │   └── saved-filter.service.ts
+│   │   ├── entity/
+│   │   └── dto/
+│   ├── linked_attributes/       # Custom 1:M attribute management
+│   │   ├── service/
+│   │   │   └── linked_attributes.service.ts
+│   │   ├── entity/
+│   │   │   └── linked_attribute.entity.ts
+│   │   └── controller/
+│   ├── entity_json/             # Flatjson building and storage
+│   │   ├── service/
+│   │   │   └── entity_json.service.ts
+│   │   ├── entity/
+│   │   │   └── entityJson.entity.ts
+│   │   └── repository/
+│   └── meta/                    # Metadata services
+├── migrations/                  # Database migrations
+└── common/                      # Shared utilities
+```
+
+## Key Conventions
+- **Flatjson Keys:** `ENTITY__attribute_key` or `ENTITY__attribute_key__sequence`
+  - Example: `LEAD__name`, `LFMG__name__1`, `LFMG__name__2`
+- **Text Storage:** All text stored in lowercase
+- **Date Storage:** Epoch milliseconds (bigint)
+- **Multi-select:** Stored as JSON arrays
+- **Naming:** PascalCase for classes, camelCase for methods
+- **Async:** Always use async/await, no callbacks
+- **Types:** Explicit TypeScript types, avoid `any`
+- **Comments:** JSDoc for all public methods
+
+## Database Tables
+- `frm_linked_attribute` - Custom 1:M attribute definitions
+- `frm_entity_json` - Stores flatjson data (entity_type, entity_id, json_data)
+- `frm_saved_filter_master` - Saved filter definitions
+- `frm_saved_filter_detail` - Saved filter conditions
+- `frm_entity_master` - Entity metadata
+- `frm_attribute_master` - Attribute metadata
+
+---
+
+# PHASE 1: LINKED ATTRIBUTE AUTOMATION
+**Priority: CRITICAL | Duration: 12-15 hours**
+
+## Task 1.1: Sequence & Key Generation Logic
+**Duration: 2 hours | Files: linked_attributes.service.ts**
+
+### Objective
+Add methods to automatically generate sequence numbers and attribute keys for linked attributes.
+
+### Requirements
+
+1. **Add private async method: generateNextSequence()**
+```typescript
+   /**
+    * Generate the next sequence number for a linked attribute
+    * @param mapped_entity_type - Main entity type (e.g., "LEAD")
+    * @param applicable_entity_type - Source 1:M entity (e.g., "LFMG")
+    * @param applicable_attribute_key - Source attribute (e.g., "name")
+    * @param organization_id - Organization ID
+    * @returns Next available sequence number
+    */
+   private async generateNextSequence(
+     mapped_entity_type: string,
+     applicable_entity_type: string,
+     applicable_attribute_key: string,
+     organization_id: number
+   ): Promise<number>
+```
+   
+   **Implementation:**
+   - Query `frm_linked_attribute` table
+   - Find MAX(sequence) for the given combination
+   - Return max + 1, or 1 if no records exist
+   - Use TypeORM QueryBuilder pattern (as seen in existing methods)
+
+2. **Add public method: generateAttributeKey()**
+```typescript
+   /**
+    * Generate a flatjson attribute key in format: ENTITY__attribute__N
+    * @param applicable_entity_type - Entity code (e.g., "LFMG")
+    * @param applicable_attribute_key - Attribute key (e.g., "name")
+    * @param sequence - Sequence number (e.g., 1)
+    * @returns Generated key (e.g., "LFMG__name__1")
+    * @example generateAttributeKey('LFMG', 'name', 1) => 'LFMG__name__1'
+    */
+   public generateAttributeKey(
+     applicable_entity_type: string,
+     applicable_attribute_key: string,
+     sequence: number
+   ): string
+```
+   
+   **Implementation:**
+   - Validate inputs (throw error if invalid)
+   - Return formatted string: `${applicable_entity_type}__${applicable_attribute_key}__${sequence}`
+
+### Testing Requirements
+- Create unit test file: `linked_attributes.service.spec.ts` (if not exists)
+- Test cases:
+  - generateNextSequence() with no existing records → returns 1
+  - generateNextSequence() with existing records → returns max + 1
+  - generateAttributeKey() with valid inputs → correct format
+  - generateAttributeKey() with invalid inputs → throws error
+
+### Acceptance Criteria
+- [ ] Both methods implemented and working
+- [ ] TypeScript types are explicit (no `any`)
+- [ ] JSDoc comments added
+- [ ] Unit tests pass
+- [ ] No breaking changes to existing code
+
+---
+
+## Task 1.2: Validation Engine
+**Duration: 3 hours | Files: linked_attributes.service.ts**
+
+### Objective
+Add comprehensive validation logic to prevent invalid linked attributes from being created.
+
+### Requirements
+
+1. **Add public async method: validateLinkedAttribute()**
+```typescript
+   /**
+    * Validate linked attribute payload before creation
+    * @param payload - Linked attribute data to validate
+    * @param loggedInUser - Current user context
+    * @returns Validation result with errors array
+    */
+   async validateLinkedAttribute(
+     payload: {
+       field_name: string;
+       mapped_entity_type: string;
+       applicable_entity_type: string;
+       applicable_attribute_key: string;
+       attribute_key?: string;
+       organization_id: number;
+     },
+     loggedInUser: any
+   ): Promise<{ valid: boolean; errors: string[] }>
+```
+
+2. **Validation Checks (implement as private helper methods):**
+
+   a. **checkDuplicateAttributeKey()**
+   - Query `frm_linked_attribute` for existing attribute_key
+   - Error: "Attribute key {key} already exists for entity {entity}"
+
+   b. **validateEntityTypeExists()**
+   - Query `frm_entity_master` to verify entity_type exists
+   - Error: "Entity type {type} does not exist"
+   - Inject `EntityMasterService` if available, or query directly
+
+   c. **validateAttributeKeyExists()**
+   - Query `frm_attribute_master` to verify attribute exists
+   - Error: "Attribute {key} does not exist in entity {entity}"
+   - Inject `AttributeMasterService` if available, or query directly
+
+   d. **validateRequiredFields()**
+   - Check field_name, mapped_entity_type, applicable_entity_type, applicable_attribute_key
+   - Error: "Required field {field} is missing or empty"
+
+3. **Aggregate all validations:**
+```typescript
+   const errors: string[] = [];
+   
+   // Run all validations
+   await Promise.all([
+     this.checkDuplicateAttributeKey(...).then(err => err && errors.push(err)),
+     this.validateEntityTypeExists(...).then(err => err && errors.push(err)),
+     this.validateAttributeKeyExists(...).then(err => err && errors.push(err)),
+   ]);
+   
+   this.validateRequiredFields(payload, errors);
+   
+   return { valid: errors.length === 0, errors };
+```
+
+### Dependencies to Inject
+You may need to inject these services (add to constructor):
+```typescript
+@Inject() private readonly entityMasterService: EntityMasterService,
+@Inject() private readonly attributeMasterService: AttributeMasterService,
+```
+
+### Testing Requirements
+- Test each validation method independently
+- Test validateLinkedAttribute() with:
+  - All valid data → returns { valid: true, errors: [] }
+  - Duplicate key → returns error
+  - Invalid entity type → returns error
+  - Invalid attribute → returns error
+  - Multiple errors → returns all errors
+
+### Acceptance Criteria
+- [ ] All validation methods implemented
+- [ ] Validation aggregates multiple errors
+- [ ] Clear, user-friendly error messages
+- [ ] Unit tests pass
+- [ ] No performance issues (validations run in parallel)
+
+---
+
+## Task 1.3: Auto SavedFilter Creation
+**Duration: 4 hours | Files: linked_attributes.service.ts**
+
+### Objective
+Automatically create SavedFilter records when a linked attribute needs filter conditions.
+
+### Requirements
+
+1. **Inject dependencies:**
+```typescript
+   @Inject() private readonly savedFilterService: SavedFilterService,
+   @Inject() private readonly savedFilterDetailRepository: SavedFilterDetailRepository,
+```
+
+2. **Add private async method: createFilterForLinkedAttribute()**
+```typescript
+   /**
+    * Create a SavedFilter for a linked attribute
+    * @param entity_type - Entity type to filter (e.g., "LFMG")
+    * @param conditions - Array of filter conditions
+    * @param attribute_key - Linked attribute key (for naming)
+    * @param loggedInUser - Current user context
+    * @returns Generated filter code
+    */
+   private async createFilterForLinkedAttribute(
+     entity_type: string,
+     conditions: Array<{
+       filter_attribute: string;
+       filter_operator: string;
+       filter_value: any;
+     }>,
+     attribute_key: string,
+     loggedInUser: any
+   ): Promise<string>
+```
+
+3. **Implementation Steps:**
+
+   a. Generate unique filter code:
+```typescript
+   const timestamp = Date.now();
+   const filterCode = `LA_${entity_type}_${attribute_key}_${timestamp}`;
+```
+
+   b. Create SavedFilterMaster:
+```typescript
+   const filterMaster = await this.savedFilterService.createEntity({
+     name: `Auto Filter - ${attribute_key}`,
+     code: filterCode,
+     mapped_entity_type: entity_type,
+     filter_scope: 'FILTER',
+     organization_id: loggedInUser.organization_id,
+     level_type: loggedInUser.level_type,
+     level_id: loggedInUser.level_id,
+   }, loggedInUser);
+```
+
+   c. Create SavedFilterDetail records (bulk or loop):
+```typescript
+   for (const condition of conditions) {
+     await this.savedFilterDetailRepository.save({
+       mapped_filter_code: filterCode,
+       filter_entity_type: entity_type,
+       filter_attribute: condition.filter_attribute,
+       filter_operator: condition.filter_operator,
+       filter_value: String(condition.filter_value),
+       organization_id: loggedInUser.organization_id,
+       // Add other required fields from SavedFilterDetail entity
+     });
+   }
+```
+
+   d. Return the generated filter code
+
+4. **Wrap in transaction:**
+```typescript
+   return await this.dataSource.transaction(async (manager) => {
+     // Create filter master & details here
+     // If any step fails, entire transaction rolls back
+   });
+```
+
+### Testing Requirements
+- Test filter creation with 1 condition
+- Test filter creation with multiple conditions
+- Test filter code uniqueness
+- Test transaction rollback on error
+- Verify filter is actually created in database
+
+### Acceptance Criteria
+- [ ] Creates SavedFilterMaster with unique code
+- [ ] Creates SavedFilterDetail for each condition
+- [ ] Wrapped in transaction (all-or-nothing)
+- [ ] Returns generated filter code
+- [ ] Unit tests pass
+- [ ] Integration test verifies database records
+
+---
+
+## Task 1.4: Smart Create Method
+**Duration: 2 hours | Files: linked_attributes.service.ts, DTO files**
+
+### Objective
+Create a single method that orchestrates the entire linked attribute creation process with auto-generation.
+
+### Requirements
+
+1. **Create DTO file: `src/module/linked_attributes/dto/create-linked-attribute-smart.dto.ts`**
+```typescript
+   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;
+   
+     @IsArray()
+     @IsOptional()
+     @ValidateNested({ each: true })
+     @Type(() => FilterConditionDto)
+     filter_conditions?: FilterConditionDto[];
+   
+     @IsBoolean()
+     @IsOptional()
+     backfill?: boolean;
+   }
+```
+
+2. **Add public async method: createLinkedAttributeSmart()**
+```typescript
+   /**
+    * Smart creation of linked attribute with auto-generation
+    * @param payload - Linked attribute data
+    * @param loggedInUser - Current user context
+    * @returns Created LinkedAttribute entity
+    */
+   async createLinkedAttributeSmart(
+     payload: CreateLinkedAttributeSmartDto,
+     loggedInUser: any
+   ): Promise<LinkedAttributes>
+```
+
+3. **Implementation Flow:**
+```typescript
+   async createLinkedAttributeSmart(payload, loggedInUser) {
+     // Step 1: Validate input
+     const validation = await this.validateLinkedAttribute({
+       field_name: payload.field_name,
+       mapped_entity_type: payload.mapped_entity_type,
+       applicable_entity_type: payload.applicable_entity_type,
+       applicable_attribute_key: payload.applicable_attribute_key,
+       organization_id: loggedInUser.organization_id,
+     }, loggedInUser);
+     
+     if (!validation.valid) {
+       throw new BadRequestException(validation.errors.join(', '));
+     }
+     
+     // Step 2: Generate sequence number
+     const sequence = await this.generateNextSequence(
+       payload.mapped_entity_type,
+       payload.applicable_entity_type,
+       payload.applicable_attribute_key,
+       loggedInUser.organization_id
+     );
+     
+     // Step 3: Generate attribute_key
+     const attribute_key = this.generateAttributeKey(
+       payload.applicable_entity_type,
+       payload.applicable_attribute_key,
+       sequence
+     );
+     
+     // Step 4: Create saved filter if conditions provided
+     let saved_filter_code = null;
+     if (payload.filter_conditions?.length > 0) {
+       saved_filter_code = await this.createFilterForLinkedAttribute(
+         payload.applicable_entity_type,
+         payload.filter_conditions,
+         attribute_key,
+         loggedInUser
+       );
+     }
+     
+     // Step 5: Create LinkedAttribute entity
+     const linkedAttrData = {
+       field_name: payload.field_name,
+       attribute_key,
+       applicable_entity_type: payload.applicable_entity_type,
+       applicable_attribute_key: payload.applicable_attribute_key,
+       mapped_entity_type: payload.mapped_entity_type,
+       saved_filter_code,
+       sequence,
+       organization_id: loggedInUser.organization_id,
+       level_type: loggedInUser.level_type,
+       level_id: loggedInUser.level_id,
+     };
+     
+     const linkedAttribute = await super.createEntity(linkedAttrData, loggedInUser);
+     
+     // Step 6: Trigger backfill if requested (async, don't await)
+     if (payload.backfill) {
+       this.backfillLinkedAttribute(linkedAttribute.id, loggedInUser)
+         .catch(err => console.error('Backfill failed:', err));
+     }
+     
+     return linkedAttribute;
+   }
+```
+
+### Testing Requirements
+- Test complete happy path (all steps succeed)
+- Test validation failure (should throw BadRequestException)
+- Test with filter_conditions
+- Test without filter_conditions
+- Test with backfill: true
+- Test with backfill: false
+
+### Acceptance Criteria
+- [ ] DTO file created with validation decorators
+- [ ] Smart create method implemented
+- [ ] All steps execute in correct order
+- [ ] Wrapped in transaction (optional but recommended)
+- [ ] Returns created LinkedAttribute
+- [ ] Unit tests pass
+- [ ] Integration test verifies end-to-end flow
+
+---
+
+## Task 1.5: Backfill Mechanism
+**Duration: 3 hours | Files: linked_attributes.service.ts**
+
+### Objective
+Implement a mechanism to update existing entity flatjsons with newly created linked attributes.
+
+### Requirements
+
+1. **Add public async method: backfillLinkedAttribute()**
+```typescript
+   /**
+    * Backfill existing entities with a new linked attribute
+    * @param linked_attribute_id - ID of the linked attribute to backfill
+    * @param loggedInUser - Current user context
+    * @returns Summary of backfill operation
+    */
+   async backfillLinkedAttribute(
+     linked_attribute_id: number,
+     loggedInUser: any
+   ): Promise<{
+     total: number;
+     updated: number;
+     failed: number;
+     errors: Array<{ entity_id: number; error: string }>;
+   }>
+```
+
+2. **Inject EntityJSONService dependency:**
+```typescript
+   @Inject() private readonly entityJsonService: EntityJSONService,
+```
+
+3. **Implementation:**
+```typescript
+   async backfillLinkedAttribute(linked_attribute_id, loggedInUser) {
+     // Step 1: Load linked attribute
+     const linkedAttr = await this.dataSource
+       .getRepository(LinkedAttributes)
+       .findOne({ where: { id: linked_attribute_id } });
+     
+     if (!linkedAttr) {
+       throw new NotFoundException(`LinkedAttribute with ID ${linked_attribute_id} not found`);
+     }
+     
+     // Step 2: Get all entities of this type
+     const entityJsonRecords = await this.dataSource
+       .getRepository('frm_entity_json')
+       .createQueryBuilder('ej')
+       .select(['ej.entity_id'])
+       .where('ej.entity_type = :entityType', { entityType: linkedAttr.mapped_entity_type })
+       .andWhere('ej.organization_id = :orgId', { orgId: loggedInUser.organization_id })
+       .getMany();
+     
+     // Step 3: Process in batches
+     const batchSize = 100;
+     const results = {
+       total: entityJsonRecords.length,
+       updated: 0,
+       failed: 0,
+       errors: []
+     };
+     
+     for (let i = 0; i < entityJsonRecords.length; i += batchSize) {
+       const batch = entityJsonRecords.slice(i, i + batchSize);
+       
+       for (const record of batch) {
+         try {
+           await this.entityJsonService.updateEntityJSON(
+             linkedAttr.mapped_entity_type,
+             record.entity_id,
+             loggedInUser
+           );
+           results.updated++;
+         } catch (error) {
+           results.failed++;
+           results.errors.push({
+             entity_id: record.entity_id,
+             error: error.message
+           });
+           console.error(`Failed to update entity ${record.entity_id}:`, error);
+         }
+       }
+       
+       // Log progress
+       console.log(`Backfill progress: ${Math.min(i + batchSize, results.total)}/${results.total}`);
+     }
+     
+     return results;
+   }
+```
+
+4. **Add helper method: backfillAllForEntity()**
+```typescript
+   /**
+    * Backfill all linked attributes for an entity type
+    * @param mapped_entity_type - Entity type to backfill
+    * @param loggedInUser - Current user context
+    * @returns Summary of backfill operation
+    */
+   async backfillAllForEntity(
+     mapped_entity_type: string,
+     loggedInUser: any
+   ): Promise<{ updated: number; failed: number }>
+```
+   
+   Implementation: Similar to above, but updates all entities regardless of linked attributes.
+
+### Testing Requirements
+- Test backfill with 0 entities (edge case)
+- Test backfill with 1 entity
+- Test backfill with 1000+ entities (performance test)
+- Test handling of partial failures (some entities fail)
+- Mock EntityJSONService.updateEntityJSON
+
+### Acceptance Criteria
+- [ ] Backfill method implemented
+- [ ] Processes in batches (configurable size)
+- [ ] Continues on individual failures
+- [ ] Returns detailed summary
+- [ ] Logs progress to console
+- [ ] Unit tests pass
+- [ ] Performance acceptable (<10 seconds for 10k entities)
+
+---
+
+## Task 1.6: Update Existing CRUD & Controller
+**Duration: 1 hour | Files: linked_attributes.controller.ts, linked_attributes.service.ts**
+
+### Objective
+Add new API endpoints for smart creation and backfilling.
+
+### Requirements
+
+1. **Update Controller: `linked_attributes.controller.ts`**
+
+   Add new endpoints:
+```typescript
+   import { Body, Controller, Post, Param, Get, Query } from '@nestjs/common';
+   import { ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+   import { CreateLinkedAttributeSmartDto } from '../dto/create-linked-attribute-smart.dto';
+   
+   @ApiTags('Linked Attributes')
+   @Controller('linked-attributes')
+   export class LinkedAttributesController {
+     constructor(private readonly linkedAttributesService: LinkedAttributesService) {}
+     
+     @Post('/smart')
+     @ApiOperation({ summary: 'Create linked attribute with auto-generation' })
+     @ApiResponse({ status: 201, description: 'Linked attribute created successfully' })
+     @ApiResponse({ status: 400, description: 'Validation failed' })
+     async createSmart(
+       @Body() dto: CreateLinkedAttributeSmartDto,
+       @Req() req: any
+     ) {
+       return await this.linkedAttributesService.createLinkedAttributeSmart(
+         dto,
+         req.loggedInUser
+       );
+     }
+     
+     @Post('/:id/backfill')
+     @ApiOperation({ summary: 'Backfill existing entities with new linked attribute' })
+     @ApiResponse({ status: 200, description: 'Backfill completed' })
+     @ApiResponse({ status: 404, description: 'Linked attribute not found' })
+     async backfill(
+       @Param('id') id: number,
+       @Req() req: any
+     ) {
+       return await this.linkedAttributesService.backfillLinkedAttribute(
+         id,
+         req.loggedInUser
+       );
+     }
+     
+     @Post('/backfill-all')
+     @ApiOperation({ summary: 'Backfill all entities of a given type' })
+     @ApiResponse({ status: 200, description: 'Backfill completed' })
+     async backfillAll(
+       @Query('entity_type') entity_type: string,
+       @Req() req: any
+     ) {
+       return await this.linkedAttributesService.backfillAllForEntity(
+         entity_type,
+         req.loggedInUser
+       );
+     }
+     
+     @Get('/preview-key')
+     @ApiOperation({ summary: 'Preview generated attribute key before creation' })
+     @ApiResponse({ status: 200, description: 'Preview generated successfully' })
+     async previewKey(
+       @Query('entity_type') entity_type: string,
+       @Query('attribute_key') attribute_key: string,
+       @Query('organization_id') organization_id: number,
+       @Req() req: any
+     ) {
+       const sequence = await this.linkedAttributesService['generateNextSequence'](
+         req.query.mapped_entity_type,
+         entity_type,
+         attribute_key,
+         organization_id
+       );
+       
+       const generated_key = this.linkedAttributesService.generateAttributeKey(
+         entity_type,
+         attribute_key,
+         sequence
+       );
+       
+       return { generated_key, sequence };
+     }
+   }
+```
+
+2. **Update existing createEntity() with deprecation warning:**
+```typescript
+   async createEntity(payload: any, loggedInUser: any): Promise<any> {
+     console.warn('[DEPRECATED] Use createLinkedAttributeSmart() instead of createEntity()');
+     
+     // Keep old logic for backward compatibility
+     if (!payload.attribute_key || payload.attribute_key.trim() === '') {
+       payload.attribute_key = payload.field_name
+         .trim()
+         .toLowerCase()
+         .replace(/\s+/g, '_');
+     }
+     
+     return super.createEntity(payload, loggedInUser);
+   }
+```
+
+### Testing Requirements
+- Test each new endpoint with Postman or automated tests
+- Verify Swagger documentation renders correctly
+- Test backward compatibility (old endpoint still works)
+
+### Acceptance Criteria
+- [ ] New endpoints added to controller
+- [ ] Swagger documentation complete
+- [ ] Old endpoints still functional (backward compatible)
+- [ ] Deprecation warning logged for old method
+- [ ] All endpoints tested
+
+---
+
+## Task 1.7: Testing & Edge Cases
+**Duration: 2 hours | Files: *.spec.ts**
+
+### Objective
+Write comprehensive tests for all Phase 1 functionality.
+
+### Requirements
+
+1. **Unit Tests (linked_attributes.service.spec.ts):**
+
+   Test suites to create:
+   
+   a. **generateNextSequence()**
+   - Returns 1 when no records exist
+   - Returns max + 1 when records exist
+   - Handles NULL max correctly
+   
+   b. **generateAttributeKey()**
+   - Generates correct format
+   - Throws error for empty entity_type
+   - Throws error for empty attribute_key
+   - Throws error for sequence < 1
+   
+   c. **validateLinkedAttribute()**
+   - Returns valid: true for correct data
+   - Returns error for duplicate key
+   - Returns error for invalid entity type
+   - Returns error for invalid attribute
+   - Returns multiple errors when multiple issues exist
+   
+   d. **createFilterForLinkedAttribute()**
+   - Creates filter master with unique code
+   - Creates filter details for each condition
+   - Returns generated filter code
+   - Rolls back on error
+   
+   e. **createLinkedAttributeSmart()**
+   - Happy path: creates successfully
+   - Throws BadRequestException on validation failure
+   - Creates filter when conditions provided
+   - Skips filter when no conditions
+   - Triggers backfill when requested
+   
+   f. **backfillLinkedAttribute()**
+   - Handles 0 entities gracefully
+   - Updates all entities successfully
+   - Continues on partial failures
+   - Returns correct summary
+
+2. **Integration Tests (linked_attributes.integration.spec.ts):**
+
+   Create end-to-end test:
+```typescript
+   describe('LinkedAttributes Integration', () => {
+     it('should create linked attribute and backfill entities', async () => {
+       // Setup: Create test entities
+       // Action: Create linked attribute with backfill
+       // Assert: Verify flatjson updated for all entities
+     });
+   });
+```
+
+3. **Edge Cases to Test:**
+   - Concurrent creation of linked attributes (race conditions)
+   - Very long field names
+   - Special characters in entity/attribute names
+   - Large batch backfill (1000+ entities)
+   - Filter conditions with various operators
+
+### Testing Tools Setup
+```typescript
+// Mock setup example
+const mockDataSource = {
+  getRepository: jest.fn().mockReturnValue({
+    createQueryBuilder: jest.fn().mockReturnThis(),
+    where: jest.fn().mockReturnThis(),
+    andWhere: jest.fn().mockReturnThis(),
+    getRawOne: jest.fn(),
+    getMany: jest.fn(),
+  }),
+  transaction: jest.fn((cb) => cb(mockDataSource)),
+};
+```
+
+### Acceptance Criteria
+- [ ] All unit tests pass
+- [ ] Integration tests pass
+- [ ] Code coverage > 80%
+- [ ] All edge cases covered
+- [ ] Performance tests show acceptable speed
+- [ ] No race condition issues
+
+---
+
+# PHASE 2: FLATJSON FILTERING SERVICE
+**Priority: CRITICAL | Duration: 18-20 hours**
+
+## Task 2.1: Database Index Creation
+**Duration: 30 minutes | Files: migrations/**
+
+### Objective
+Create GIN index on the flatjson column for optimized JSONB queries.
+
+### Requirements
+
+1. **Create migration file:**
+```bash
+   npm run typeorm migration:create src/migrations/AddEntityJsonGinIndex
+```
+
+2. **Implement migration: `{timestamp}-AddEntityJsonGinIndex.ts`**
+```typescript
+   import { MigrationInterface, QueryRunner } from 'typeorm';
+   
+   export class AddEntityJsonGinIndex{timestamp} implements MigrationInterface {
+     name = 'AddEntityJsonGinIndex{timestamp}';
+   
+     public async up(queryRunner: QueryRunner): Promise<void> {
+       // GIN index for JSONB operations (containment, existence checks)
+       await queryRunner.query(`
+         CREATE INDEX IF NOT EXISTS idx_entity_json_data_gin 
+         ON frm_entity_json 
+         USING GIN (json_data jsonb_path_ops);
+       `);
+       
+       // Standard B-tree index for entity_type lookups
+       await queryRunner.query(`
+         CREATE INDEX IF NOT EXISTS idx_entity_json_entity_type 
+         ON frm_entity_json (entity_type);
+       `);
+       
+       // Composite index for entity_type + entity_id lookups
+       await queryRunner.query(`
+         CREATE INDEX IF NOT EXISTS idx_entity_json_composite 
+         ON frm_entity_json (entity_type, entity_id);
+       `);
+       
+       console.log('✅ GIN indexes created successfully');
+     }
+   
+     public async up(queryRunner: QueryRunner): Promise<void> {
+       await queryRunner.query(`DROP INDEX IF EXISTS idx_entity_json_data_gin;`);
+       await queryRunner.query(`DROP INDEX IF EXISTS idx_entity_json_entity_type;`);
+       await queryRunner.query(`DROP INDEX IF EXISTS idx_entity_json_composite;`);
+       
+       console.log('✅ GIN indexes dropped successfully');
+     }
+   }
+```
+
+3. **Run migration:**
+```bash
+   npm run typeorm migration:run
+```
+
+4. **Verify index creation:**
+```sql
+   -- Run this query to verify
+   SELECT 
+     schemaname,
+     tablename,
+     indexname,
+     indexdef
+   FROM pg_indexes
+   WHERE tablename = 'frm_entity_json';
+```
+
+### Testing Requirements
+- Test migration up (creates indexes)
+- Test migration down (drops indexes)
+- Verify query planner uses GIN index with EXPLAIN ANALYZE
+
+### Acceptance Criteria
+- [ ] Migration file created
+- [ ] Migration runs successfully
+- [ ] All 3 indexes created
+- [ ] Query planner shows index usage
+- [ ] Rollback migration works
+
+---
+
+## Task 2.2: Service Skeleton & Infrastructure
+**Duration: 2 hours | Files: filter/service/flatjson-filter.service.ts**
+
+### Objective
+Create the base structure for the new flatjson filtering service.
+
+### Requirements
+
+1. **Create service file: `src/module/filter/service/flatjson-filter.service.ts`**
+```typescript
+   import { Injectable, BadRequestException } from '@nestjs/common';
+   import { EntityManager, SelectQueryBuilder } 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 { FilterRequestDto, FilterCondition, SortConfig } from '../dto/filter-request.dto';
+   import { EntityJson } from 'src/module/entity_json/entity/entityJson.entity';
+   
+   /**
+    * JSONB query condition structure
+    */
+   interface JsonbCondition {
+     query: string;
+     params: Record<string, any>;
+   }
+   
+   @Injectable()
+   export class FlatjsonFilterService {
+     constructor(
+       private readonly entityManager: EntityManager,
+       private readonly entityMasterService: EntityMasterService,
+       private readonly attributeMasterService: AttributeMasterService,
+       private readonly resolverService: ResolverService,
+       private readonly loggingService: LoggingService,
+       private readonly configService: ConfigService,
+     ) {}
+   
+     /**
+      * Main filtering method - queries frm_entity_json table
+      */
+     async applyFlatjsonFilter(dto: FilterRequestDto): Promise<any> {
+       // TODO: Implement in Task 2.7
+       throw new Error('Not implemented yet');
+     }
+   
+     /**
+      * Build JSONB where clauses from filter conditions
+      */
+     private buildJsonbConditions(
+       filters: FilterCondition[],
+       attributeMetaMap: Record<string, any>
+     ): JsonbCondition[] {
+       // TODO: Implement in Task 2.7
+       return [];
+     }
+   
+     /**
+      * Build a single JSONB condition based on data type
+      */
+     private buildJsonbCondition(
+       filter: FilterCondition,
+       meta: any
+     ): JsonbCondition | null {
+       if (!meta) return null;
+   
+       const flatJsonKey = meta.flat_json_key || `${meta.mapped_entity_type}__${filter.filter_attribute}`;
+       const op = filter.filter_operator;
+       const val = filter.filter_value;
+       const key = `param_${filter.filter_attribute}_${Math.random().toString(36).substring(2, 8)}`;
+   
+       switch (meta.data_type) {
+         case 'text':
+           return this.buildTextCondition(flatJsonKey, op, val, key);
+         case 'number':
+           return this.buildNumberCondition(flatJsonKey, op, val, key);
+         case 'date':
+           return this.buildDateCondition(flatJsonKey, op, val, key);
+         case 'select':
+         case 'radio':
+           return this.buildSelectCondition(flatJsonKey, op, val, key);
+         case 'multiselect':
+         case 'checkbox':
+           return this.buildMultiSelectCondition(flatJsonKey, op, val, key);
+         case 'year':
+           return this.buildYearCondition(flatJsonKey, op, val, key);
+         default:
+           return null;
+       }
+     }
+   
+     /**
+      * Build text condition (JSONB ->> operator)
+      */
+     private buildTextCondition(
+       flatJsonKey: string,
+       operator: string,
+       value: any,
+       paramKey: string
+     ): JsonbCondition | null {
+       // TODO: Implement in Task 2.3
+       return null;
+     }
+   
+     /**
+      * Build number condition (JSONB ->> with ::int cast)
+      */
+     private buildNumberCondition(
+       flatJsonKey: string,
+       operator: string,
+       value: any,
+       paramKey: string
+     ): JsonbCondition | null {
+       // TODO: Implement in Task 2.4
+       return null;
+     }
+   
+     /**
+      * Build date condition (JSONB ->> with ::bigint cast for epoch ms)
+      */
+     private buildDateCondition(
+       flatJsonKey: string,
+       operator: string,
+       value: any,
+       paramKey: string
+     ): JsonbCondition | null {
+       // TODO: Implement in Task 2.5
+       return null;
+     }
+   
+     /**
+      * Build select condition (single value)
+      */
+     private buildSelectCondition(
+       flatJsonKey: string,
+       operator: string,
+       value: any,
+       paramKey: string
+     ): JsonbCondition | null {
+       // TODO: Implement in Task 2.6
+       return null;
+     }
+   
+     /**
+      * Build multiselect condition (JSONB -> with ? operators for arrays)
+      */
+     private buildMultiSelectCondition(
+       flatJsonKey: string,
+       operator: string,
+       value: any,
+       paramKey: string
+     ): JsonbCondition | null {
+       // TODO: Implement in Task 2.6
+       return null;
+     }
+   
+     /**
+      * Build year condition
+      */
+     private buildYearCondition(
+       flatJsonKey: string,
+       operator: string,
+       value: any,
+       paramKey: string
+     ): JsonbCondition | null {
+       // Similar to number condition
+       return this.buildNumberCondition(flatJsonKey, operator, value, paramKey);
+     }
+   
+     /**
+      * Get tab aggregation counts from JSONB
+      */
+     private async getJsonbTabCounts(
+       entity_type: string,
+       flatJsonKey: string,
+       whereClauses: JsonbCondition[]
+     ): Promise<Array<{ tab_value: string; tab_value_count: number }>> {
+       // TODO: Implement in Task 2.8
+       return [];
+     }
+   
+     /**
+      * Apply sorting on JSONB fields
+      */
+     private applyJsonbSorting(
+       qb: SelectQueryBuilder<EntityJson>,
+       sortby: SortConfig[],
+       attributeMetaMap: Record<string, any>
+     ): void {
+       // TODO: Implement in Task 2.9
+     }
+   }
+```
+
+2. **Register service in module: `src/module/filter/filter.module.ts`**
+```typescript
+   import { FlatjsonFilterService } from './service/flatjson-filter.service';
+   
+   @Module({
+     imports: [TypeOrmModule.forFeature([...])],
+     providers: [
+       FilterService,
+       FlatjsonFilterService, // Add this
+       SavedFilterService,
+       // ... other providers
+     ],
+     exports: [
+       FilterService,
+       FlatjsonFilterService, // Add this
+       SavedFilterService,
+     ],
+   })
+   export class FilterModule {}
+```
+
+### Testing Requirements
+- Service can be instantiated
+- All dependencies inject correctly
+- Skeleton methods exist (even if throwing "Not implemented")
+
+### Acceptance Criteria
+- [ ] Service file created with all method signatures
+- [ ] Registered in module
+- [ ] All dependencies injected
+- [ ] TypeScript compiles without errors
+- [ ] Service can be imported in other modules
+
+---
+
+## Task 2.3: JSONB Query Builders - Text Type
+**Duration: 2 hours | Files: flatjson-filter.service.ts**
+
+### Objective
+Implement JSONB query building for text data type.
+
+### Requirements
+
+**Implement `buildTextCondition()` method:**
+```typescript
+private buildTextCondition(
+  flatJsonKey: string,
+  operator: string,
+  value: any,
+  paramKey: string
+): JsonbCondition | null {
+  // Text is already stored lowercase in flatjson
+  const lowerValue = value ? String(value).toLowerCase() : '';
+  
+  switch (operator) {
+    case 'equal':
+      return {
+        query: `json_data->>'${flatJsonKey}' = :${paramKey}`,
+        params: { [paramKey]: lowerValue }
+      };
+    
+    case 'not_equal':
+      return {
+        query: `json_data->>'${flatJsonKey}' != :${paramKey}`,
+        params: { [paramKey]: lowerValue }
+      };
+    
+    case 'contains':
+      return {
+        query: `json_data->>'${flatJsonKey}' LIKE :${paramKey}`,
+        params: { [paramKey]: `%${lowerValue}%` }
+      };
+    
+    case 'not_contains':
+      return {
+        query: `json_data->>'${flatJsonKey}' NOT LIKE :${paramKey}`,
+        params: { [paramKey]: `%${lowerValue}%` }
+      };
+    
+    case 'starts_with':
+      return {
+        query: `json_data->>'${flatJsonKey}' LIKE :${paramKey}`,
+        params: { [paramKey]: `${lowerValue}%` }
+      };
+    
+    case 'ends_with':
+      return {
+        query: `json_data->>'${flatJsonKey}' LIKE :${paramKey}`,
+        params: { [paramKey]: `%${lowerValue}` }
+      };
+    
+    case 'empty':
+      return {
+        query: `(json_data->>'${flatJsonKey}' IS NULL OR json_data->>'${flatJsonKey}' = '')`,
+        params: {}
+      };
+    
+    case 'not_empty':
+      return {
+        query: `(json_data->>'${flatJsonKey}' IS NOT NULL AND json_data->>'${flatJsonKey}' != '')`,
+        params: {}
+      };
+    
+    default:
+      console.warn(`Unsupported text operator: ${operator}`);
+      return null;
+  }
+}
+```
+
+### Testing Requirements
+Create test file: `flatjson-filter.service.spec.ts`
+```typescript
+describe('FlatjsonFilterService - Text Conditions', () => {
+  it('should build equal condition', () => {
+    const condition = service['buildTextCondition']('LEAD__name', 'equal', 'John', 'param1');
+    expect(condition.query).toBe("json_data->>'LEAD__name' = :param1");
+    expect(condition.params.param1).toBe('john');
+  });
+  
+  it('should build contains condition', () => {
+    const condition = service['buildTextCondition']('LEAD__name', 'contains', 'John', 'param1');
+    expect(condition.query).toContain('LIKE');
+    expect(condition.params.param1).toBe('%john%');
+  });
+  
+  it('should handle empty operator', () => {
+    const condition = service['buildTextCondition']('LEAD__name', 'empty', null, 'param1');
+    expect(condition.query).toContain('IS NULL');
+  });
+  
+  // Add tests for all operators
+});
+```
+
+### Acceptance Criteria
+- [ ] All text operators implemented
+- [ ] Values converted to lowercase
+- [ ] LIKE patterns correct for contains/starts_with/ends_with
+- [ ] Empty/not_empty handle NULL and empty string
+- [ ] Unit tests pass
+- [ ] No SQL injection vulnerabilities (parameterized queries)
+
+---
+
+## Task 2.4: JSONB Query Builders - Number Type
+**Duration: 1.5 hours | Files: flatjson-filter.service.ts**
+
+### Objective
+Implement JSONB query building for number data type.
+
+### Requirements
+
+**Implement `buildNumberCondition()` method:**
+```typescript
+private buildNumberCondition(
+  flatJsonKey: string,
+  operator: string,
+  value: any,
+  paramKey: string
+): JsonbCondition | null {
+  // Cast JSONB text to numeric for comparison
+  const jsonbField = `(json_data->>'${flatJsonKey}')::numeric`;
+  
+  switch (operator) {
+    case 'equal':
+      return {
+        query: `${jsonbField} = :${paramKey}`,
+        params: { [paramKey]: Number(value) }
+      };
+    
+    case 'not_equal':
+      return {
+        query: `${jsonbField} != :${paramKey}`,
+        params: { [paramKey]: Number(value) }
+      };
+    
+    case 'greater_than':
+      return {
+        query: `${jsonbField} > :${paramKey}`,
+        params: { [paramKey]: Number(value) }
+      };
+    
+    case 'less_than':
+      return {
+        query: `${jsonbField} < :${paramKey}`,
+        params: { [paramKey]: Number(value) }
+      };
+    
+    case 'greater_than_equal_to':
+      return {
+        query: `${jsonbField} >= :${paramKey}`,
+        params: { [paramKey]: Number(value) }
+      };
+    
+    case 'less_than_equal_to':
+      return {
+        query: `${jsonbField} <= :${paramKey}`,
+        params: { [paramKey]: Number(value) }
+      };
+    
+    case 'between':
+      // Value should be array [min, max] or string "min,max"
+      let range: number[];
+      if (typeof value === 'string') {
+        range = value.split(',').map(v => Number(v.trim()));
+      } else if (Array.isArray(value)) {
+        range = value.map(v => Number(v));
+      } else {
+        return null;
+      }
+      
+      if (range.length !== 2) return null;
+      
+      return {
+        query: `${jsonbField} BETWEEN :${paramKey}_min AND :${paramKey}_max`,
+        params: {
+          [`${paramKey}_min`]: range[0],
+          [`${paramKey}_max`]: range[1]
+        }
+      };
+    
+    case 'empty':
+      return {
+        query: `json_data->>'${flatJsonKey}' IS NULL`,
+        params: {}
+      };
+    
+    case 'not_empty':
+      return {
+        query: `json_data->>'${flatJsonKey}' IS NOT NULL`,
+        params: {}
+      };
+    
+    default:
+      console.warn(`Unsupported number operator: ${operator}`);
+      return null;
+  }
+}
+```
+
+### Testing Requirements
+```typescript
+describe('FlatjsonFilterService - Number Conditions', () => {
+  it('should build greater_than condition with type casting', () => {
+    const condition = service['buildNumberCondition']('LEAD__age', 'greater_than', 18, 'param1');
+    expect(condition.query).toContain('::numeric >');
+    expect(condition.params.param1).toBe(18);
+  });
+  
+  it('should build between condition', () => {
+    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);
+  });
+  
+  // Add tests for all operators
+});
+```
+
+### Acceptance Criteria
+- [ ] All number operators implemented
+- [ ] Proper type casting to `::numeric`
+- [ ] Between operator handles array and string input
+- [ ] Values converted to Number type
+- [ ] Unit tests pass
+
+---
+
+## Task 2.5: JSONB Query Builders - Date Type
+**Duration: 3 hours | Files: flatjson-filter.service.ts**
+
+### Objective
+Implement JSONB query building for date data type (stored as epoch milliseconds).
+
+### Requirements
+
+**Implement `buildDateCondition()` method:**
+
+This is the most complex condition builder due to various date operators. Reference the existing `FilterService.buildDateCondition()` and adapt for JSONB.
+```typescript
+private buildDateCondition(
+  flatJsonKey: string,
+  operator: string,
+  value: any,
+  paramKey: string
+): JsonbCondition | null {
+  // Dates stored as epoch milliseconds (bigint)
+  const jsonbField = `(json_data->>'${flatJsonKey}')::bigint`;
+  
+  // Helper: Convert date string to epoch ms
+  const toEpochMs = (dateStr: string): number => {
+    return new Date(dateStr).getTime();
+  };
+  
+  // Helper: Get date N days ago
+  const daysAgo = (days: number): number => {
+    const d = new Date();
+    d.setDate(d.getDate() - days);
+    return d.getTime();
+  };
+  
+  // Helper: Get date N days from now
+  const daysFromNow = (days: number): number => {
+    const d = new Date();
+    d.setDate(d.getDate() + days);
+    return d.getTime();
+  };
+  
+  // Helper: Subtract business days (skip weekends)
+  const subtractBusinessDays = (days: number): number => {
+    let d = new Date();
+    let count = 0;
+    
+    while (count < days) {
+      d.setDate(d.getDate() - 1);
+      const day = d.getDay(); // 0=Sun, 6=Sat
+      if (day !== 0 && day !== 6) {
+        count++;
+      }
+    }
+    
+    return d.getTime();
+  };
+  
+  const numVal = Number(value);
+  
+  switch (operator) {
+    // Basic comparisons
+    case 'equal':
+    case 'is':
+      return {
+        query: `${jsonbField} = :${paramKey}`,
+        params: { [paramKey]: toEpochMs(value) }
+      };
+    
+    case 'before':
+    case 'is_before':
+      return {
+        query: `${jsonbField} < :${paramKey}`,
+        params: { [paramKey]: toEpochMs(value) }
+      };
+    
+    case 'after':
+    case 'is_after':
+      return {
+        query: `${jsonbField} > :${paramKey}`,
+        params: { [paramKey]: toEpochMs(value) }
+      };
+    
+    case 'is_on_or_before':
+      return {
+        query: `${jsonbField} <= :${paramKey}`,
+        params: { [paramKey]: toEpochMs(value) }
+      };
+    
+    case 'is_on_or_after':
+      return {
+        query: `${jsonbField} >= :${paramKey}`,
+        params: { [paramKey]: toEpochMs(value) }
+      };
+    
+    // Day offset logic
+    case 'is_day_before':
+      if (isNaN(numVal)) return null;
+      return {
+        query: `${jsonbField} <= :${paramKey}`,
+        params: { [paramKey]: daysAgo(numVal) }
+      };
+    
+    case 'is_day_after':
+      if (isNaN(numVal)) return null;
+      return {
+        query: `${jsonbField} >= :${paramKey}`,
+        params: { [paramKey]: daysFromNow(numVal) }
+      };
+    
+    // Business days (skip weekends)
+    case 'is_before_business_days':
+      if (isNaN(numVal)) return null;
+      return {
+        query: `${jsonbField} <= :${paramKey}`,
+        params: { [paramKey]: subtractBusinessDays(numVal) }
+      };
+    
+    case 'is_after_business_days':
+      if (isNaN(numVal)) return null;
+      // Similar implementation for forward business days
+      return null; // Implement as needed
+    
+    // Range operators
+    case 'between':
+      let range: string[];
+      if (typeof value === 'string') {
+        range = value.split(',').map(v => v.trim());
+      } else if (Array.isArray(value)) {
+        range = value;
+      } else {
+        return null;
+      }
+      
+      if (range.length !== 2) return null;
+      
+      return {
+        query: `${jsonbField} BETWEEN :${paramKey}_start AND :${paramKey}_end`,
+        params: {
+          [`${paramKey}_start`]: toEpochMs(range[0]),
+          [`${paramKey}_end`]: toEpochMs(range[1])
+        }
+      };
+    
+    case 'in_last_day':
+      if (isNaN(numVal)) return null;
+      return {
+        query: `${jsonbField} BETWEEN :${paramKey}_start AND :${paramKey}_end`,
+        params: {
+          [`${paramKey}_start`]: daysAgo(numVal),
+          [`${paramKey}_end`]: Date.now()
+        }
+      };
+    
+    case 'in_next_day':
+      if (isNaN(numVal)) return null;
+      return {
+        query: `${jsonbField} BETWEEN :${paramKey}_start AND :${paramKey}_end`,
+        params: {
+          [`${paramKey}_start`]: Date.now(),
+          [`${paramKey}_end`]: daysFromNow(numVal)
+        }
+      };
+    
+    // Special cases
+    case 'today':
+      const todayStart = new Date().setHours(0, 0, 0, 0);
+      const todayEnd = new Date().setHours(23, 59, 59, 999);
+      return {
+        query: `${jsonbField} BETWEEN :${paramKey}_start AND :${paramKey}_end`,
+        params: {
+          [`${paramKey}_start`]: todayStart,
+          [`${paramKey}_end`]: todayEnd
+        }
+      };
+    
+    case 'empty':
+      return {
+        query: `json_data->>'${flatJsonKey}' IS NULL`,
+        params: {}
+      };
+    
+    case 'not_empty':
+      return {
+        query: `json_data->>'${flatJsonKey}' IS NOT NULL`,
+        params: {}
+      };
+    
+    default:
+      console.warn(`Unsupported date operator: ${operator}`);
+      return null;
+  }
+}
+```
+
+### Testing Requirements
+```typescript
+describe('FlatjsonFilterService - Date Conditions', () => {
+  it('should build is_before condition with epoch ms', () => {
+    const condition = service['buildDateCondition'](
+      'LEAD__created_at',
+      'is_before',
+      '2024-01-01',
+      'param1'
+    );
+    expect(condition.query).toContain('::bigint <');
+    expect(condition.params.param1).toBe(new Date('2024-01-01').getTime());
+  });
+  
+  it('should build in_last_day condition', () => {
+    const condition = service['buildDateCondition'](
+      'LEAD__created_at',
+      'in_last_day',
+      7,
+      'param1'
+    );
+    expect(condition.query).toContain('BETWEEN');
+    expect(condition.params.param1_start).toBeLessThan(Date.now());
+  });
+  
+  it('should build today condition', () => {
+    const condition = service['buildDateCondition'](
+      'LEAD__created_at',
+      'today',
+      null,
+      'param1'
+    );
+    expect(condition.query).toContain('BETWEEN');
+  });
+  
+  // Add tests for all operators, especially business days
+});
+```
+
+### Acceptance Criteria
+- [ ] All date operators from FilterService ported
+- [ ] Proper type casting to `::bigint`
+- [ ] Epoch millisecond conversions correct
+- [ ] Business day logic works (skips weekends)
+- [ ] Range operators (between, in_last_day) work
+- [ ] Unit tests pass
+- [ ] Edge cases covered (leap years, month boundaries)
+
+---
+
+## Task 2.6: JSONB Query Builders - Select/Multiselect
+**Duration: 2 hours | Files: flatjson-filter.service.ts**
+
+### Objective
+Implement JSONB query building for select (single) and multiselect (array) data types.
+
+### Requirements
+
+**1. Implement `buildSelectCondition()` for single-value selects:**
+```typescript
+private buildSelectCondition(
+  flatJsonKey: string,
+  operator: string,
+  value: any,
+  paramKey: string
+): JsonbCondition | null {
+  switch (operator) {
+    case 'equal':
+      if (Array.isArray(value)) {
+        // IN operator for multiple values
+        return {
+          query: `json_data->>'${flatJsonKey}' = ANY(:${paramKey})`,
+          params: { [paramKey]: value.map(String) }
+        };
+      }
+      return {
+        query: `json_data->>'${flatJsonKey}' = :${paramKey}`,
+        params: { [paramKey]: String(value) }
+      };
+    
+    case 'not_equal':
+      if (Array.isArray(value)) {
+        // NOT IN operator
+        return {
+          query: `json_data->>'${flatJsonKey}' != ALL(:${paramKey})`,
+          params: { [paramKey]: value.map(String) }
+        };
+      }
+      return {
+        query: `json_data->>'${flatJsonKey}' != :${paramKey}`,
+        params: { [paramKey]: String(value) }
+      };
+    
+    case 'in':
+      const inValues = Array.isArray(value) ? value : [value];
+      return {
+        query: `json_data->>'${flatJsonKey}' = ANY(:${paramKey})`,
+        params: { [paramKey]: inValues.map(String) }
+      };
+    
+    case 'not_in':
+      const notInValues = Array.isArray(value) ? value : [value];
+      return {
+        query: `json_data->>'${flatJsonKey}' != ALL(:${paramKey})`,
+        params: { [paramKey]: notInValues.map(String) }
+      };
+    
+    case 'empty':
+      return {
+        query: `json_data->>'${flatJsonKey}' IS NULL`,
+        params: {}
+      };
+    
+    case 'not_empty':
+      return {
+        query: `json_data->>'${flatJsonKey}' IS NOT NULL`,
+        params: {}
+      };
+    
+    default:
+      console.warn(`Unsupported select operator: ${operator}`);
+      return null;
+  }
+}
+```
+
+**2. Implement `buildMultiSelectCondition()` for array values:**
+```typescript
+private buildMultiSelectCondition(
+  flatJsonKey: string,
+  operator: string,
+  value: any,
+  paramKey: string
+): JsonbCondition | null {
+  // Convert value to array if not already
+  let arr: string[];
+  if (Array.isArray(value)) {
+    arr = value.map(String);
+  } else if (typeof value === 'string') {
+    arr = value.split(',').map(v => v.trim());
+  } else {
+    arr = [String(value)];
+  }
+  
+  if (arr.length === 0) {
+    return { query: '1=1', params: {} }; // Always true for empty array
+  }
+  
+  switch (operator) {
+    case 'contains':
+    case 'has':
+      // Check if JSON array contains this element
+      // json_data->'LEAD__languages' ? 'hindi'
+      if (arr.length === 1) {
+        return {
+          query: `json_data->'${flatJsonKey}' ? :${paramKey}`,
+          params: { [paramKey]: arr[0] }
+        };
+      }
+      // For multiple values, check if contains ANY
+      return {
+        query: `json_data->'${flatJsonKey}' ?| ARRAY[:...${paramKey}]`,
+        params: { [paramKey]: arr }
+      };
+    
+    case 'contains_all':
+      // Check if JSON array contains ALL elements
+      // json_data->'LEAD__languages' ?& ARRAY['hindi', 'english']
+      return {
+        query: `json_data->'${flatJsonKey}' ?& ARRAY[:...${paramKey}]`,
+        params: { [paramKey]: arr }
+      };
+    
+    case 'contains_any':
+      // Check if JSON array contains ANY element
+      // json_data->'LEAD__languages' ?| ARRAY['hindi', 'english']
+      return {
+        query: `json_data->'${flatJsonKey}' ?| ARRAY[:...${paramKey}]`,
+        params: { [paramKey]: arr }
+      };
+    
+    case 'not_contains':
+      // Check if JSON array does NOT contain element
+      if (arr.length === 1) {
+        return {
+          query: `NOT (json_data->'${flatJsonKey}' ? :${paramKey})`,
+          params: { [paramKey]: arr[0] }
+        };
+      }
+      return {
+        query: `NOT (json_data->'${flatJsonKey}' ?| ARRAY[:...${paramKey}])`,
+        params: { [paramKey]: arr }
+      };
+    
+    case 'equal':
+      // Exact array match (order matters in PostgreSQL)
+      // This is tricky - might need to compare as JSON
+      return {
+        query: `json_data->'${flatJsonKey}'::jsonb = :${paramKey}::jsonb`,
+        params: { [paramKey]: JSON.stringify(arr) }
+      };
+    
+    case 'empty':
+      return {
+        query: `(json_data->>'${flatJsonKey}' IS NULL OR json_data->'${flatJsonKey}' = '[]'::jsonb)`,
+        params: {}
+      };
+    
+    case 'not_empty':
+      return {
+        query: `(json_data->>'${flatJsonKey}' IS NOT NULL AND json_data->'${flatJsonKey}' != '[]'::jsonb)`,
+        params: {}
+      };
+    
+    default:
+      console.warn(`Unsupported multiselect operator: ${operator}`);
+      return null;
+  }
+}
+```
+
+### Important JSONB Array Operators
+- `?` - Does the string exist as a top-level key/element?
+- `?|` - Do any of these array strings exist?
+- `?&` - Do all of these array strings exist?
+- `@>` - Does the left JSON contain the right JSON?
+- `<@` - Is the left JSON contained in the right JSON?
+
+### Testing Requirements
+```typescript
+describe('FlatjsonFilterService - Select Conditions', () => {
+  it('should build equal condition for single value', () => {
+    const condition = service['buildSelectCondition']('LEAD__status', 'equal', 'active', 'param1');
+    expect(condition.query).toContain("json_data->>'LEAD__status' =");
+    expect(condition.params.param1).toBe('active');
+  });
+  
+  it('should build IN condition for array value', () => {
+    const condition = service['buildSelectCondition'](
+      'LEAD__status',
+      'equal',
+      ['active', 'pending'],
+      'param1'
+    );
+    expect(condition.query).toContain('ANY');
+  });
+});
+
+describe('FlatjsonFilterService - Multiselect Conditions', () => {
+  it('should build contains condition using ? operator', () => {
+    const condition = service['buildMultiSelectCondition'](
+      'LEAD__languages',
+      'contains',
+      'hindi',
+      'param1'
+    );
+    expect(condition.query).toContain("json_data->'LEAD__languages' ?");
+    expect(condition.params.param1).toBe('hindi');
+  });
+  
+  it('should build contains_all condition using ?& operator', () => {
+    const condition = service['buildMultiSelectCondition'](
+      'LEAD__languages',
+      'contains_all',
+      ['hindi', 'english'],
+      'param1'
+    );
+    expect(condition.query).toContain('?&');
+    expect(condition.params.param1).toEqual(['hindi', 'english']);
+  });
+  
+  it('should handle empty array', () => {
+    const condition = service['buildMultiSelectCondition'](
+      'LEAD__languages',
+      'empty',
+      null,
+      'param1'
+    );
+    expect(condition.query).toContain('IS NULL');
+  });
+});
+```
+
+### Acceptance Criteria
+- [ ] Select conditions work for single and array values
+- [ ] Multiselect uses proper JSONB operators (`?`, `?|`, `?&`)
+- [ ] Array values converted to strings
+- [ ] Empty/not_empty handle NULL and empty arrays
+- [ ] Unit tests pass
+- [ ] Verify queries work with actual database
+
+---
+
+## Task 2.7: Main Filter Method Implementation
+**Duration: 4 hours | Files: flatjson-filter.service.ts**
+
+### Objective
+Implement the core `applyFlatjsonFilter()` method that orchestrates the entire filtering process.
+
+### Requirements
+
+**Implement the main filtering method:**
+```typescript
+async applyFlatjsonFilter(dto: FilterRequestDto): Promise<any> {
+  const {
+    entity_type,
+    quickFilter = [],
+    savedFilterCode,
+    attributeFilter = [],
+    tabs,
+    sortby,
+    loggedInUser,
+    queryParams,
+    page = 1,
+    size = 10,
+  } = dto;
+  
+  await this.loggingService.log(
+    'info',
+    'FlatjsonFilterService',
+    'applyFlatjsonFilter',
+    `Filtering ${entity_type} using flatjson`
+  );
+  
+  // Step 1: Load entity metadata
+  const entityMeta = await this.entityMasterService.getEntityData(
+    entity_type,
+    loggedInUser
+  );
+  
+  if (!entityMeta) {
+    throw new BadRequestException(`Invalid entity_type: ${entity_type}`);
+  }
+  
+  // Step 2: Load attribute metadata
+  const attributes = await this.attributeMasterService.findAttributesByMappedEntityType(
+    entity_type,
+    loggedInUser
+  );
+  
+  const attributeMetaMap = attributes.reduce((acc, attr) => {
+    acc[attr.attribute_key] = attr;
+    return acc;
+  }, {} as Record<string, any>);
+  
+  // Step 3: Merge all filters
+  const savedFilters = savedFilterCode
+    ? await this.getSavedFilters(savedFilterCode)
+    : [];
+  
+  const allFilters = [
+    ...quickFilter,
+    ...attributeFilter,
+    ...savedFilters,
+  ].filter(f => f.filter_value !== '' && f.filter_value != null);
+  
+  // Step 4: Build JSONB where clauses
+  const baseWhere = this.buildJsonbConditions(allFilters, attributeMetaMap);
+  
+  // Step 5: Add organization/level filter
+  const orgId = loggedInUser.organization_id;
+  const levelType = loggedInUser.level_type;
+  const levelId = loggedInUser.level_id;
+  
+  if (entity_type !== 'ORGP' && orgId && levelType && levelId) {
+    baseWhere.push({
+      query: `json_data->>'${entity_type}__organization_id' = :orgId 
+              AND json_data->>'${entity_type}__level_type' = :levelType 
+              AND json_data->>'${entity_type}__level_id' = :levelId`,
+      params: {
+        orgId: String(orgId),
+        levelType,
+        levelId: String(levelId)
+      }
+    });
+  }
+  
+  // Step 6: Handle queryParams filters
+  if (queryParams) {
+    Object.entries(queryParams).forEach(([key, value]) => {
+      if (!value) return;
+      
+      const flatKey = `${entity_type}__${key}`;
+      baseWhere.push({
+        query: `json_data->>'${flatKey}' = :qp_${key}`,
+        params: { [`qp_${key}`]: String(value) }
+      });
+    });
+  }
+  
+  // Step 7: Build query on frm_entity_json
+  let qb = this.entityManager
+    .getRepository(EntityJson)
+    .createQueryBuilder('ej')
+    .select('ej.json_data')
+    .where('ej.entity_type = :entityType', { entityType: entity_type });
+  
+  // Apply all where clauses
+  baseWhere.forEach(clause => {
+    qb.andWhere(clause.query, clause.params);
+  });
+  
+  // Step 8: Handle tabs (if provided)
+  let filteredTabs = [];
+  if (tabs?.columnName) {
+    const tabFlatKey = attributeMetaMap[tabs.columnName]?.flat_json_key 
+                       || `${entity_type}__${tabs.columnName}`;
+    
+    filteredTabs = await this.getJsonbTabCounts(
+      entity_type,
+      tabFlatKey,
+      baseWhere
+    );
+    
+    // Apply tab filter if not "all"
+    if (tabs.value && tabs.value.toLowerCase() !== 'all') {
+      qb.andWhere(`json_data->>'${tabFlatKey}' = :tabValue`, {
+        tabValue: tabs.value.toLowerCase()
+      });
+    }
+  }
+  
+  // Step 9: Apply sorting
+  if (sortby?.length > 0) {
+    this.applyJsonbSorting(qb, sortby, attributeMetaMap);
+  } else {
+    // Default sort by created_at
+    qb.orderBy(`(json_data->>'${entity_type}__created_at')::bigint`, 'DESC');
+  }
+  
+  // Step 10: Get total count (before pagination)
+  const countQb = qb.clone();
+  const totalCount = await countQb.getCount();
+  
+  // Step 11: Apply pagination
+  const actualPage = page > 0 ? page : 1;
+  const actualSize = size > 0 ? size : 10;
+  qb.skip((actualPage - 1) * actualSize).take(actualSize);
+  
+  // Step 12: Execute query
+  const startTime = Date.now();
+  const results = await qb.getRawMany();
+  const queryTime = Date.now() - startTime;
+  
+  await this.loggingService.log(
+    'info',
+    'FlatjsonFilterService',
+    'applyFlatjsonFilter',
+    `Query executed in ${queryTime}ms, returned ${results.length} records`
+  );
+  
+  // Step 13: Extract json_data from results
+  const entity_list = results.map(r => r.ej_json_data);
+  
+  // Step 14: Resolve data (if needed - optional)
+  const resolvedEntityList = await Promise.all(
+    entity_list.map(row =>
+      this.resolverService.getResolvedData(loggedInUser, row, entity_type)
+    )
+  );
+  
+  // Step 15: Return formatted response
+  return {
+    success: true,
+    data: {
+      entity_tabs: filteredTabs,
+      entity_list: resolvedEntityList,
+      pagination: {
+        total: totalCount,
+        page: actualPage,
+        size: actualSize,
+        totalPages: Math.ceil(totalCount / actualSize),
+        hasNextPage: actualPage * actualSize < totalCount,
+        hasPreviousPage: actualPage > 1,
+      },
+    },
+    performance: {
+      query_time_ms: queryTime,
+      using_flatjson: true,
+    }
+  };
+}
+
+/**
+ * Build all JSONB conditions from filters
+ */
+private buildJsonbConditions(
+  filters: FilterCondition[],
+  attributeMetaMap: Record<string, any>
+): JsonbCondition[] {
+  return filters
+    .map(f => this.buildJsonbCondition(f, attributeMetaMap[f.filter_attribute]))
+    .filter((c): c is JsonbCondition => c !== null);
+}
+
+/**
+ * Get saved filters by code
+ */
+private async getSavedFilters(code: string): Promise<FilterCondition[]> {
+  // Inject SavedFilterService if not already
+  // Return saved filter conditions
+  // This mirrors FilterService.getSavedFilters()
+  return [];
+}
+```
+
+### Testing Requirements
+- Test with no filters (should return all entities of type)
+- Test with text filters
+- Test with number filters
+- Test with date filters
+- Test with pagination
+- Test with sorting
+- Test with tabs
+- Test performance (log query execution time)
+- Compare results with FilterService.applyFilter() for same input
+
+### Acceptance Criteria
+- [ ] Method implemented and working end-to-end
+- [ ] Queries frm_entity_json table only
+- [ ] Uses GIN index (verify with EXPLAIN ANALYZE)
+- [ ] Returns same structure as FilterService
+- [ ] Pagination works correctly
+- [ ] Sorting works on any flatjson field
+- [ ] Performance logged
+- [ ] Integration test passes
+
+---
+
+## Task 2.8: Tab Aggregation on JSONB
+**Duration: 2 hours | Files: flatjson-filter.service.ts**
+
+### Objective
+Implement tab count aggregation directly on JSONB data.
+
+### Requirements
+
+**Implement `getJsonbTabCounts()` method:**
+```typescript
+private async getJsonbTabCounts(
+  entity_type: string,
+  flatJsonKey: string,
+  whereClauses: JsonbCondition[]
+): Promise<Array<{ tab_value: string; tab_value_count: number }>> {
+  // Build base query
+  let qb = this.entityManager
+    .getRepository(EntityJson)
+    .createQueryBuilder('ej')
+    .select(`json_data->>'${flatJsonKey}'`, 'tab_value')
+    .addSelect('COUNT(*)', 'tab_value_count')
+    .where('ej.entity_type = :entityType', { entityType: entity_type })
+    .groupBy(`json_data->>'${flatJsonKey}'`);
+  
+  // Apply all where clauses
+  whereClauses.forEach(clause => {
+    qb.andWhere(clause.query, clause.params);
+  });
+  
+  // Execute query
+  const rows = await qb.getRawMany();
+  
+  // Calculate total
+  const total = rows.reduce((sum, r) => sum + parseInt(r.tab_value_count, 10), 0);
+  
+  // Return with "All" tab
+  return [
+    { tab_value: 'All', tab_value_count: total },
+    ...rows.map(r => ({
+      tab_value: r.tab_value ?? 'BLANK',
+      tab_value_count: parseInt(r.tab_value_count, 10)
+    }))
+  ];
+}
+```
+
+### Testing Requirements
+```typescript
+describe('FlatjsonFilterService - Tab Aggregation', () => {
+  it('should aggregate counts by tab attribute', async () => {
+    const tabs = await service['getJsonbTabCounts'](
+      'LEAD',
+      'LEAD__status',
+      []
+    );
+    
+    expect(tabs).toContainEqual(
+      expect.objectContaining({ tab_value: 'All' })
+    );
+    expect(tabs.length).toBeGreaterThan(1);
+  });
+  
+  it('should apply filters before aggregation', async () => {
+    const whereClauses = [{
+      query: "json_data->>'LEAD__city' = :city",
+      params: { city: 'mumbai' }
+    }];
+    
+    const tabs = await service['getJsonbTabCounts'](
+      'LEAD',
+      'LEAD__status',
+      whereClauses
+    );
+    
+    // Should only count entities in Mumbai
+    expect(tabs.find(t => t.tab_value === 'All').tab_value_count).toBeLessThanOrEqual(/* total entities */);
+  });
+});
+```
+
+### Acceptance Criteria
+- [ ] Aggregates counts by tab attribute
+- [ ] Includes "All" tab with total count
+- [ ] Handles NULL values as "BLANK"
+- [ ] Applies base filters before grouping
+- [ ] Performance acceptable (<500ms for 100k records)
+- [ ] Unit tests pass
+
+---
+
+## Task 2.9: Sorting on JSONB Fields
+**Duration: 1 hour | Files: flatjson-filter.service.ts**
+
+### Objective
+Implement sorting on flatjson fields with proper type casting.
+
+### Requirements
+
+**Implement `applyJsonbSorting()` method:**
+```typescript
+private applyJsonbSorting(
+  qb: SelectQueryBuilder<EntityJson>,
+  sortby: SortConfig[],
+  attributeMetaMap: Record<string, any>
+): void {
+  sortby.forEach(({ sortColum, sortType }) => {
+    if (!sortColum) return;
+    
+    const meta = attributeMetaMap[sortColum];
+    if (!meta) {
+      console.warn(`No metadata found for sort column: ${sortColum}`);
+      return;
+    }
+    
+    const flatKey = meta.flat_json_key || `${meta.mapped_entity_type}__${sortColum}`;
+    const direction = sortType?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC';
+    
+    // Apply type casting based on data_type
+    let sortExpression: string;
+    
+    switch (meta.data_type) {
+      case 'text':
+        sortExpression = `json_data->>'${flatKey}'`;
+        break;
+      
+      case 'number':
+      case 'year':
+        sortExpression = `(json_data->>'${flatKey}')::numeric`;
+        break;
+      
+      case 'date':
+        sortExpression = `(json_data->>'${flatKey}')::bigint`;
+        break;
+      
+      default:
+        sortExpression = `json_data->>'${flatKey}'`;
+    }
+    
+    qb.addOrderBy(sortExpression, direction);
+  });
+}
+```
+
+### Testing Requirements
+```typescript
+describe('FlatjsonFilterService - Sorting', () => {
+  it('should sort text fields alphabetically', async () => {
+    const qb = /* mock query builder */;
+    service['applyJsonbSorting'](qb, [{ sortColum: 'name', sortType: 'ASC' }], attributeMetaMap);
+    
+    expect(qb.addOrderBy).toHaveBeenCalledWith(
+      expect.stringContaining("json_data->>'LEAD__name'"),
+      'ASC'
+    );
+  });
+  
+  it('should cast number fields for sorting', async () => {
+    const qb = /* mock query builder */;
+    service['applyJsonbSorting'](qb, [{ sortColum: 'age', sortType: 'DESC' }], attributeMetaMap);
+    
+    expect(qb.addOrderBy).toHaveBeenCalledWith(
+      expect.stringContaining('::numeric'),
+      'DESC'
+    );
+  });
+  
+  it('should cast date fields as bigint for sorting', async () => {
+    const qb = /* mock query builder */;
+    service['applyJsonbSorting'](qb, [{ sortColum: 'created_at', sortType: 'DESC' }], attributeMetaMap);
+    
+    expect(qb.addOrderBy).toHaveBeenCalledWith(
+      expect.stringContaining('::bigint'),
+      'DESC'
+    );
+  });
+});
+```
+
+### Acceptance Criteria
+- [ ] Handles multiple sort columns
+- [ ] Proper type casting based on data_type
+- [ ] ASC/DESC support
+- [ ] Works with GIN index
+- [ ] Unit tests pass
+
+---
+
+## Task 2.10: Sub-Entity Filter Handling
+**Duration: 2 hours | Files: flatjson-filter.service.ts**
+
+### Objective
+Handle filters on sub-entities (1:M relationships not in flatjson).
+
+### Strategy
+Since LinkedAttributes already map custom 1:M data into flatjson, most sub-entity filtering should work directly. However, for truly dynamic 1:M queries not covered by LinkedAttributes, implement a hybrid approach.
+
+### Requirements
+
+**Add method: `applyFlatjsonFilterWrapper()`**
+```typescript
+/**
+ * Wrapper that handles sub-entity filters before querying flatjson
+ * Similar to FilterService.applyFilterWrapper()
+ */
+async applyFlatjsonFilterWrapper(dto: FilterRequestDto): Promise<any> {
+  const { entity_type, quickFilter = [], savedFilterCode, attributeFilter = [] } = dto;
+  
+  // Step 1: Get saved filters
+  const savedFilters = savedFilterCode
+    ? await this.getSavedFilters(savedFilterCode)
+    : [];
+  
+  const allFilters = [...quickFilter, ...attributeFilter, ...savedFilters];
+  
+  // Step 2: Group filters by entity_type
+  const grouped = allFilters.reduce((acc, f) => {
+    const filterEntityType = f.filter_entity_type || entity_type;
+    if (!acc[filterEntityType]) acc[filterEntityType] = [];
+    acc[filterEntityType].push(f);
+    return acc;
+  }, {} as Record<string, FilterCondition[]>);
+  
+  // Step 3: Check if there are sub-entity filters
+  const subEntityTypes = Object.keys(grouped).filter(t => t !== entity_type);
+  
+  if (subEntityTypes.length === 0) {
+    // No sub-entity filters, just call main method
+    return await this.applyFlatjsonFilter(dto);
+  }
+  
+  // Step 4: For each sub-entity, check if it's mapped in flatjson
+  let intersectionIds: number[] | null = null;
+  
+  for (const subEntityType of subEntityTypes) {
+    const subFilters = grouped[subEntityType];
+    
+    // Check if this sub-entity data exists in flatjson
+    // (i.e., there are LinkedAttributes for it)
+    const linkedAttrs = await this.dataSource
+      .getRepository(LinkedAttributes)
+      .find({
+        where: {
+          mapped_entity_type: entity_type,
+          applicable_entity_type: subEntityType,
+        }
+      });
+    
+    if (linkedAttrs.length > 0) {
+      // Sub-entity data is in flatjson, can filter directly
+      // Add to main filters
+      grouped[entity_type].push(...subFilters);
+    } else {
+      // Sub-entity data NOT in flatjson, need to query traditional way
+      // This mirrors FilterService.applyFilterWrapper() logic
+      
+      // Query sub-entity table using traditional FilterService
+      const subDto = {
+        ...dto,
+        entity_type: subEntityType,
+        quickFilter: subFilters,
+        savedFilterCode: null,
+        attributeFilter: [],
+      };
+      
+      const subResult = await this.filterService.applyFilter(subDto);
+      const subEntityIds = subResult.data.entity_list.map(row => row.id);
+      
+      if (!subEntityIds.length) {
+        // No matching sub-entities, return empty
+        return {
+          success: true,
+          data: { entity_tabs: [], entity_list: [], pagination: {} }
+        };
+      }
+      
+      // Map sub-entity IDs to main entity IDs using EntityRelationService
+      const relatedIds = await this.entityRelationService.getRelatedEntityIds(
+        entity_type,
+        subEntityType,
+        subEntityIds,
+        dto.loggedInUser.organization_id
+      );
+      
+      // Apply intersection
+      intersectionIds = intersectionIds === null
+        ? relatedIds
+        : intersectionIds.filter(id => relatedIds.includes(id));
+      
+      if (intersectionIds.length === 0) {
+        return {
+          success: true,
+          data: { entity_tabs: [], entity_list: [], pagination: {} }
+        };
+      }
+    }
+  }
+  
+  // Step 5: Call main filter with ID intersection
+  const mainDto = {
+    ...dto,
+    quickFilter: grouped[entity_type] || [],
+    savedFilterCode: null,
+    attributeFilter: [],
+  };
+  
+  if (intersectionIds && intersectionIds.length > 0) {
+    // Add ID filter to main query
+    mainDto.quickFilter.push({
+      filter_entity_type: entity_type,
+      filter_attribute: 'id',
+      filter_operator: 'in',
+      filter_value: intersectionIds,
+    });
+  }
+  
+  return await this.applyFlatjsonFilter(mainDto);
+}
+```
+
+### Dependencies
+Inject these services if not already:
+```typescript
+@Inject() private readonly filterService: FilterService,
+@Inject() private readonly entityRelationService: EntityRelationService,
+```
+
+### Testing Requirements
+- Test with sub-entity filters that ARE in flatjson (via LinkedAttributes)
+- Test with sub-entity filters that are NOT in flatjson
+- Test with mixed filters (main + sub-entity)
+- Verify correct results match FilterService behavior
+
+### Acceptance Criteria
+- [ ] LinkedAttributes data filterable directly in flatjson
+- [ ] Hybrid approach for unmapped sub-entities works
+- [ ] Correct results returned
+- [ ] Performance acceptable
+- [ ] Unit tests pass
+
+---
+
+## Task 2.11: Integration & Routing
+**Duration: 2 hours | Files: filter.controller.ts, entity-master.entity.ts**
+
+### Objective
+Add routing logic to switch between traditional and flatjson filtering.
+
+### Requirements
+
+**Option 1: Feature Flag in Entity Master (Recommended)**
+
+1. **Add migration for feature flag:**
+```typescript
+   // Migration: AddUseFlatjsonFiltering
+   public async up(queryRunner: QueryRunner): Promise<void> {
+     await queryRunner.query(`
+       ALTER TABLE frm_entity_master 
+       ADD COLUMN IF NOT EXISTS use_flatjson_filtering BOOLEAN DEFAULT FALSE;
+     `);
+   }
+   
+   public async down(queryRunner: QueryRunner): Promise<void> {
+     await queryRunner.query(`
+       ALTER TABLE frm_entity_master 
+       DROP COLUMN IF EXISTS use_flatjson_filtering;
+     `);
+   }
+```
+
+2. **Update entity: `src/module/meta/entity/entity-master.entity.ts`**
+```typescript
+   @Column({ type: 'boolean', default: false })
+   use_flatjson_filtering: boolean;
+```
+
+3. **Update controller: `src/module/filter/controller/filter.controller.ts`**
+```typescript
+   import { FlatjsonFilterService } from '../service/flatjson-filter.service';
+   
+   @Controller('filter')
+   export class FilterController {
+     constructor(
+       private readonly filterService: FilterService,
+       private readonly flatjsonFilterService: FlatjsonFilterService,
+       private readonly entityMasterService: EntityMasterService,
+     ) {}
+     
+     @Post('/apply')
+     async applyFilter(@Body() dto: FilterRequestDto, @Req() req: any) {
+       dto.loggedInUser = req.loggedInUser;
+       
+       // Check if entity uses flatjson filtering
+       const entityMeta = await this.entityMasterService.getEntityData(
+         dto.entity_type,
+         dto.loggedInUser
+       );
+       
+       if (entityMeta?.use_flatjson_filtering) {
+         // Use new flatjson filtering
+         return await this.flatjsonFilterService.applyFlatjsonFilterWrapper(dto);
+       }
+       
+       // Use traditional filtering (backward compatible)
+       return await this.filterService.applyFilterWrapper(dto);
+     }
+   }
+```
+
+**Option 2: Separate Endpoint**
+
+Add new endpoint:
+```typescript
+@Post('/apply-flatjson')
+async applyFlatjsonFilter(@Body() dto: FilterRequestDto, @Req() req: any) {
+  dto.loggedInUser = req.loggedInUser;
+  return await this.flatjsonFilterService.applyFlatjsonFilterWrapper(dto);
+}
+```
+
+**Option 3: Query Parameter**
+```typescript
+@Post('/apply')
+async applyFilter(
+  @Body() dto: FilterRequestDto,
+  @Query('use_flatjson') useFlatjson: boolean,
+  @Req() req: any
+) {
+  dto.loggedInUser = req.loggedInUser;
+  
+  if (useFlatjson) {
+    return await this.flatjsonFilterService.applyFlatjsonFilterWrapper(dto);
+  }
+  
+  return await this.filterService.applyFilterWrapper(dto);
+}
+```
+
+### Testing Requirements
+- Test switching between implementations
+- Verify both return same results for same input
+- Test feature flag toggle
+- Verify backward compatibility
+
+### Acceptance Criteria
+- [ ] Routing logic implemented
+- [ ] Feature flag works (or query param)
+- [ ] No breaking changes to existing API
+- [ ] Both services work independently
+- [ ] Easy to switch between implementations
+- [ ] Integration tests pass
+
+---
+
+# PHASE 3: TESTING & OPTIMIZATION
+**Priority: IMPORTANT | Duration: 5 hours**
+
+## Task 3.1: Unit Tests
+**Duration: 2 hours | Files: *.spec.ts**
+
+### Objective
+Ensure all new code has comprehensive unit test coverage.
+
+### Requirements
+
+1. **Test Coverage Target: 80%+**
+
+2. **Files to Test:**
+   - `linked_attributes.service.spec.ts` (Phase 1 tests)
+   - `flatjson-filter.service.spec.ts` (Phase 2 tests)
+
+3. **Test Suites:**
+
+   **For LinkedAttributesService:**
+   - Sequence generation
+   - Attribute key generation
+   - Validation logic
+   - Filter creation
+   - Smart create
+   - Backfill
+
+   **For FlatjsonFilterService:**
+   - Text condition building
+   - Number condition building
+   - Date condition building
+   - Select condition building
+   - Multiselect condition building
+   - Main filter method
+   - Tab aggregation
+   - Sorting
+
+4. **Run tests:**
+```bash
+   npm test -- --coverage
+```
+
+### Acceptance Criteria
+- [ ] All unit tests pass
+- [ ] Code coverage > 80%
+- [ ] No skipped tests
+- [ ] Fast execution (< 30 seconds total)
+
+---
+
+## Task 3.2: Integration Tests
+**Duration: 2 hours | Files: *.integration.spec.ts**
+
+### Objective
+Test end-to-end flows with real database.
+
+### Requirements
+
+1. **Create integration test files:**
+   - `linked_attributes.integration.spec.ts`
+   - `flatjson-filter.integration.spec.ts`
+
+2. **Test Scenarios:**
+
+   **LinkedAttributes Integration:**
+```typescript
+   describe('LinkedAttributes E2E', () => {
+     it('should create linked attribute and update all entities', async () => {
+       // 1. Create test entities (3 LEADs with family members)
+       // 2. Create linked attribute for father_name
+       // 3. Verify flatjson updated for all entities
+       // 4. Query with filter on father_name
+       // 5. Verify results correct
+     });
+   });
+```
+
+   **FlatjsonFilter Integration:**
+```typescript
+   describe('FlatjsonFilter E2E', () => {
+     it('should filter entities using flatjson', async () => {
+       // 1. Create test entities with various attributes
+       // 2. Apply filters using FlatjsonFilterService
+       // 3. Apply same filters using traditional FilterService
+       // 4. Compare results (should be identical)
+     });
+     
+     it('should handle complex multi-condition filters', async () => {
+       // Test with 5+ filter conditions
+     });
+     
+     it('should handle pagination correctly', async () => {
+       // Create 50 test entities
+       // Query with page=2, size=10
+       // Verify correct records returned
+     });
+   });
+```
+
+3. **Setup/Teardown:**
+```typescript
+   beforeAll(async () => {
+     // Setup test database
+     // Create test entities
+   });
+   
+   afterAll(async () => {
+     // Cleanup test data
+   });
+```
+
+### Acceptance Criteria
+- [ ] All integration tests pass
+- [ ] Tests use real database (test schema)
+- [ ] Proper setup/teardown
+- [ ] Tests are idempotent (can run multiple times)
+
+---
+
+## Task 3.3: Performance Testing
+**Duration: 1 hour | Files: performance.spec.ts**
+
+### Objective
+Benchmark flatjson filtering vs. traditional filtering.
+
+### Requirements
+
+1. **Create performance test file:**
+```typescript
+   // src/module/filter/performance.spec.ts
+   
+   describe('Filtering Performance Benchmark', () => {
+     const sizes = [100, 1000, 10000, 100000];
+     
+     for (const size of sizes) {
+       it(`should compare performance with ${size} records`, async () => {
+         // Setup: Create ${size} test entities
+         
+         const dto = {
+           entity_type: 'LEAD',
+           quickFilter: [
+             { filter_attribute: 'city', filter_operator: 'equal', filter_value: 'mumbai' },
+             { filter_attribute: 'age', filter_operator: 'greater_than', filter_value: 18 },
+           ],
+           page: 1,
+           size: 10,
+           loggedInUser: testUser,
+         };
+         
+         // Test traditional filter
+         const start1 = Date.now();
+         const result1 = await filterService.applyFilter(dto);
+         const time1 = Date.now() - start1;
+         
+         // Test flatjson filter
+         const start2 = Date.now();
+         const result2 = await flatjsonFilterService.applyFlatjsonFilter(dto);
+         const time2 = Date.now() - start2;
+         
+         console.log(`\nDataset: ${size} records`);
+         console.log(`Traditional: ${time1}ms`);
+         console.log(`Flatjson: ${time2}ms`);
+         console.log(`Speedup: ${(time1 / time2).toFixed(2)}x`);
+         
+         // Verify GIN index usage
+         const explainQuery = `EXPLAIN ANALYZE ${/* flatjson query */}`;
+         const plan = await entityManager.query(explainQuery);
+         expect(plan).toContain('Bitmap Index Scan');
+       });
+     }
+   });
+
+   2. **Run benchmarks:**
+```bash
+   npm test -- performance.spec.ts
+```
+
+3. **Expected Results:**
+   - 100 records: Similar performance
+   - 1,000 records: 1.5-2x speedup
+   - 10,000 records: 3-5x speedup
+   - 100,000 records: 5-10x speedup
+
+### Acceptance Criteria
+- [ ] Benchmarks complete
+- [ ] Flatjson faster for datasets > 10k
+- [ ] GIN index verified as used
+- [ ] Query times logged
+- [ ] Performance regression tests added
+
+---
+
+# COMPLETION CHECKLIST
+
+## Phase 1: Linked Attribute Automation
+- [ ] Task 1.1: Sequence & Key Generation
+- [ ] Task 1.2: Validation Engine
+- [ ] Task 1.3: Auto SavedFilter Creation
+- [ ] Task 1.4: Smart Create Method
+- [ ] Task 1.5: Backfill Mechanism
+- [ ] Task 1.6: Update CRUD & Controller
+- [ ] Task 1.7: Testing & Edge Cases
+
+## Phase 2: Flatjson Filtering Service
+- [ ] Task 2.1: Database Index Creation
+- [ ] Task 2.2: Service Skeleton & Infrastructure
+- [ ] Task 2.3: Text Query Builders
+- [ ] Task 2.4: Number Query Builders
+- [ ] Task 2.5: Date Query Builders
+- [ ] Task 2.6: Select/Multiselect Query Builders
+- [ ] Task 2.7: Main Filter Method
+- [ ] Task 2.8: Tab Aggregation
+- [ ] Task 2.9: Sorting
+- [ ] Task 2.10: Sub-Entity Handling
+- [ ] Task 2.11: Integration & Routing
+
+## Phase 3: Testing & Optimization
+- [ ] Task 3.1: Unit Tests (80% coverage)
+- [ ] Task 3.2: Integration Tests
+- [ ] Task 3.3: Performance Benchmarks
+
+## Documentation
+- [ ] API documentation updated (Swagger)
+- [ ] README updated with new features
+- [ ] Migration guide created
+- [ ] Performance comparison report
+
+## Deployment
+- [ ] All tests passing
+- [ ] Migrations tested
+- [ ] Staging deployment successful
+- [ ] Production deployment plan ready
+
+---
+
+# EXECUTION INSTRUCTIONS FOR CLAUDE CODE
+
+When you start working on this project:
+
+1. **Read this entire document first** to understand the full scope
+2. **Start with Phase 1, Task 1.1** - don't skip ahead
+3. **After each task:**
+   - Run tests to verify
+   - Commit code with meaningful message
+   - Update this checklist
+   - Wait for confirmation before proceeding
+4. **If you encounter issues:**
+   - Log the issue clearly
+   - Suggest solutions
+   - Wait for guidance
+5. **Always:**
+   - Follow existing code patterns
+   - Add comprehensive comments
+   - Write tests for new code
+   - Log important operations
+
+**Begin with Task 1.1 when ready!**