rez_core 6.1.5 → 6.1.7

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

@@ -1,903 +1,903 @@
-import { Injectable, BadRequestException, Inject, forwardRef } 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';
-import { SavedFilterRepositoryService } from '../repository/saved-filter.repository';
-import { EntityJSONService } from 'src/module/entity_json/service/entity_json.service';
-
-/**
- * JSONB query condition structure
- */
-interface JsonbCondition {
-  query: string;
-  params: Record<string, any>;
-}
-
-@Injectable()
-export class FlatjsonFilterService {
-  constructor(
-    private readonly entityManager: EntityManager,
-    @Inject(forwardRef(() => EntityMasterService))
-    private readonly entityMasterService: EntityMasterService,
-    @Inject(forwardRef(() => AttributeMasterService))
-    private readonly attributeMasterService: AttributeMasterService,
-    @Inject(forwardRef(() => ResolverService))
-    private readonly resolverService: ResolverService,
-    @Inject(forwardRef(() => LoggingService))
-    private readonly loggingService: LoggingService,
-    private readonly configService: ConfigService,
-    @Inject(forwardRef(() => SavedFilterRepositoryService))
-    private readonly savedFilterRepositoryService: SavedFilterRepositoryService,
-    @Inject(forwardRef(() => EntityJSONService))
-    private readonly entityJsonService: EntityJSONService,
-  ) {}
-
-  /**
-   * Main filtering method - queries frm_entity_json table
-   */
-  async applyFlatjsonFilter(dto: FilterRequestDto): Promise<any> {
-    const {
-      entity_type,
-      quickFilter = [],
-      savedFilterCode,
-      attributeFilter = [],
-      sortby = [],
-      tabs,
-      page = 1,
-      size = 20,
-      loggedInUser,
-    } = dto;
-
-    await this.loggingService.log(
-      'info',
-      'FlatjsonFilterService',
-      'applyFlatjsonFilter',
-      `Filtering entity: ${entity_type}`,
-    );
-
-    // Step 1: Load attribute metadata for this entity
-    let attributes =
-      await this.entityJsonService.getAttributeForFlatJSON(
-        entity_type,
-        loggedInUser,
-        'filter_attribute',
-      );
-
-    if (!attributes?.length) {
-      attributes =
-        await this.attributeMasterService.findAttributesByMappedEntityType(
-          entity_type,
-          loggedInUser,
-        );
-    }
-
-    attributes = attributes ?? [];
-
-    const attributeMetaMap: Record<string, any> = {};
-    attributes.forEach((attr) => {
-      attributeMetaMap[attr.attribute_key] = attr;
-    });
-
-    await this.loggingService.log(
-      'debug',
-      'FlatjsonFilterService',
-      'applyFlatjsonFilter',
-      `Loaded ${attributes.length} attributes`,
-    );
-
-    // Step 2: Merge filters (quickFilter + savedFilter + attributeFilter)
-    let allFilters: FilterCondition[] = [...quickFilter, ...attributeFilter];
-
-    if (savedFilterCode) {
-      const savedFilterDetails =
-        await this.savedFilterRepositoryService.getDetailsByCode(
-          savedFilterCode,
-        );
-      allFilters = [...allFilters, ...savedFilterDetails];
-    }
-
-    await this.loggingService.log(
-      'debug',
-      'FlatjsonFilterService',
-      'applyFlatjsonFilter',
-      `Total filters: ${allFilters.length}`,
-    );
-
-    // Step 3: Build JSONB conditions
-    const jsonbConditions = this.buildJsonbConditions(
-      allFilters,
-      attributeMetaMap,
-    );
-
-    // Step 4: Build base query
-    const qb = this.entityManager
-      .getRepository(EntityJson)
-      .createQueryBuilder('ej')
-      .where('ej.entity_type = :entity_type', { entity_type })
-      .andWhere('ej.organization_id = :orgId', {
-        orgId: loggedInUser.organization_id,
-      });
-
-    // Step 5: Apply JSONB conditions
-    jsonbConditions.forEach((condition, index) => {
-      qb.andWhere(condition.query, condition.params);
-    });
-
-    // Step 6: Apply tab filter if provided
-    if (tabs?.columnName && tabs?.value) {
-      const tabMeta = attributeMetaMap[tabs.columnName];
-      if (tabMeta) {
-        const flatJsonKey =
-          tabMeta.attribute_key ||
-          `${entity_type}__${tabs.columnName}`;
-        qb.andWhere(`json_data->>'${flatJsonKey}' = :tabValue`, {
-          tabValue: tabs.value,
-        });
-      }
-    }
-
-    // Step 7: Get tab counts if needed (before pagination)
-    let tabCounts: any[] = [];
-    if (tabs?.columnName && !tabs?.value) {
-      const tabMeta = attributeMetaMap[tabs.columnName];
-      if (tabMeta) {
-        const flatJsonKey =
-          tabMeta.attribute_key ||
-          `${entity_type}__${tabs.columnName}`;
-        tabCounts = await this.getJsonbTabCounts(
-          entity_type,
-          flatJsonKey,
-          jsonbConditions,
-        );
-      }
-    }
-
-    // Step 8: Apply sorting
-    if (sortby && sortby.length > 0) {
-      this.applyJsonbSorting(qb, sortby, attributeMetaMap);
-    } else {
-      // Default sort by created_date DESC
-      qb.orderBy('ej.created_at', 'DESC');
-    }
-
-    // Step 9: Get total count (before pagination)
-    const totalCount = await qb.getCount();
-
-    // Step 10: Apply pagination
-    if (page && size) {
-      const skip = (page - 1) * size;
-      qb.skip(skip).take(size);
-    }
-
-    const results = await qb.getMany();
-
-    await this.loggingService.log(
-      'info',
-      'FlatjsonFilterService',
-      'applyFlatjsonFilter',
-      `Found ${totalCount} total, returning ${results.length} records`,
-    );
-
-    // Map only json_data
-    const jsonDataResults = results.map((r) => r.json_data);
-
-    return {
-      data: jsonDataResults,
-      total: totalCount,
-      page: page || 1,
-      size: size || 20,
-      totalPages: size ? Math.ceil(totalCount / size) : 1,
-      tabCounts: tabCounts.length > 0 ? tabCounts : undefined,
-    };
-
-  }
-
-  /**
-   * Build JSONB where clauses from filter conditions
-   */
-  private buildJsonbConditions(
-    filters: FilterCondition[],
-    attributeMetaMap: Record<string, any>,
-  ): JsonbCondition[] {
-    const conditions: JsonbCondition[] = [];
-
-    for (const filter of filters) {
-      const meta = attributeMetaMap[filter.filter_attribute];
-      const condition = this.buildJsonbCondition(filter, meta);
-
-      if (condition) {
-        conditions.push(condition);
-      } else {
-        console.warn(
-          `Could not build condition for filter: ${filter.filter_attribute}`,
-        );
-      }
-    }
-
-    return conditions;
-  }
-
-  /**
-   * Resolve entity IDs to full entity data
-   */
-  private async resolveEntityData(
-    entityJsonRecords: EntityJson[],
-    entity_type: string,
-    loggedInUser: any,
-  ): Promise<any[]> {
-    if (entityJsonRecords.length === 0) return [];
-
-    const entityIds = entityJsonRecords.map((ej) => ej.entity_id);
-
-    try {
-      // Use resolver service to get full entity data
-      const fullEntities = await this.resolverService.getResolvedData(
-        entity_type,
-        entityIds,
-        loggedInUser,
-      );
-
-      // Return with json_data merged
-      return entityJsonRecords.map((ej) => {
-        const fullEntity = fullEntities.find((e) => e.id === ej.entity_id);
-        return {
-          ...fullEntity,
-          _flatjson: ej.json_data, // Include flatjson for debugging
-        };
-      });
-    } catch (error) {
-      console.error('Error resolving entity data:', error);
-      // Fallback: return just the entity IDs with json_data
-      return entityJsonRecords.map((ej) => ({
-        id: ej.entity_id,
-        entity_type: ej.entity_type,
-        ...ej.json_data,
-      }));
-    }
-  }
-
-  /**
-   * Build a single JSONB condition based on data type
-   */
-  private buildJsonbCondition(
-    filter: FilterCondition,
-    meta: any,
-  ): JsonbCondition | null {
-    if (!meta) return null;
-
-    const flatJsonKey =
-      meta.attribute_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 {
-    // 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;
-    }
-  }
-
-  /**
-   * Build number condition (JSONB ->> with ::numeric cast)
-   */
-  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;
-    }
-  }
-
-  /**
-   * Build date condition (JSONB ->> with ::bigint cast for epoch ms)
-   */
-  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) },
-        };
-
-      // 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;
-    }
-  }
-
-  /**
-   * Build select condition (single value)
-   */
-  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;
-    }
-  }
-
-  /**
-   * Build multiselect condition (JSONB -> with ? operators for arrays)
-   */
-  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}]::text[]`,
-          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}]::text[]`,
-          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}]::text[]`,
-          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}]::text[])`,
-          params: { [paramKey]: arr },
-        };
-
-      case 'equal':
-        // Exact array match (order matters in PostgreSQL)
-        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;
-    }
-  }
-
-  /**
-   * 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 }>> {
-    // Build a query that groups by the tab field
-    const qb = this.entityManager
-      .getRepository(EntityJson)
-      .createQueryBuilder('ej')
-      .select(`json_data->>'${flatJsonKey}'`, 'tab_value')
-      .addSelect('COUNT(*)', 'tab_value_count')
-      .where('ej.entity_type = :entity_type', { entity_type })
-      .groupBy(`json_data->>'${flatJsonKey}'`);
-
-    // Apply the same filter conditions (but not the tab filter itself)
-    whereClauses.forEach((condition) => {
-      qb.andWhere(condition.query, condition.params);
-    });
-
-    const results = await qb.getRawMany();
-
-    // Filter out NULL/undefined tab values and convert count to number
-    return results
-      .filter((r) => r.tab_value != null && r.tab_value !== '')
-      .map((r) => ({
-        tab_value: r.tab_value,
-        tab_value_count: parseInt(r.tab_value_count, 10),
-      }))
-      .sort((a, b) => b.tab_value_count - a.tab_value_count); // Sort by count DESC
-  }
-
-  /**
-   * Apply sorting on JSONB fields
-   */
-  private applyJsonbSorting(
-    qb: SelectQueryBuilder<EntityJson>,
-    sortby: SortConfig[],
-    attributeMetaMap: Record<string, any>,
-  ): void {
-    sortby.forEach((sort, index) => {
-      const meta = attributeMetaMap[sort.sortColum];
-
-      if (!meta) {
-        console.warn(`No metadata found for sort column: ${sort.sortColum}`);
-        return;
-      }
-
-      const flatJsonKey =
-        meta.attribute_key || `${meta.mapped_entity_type}__${sort.sortColum}`;
-      const direction = sort.sortType === 'ASC' ? 'ASC' : 'DESC';
-
-      // Apply type-specific casting for proper sorting
-      let sortExpression: string;
-
-      switch (meta.data_type) {
-        case 'number':
-        case 'year':
-          // Cast to numeric for number sorting
-          sortExpression = `(json_data->>'${flatJsonKey}')::numeric`;
-          break;
-
-        case 'date':
-          // Cast to bigint for date sorting (epoch ms)
-          sortExpression = `(json_data->>'${flatJsonKey}')::bigint`;
-          break;
-
-        case 'text':
-        case 'select':
-        case 'radio':
-        default:
-          // Text sorting (already lowercase)
-          sortExpression = `json_data->>'${flatJsonKey}'`;
-          break;
-      }
-
-      // Add to ORDER BY clause
-      if (index === 0) {
-        qb.orderBy(sortExpression, direction);
-      } else {
-        qb.addOrderBy(sortExpression, direction);
-      }
-    });
-  }
-}
+import { Injectable, BadRequestException, Inject, forwardRef } 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';
+import { SavedFilterRepositoryService } from '../repository/saved-filter.repository';
+import { EntityJSONService } from 'src/module/entity_json/service/entity_json.service';
+
+/**
+ * JSONB query condition structure
+ */
+interface JsonbCondition {
+  query: string;
+  params: Record<string, any>;
+}
+
+@Injectable()
+export class FlatjsonFilterService {
+  constructor(
+    private readonly entityManager: EntityManager,
+    @Inject(forwardRef(() => EntityMasterService))
+    private readonly entityMasterService: EntityMasterService,
+    @Inject(forwardRef(() => AttributeMasterService))
+    private readonly attributeMasterService: AttributeMasterService,
+    @Inject(forwardRef(() => ResolverService))
+    private readonly resolverService: ResolverService,
+    @Inject(forwardRef(() => LoggingService))
+    private readonly loggingService: LoggingService,
+    private readonly configService: ConfigService,
+    @Inject(forwardRef(() => SavedFilterRepositoryService))
+    private readonly savedFilterRepositoryService: SavedFilterRepositoryService,
+    @Inject(forwardRef(() => EntityJSONService))
+    private readonly entityJsonService: EntityJSONService,
+  ) {}
+
+  /**
+   * Main filtering method - queries frm_entity_json table
+   */
+  async applyFlatjsonFilter(dto: FilterRequestDto): Promise<any> {
+    const {
+      entity_type,
+      quickFilter = [],
+      savedFilterCode,
+      attributeFilter = [],
+      sortby = [],
+      tabs,
+      page = 1,
+      size = 20,
+      loggedInUser,
+    } = dto;
+
+    await this.loggingService.log(
+      'info',
+      'FlatjsonFilterService',
+      'applyFlatjsonFilter',
+      `Filtering entity: ${entity_type}`,
+    );
+
+    // Step 1: Load attribute metadata for this entity
+    let attributes =
+      await this.entityJsonService.getAttributeForFlatJSON(
+        entity_type,
+        loggedInUser,
+        'filter_attribute',
+      );
+
+    if (!attributes?.length) {
+      attributes =
+        await this.attributeMasterService.findAttributesByMappedEntityType(
+          entity_type,
+          loggedInUser,
+        );
+    }
+
+    attributes = attributes ?? [];
+
+    const attributeMetaMap: Record<string, any> = {};
+    attributes.forEach((attr) => {
+      attributeMetaMap[attr.attribute_key] = attr;
+    });
+
+    await this.loggingService.log(
+      'debug',
+      'FlatjsonFilterService',
+      'applyFlatjsonFilter',
+      `Loaded ${attributes.length} attributes`,
+    );
+
+    // Step 2: Merge filters (quickFilter + savedFilter + attributeFilter)
+    let allFilters: FilterCondition[] = [...quickFilter, ...attributeFilter];
+
+    if (savedFilterCode) {
+      const savedFilterDetails =
+        await this.savedFilterRepositoryService.getDetailsByCode(
+          savedFilterCode,
+        );
+      allFilters = [...allFilters, ...savedFilterDetails];
+    }
+
+    await this.loggingService.log(
+      'debug',
+      'FlatjsonFilterService',
+      'applyFlatjsonFilter',
+      `Total filters: ${allFilters.length}`,
+    );
+
+    // Step 3: Build JSONB conditions
+    const jsonbConditions = this.buildJsonbConditions(
+      allFilters,
+      attributeMetaMap,
+    );
+
+    // Step 4: Build base query
+    const qb = this.entityManager
+      .getRepository(EntityJson)
+      .createQueryBuilder('ej')
+      .where('ej.entity_type = :entity_type', { entity_type })
+      .andWhere('ej.organization_id = :orgId', {
+        orgId: loggedInUser.organization_id,
+      });
+
+    // Step 5: Apply JSONB conditions
+    jsonbConditions.forEach((condition, index) => {
+      qb.andWhere(condition.query, condition.params);
+    });
+
+    // Step 6: Apply tab filter if provided
+    if (tabs?.columnName && tabs?.value) {
+      const tabMeta = attributeMetaMap[tabs.columnName];
+      if (tabMeta) {
+        const flatJsonKey =
+          tabMeta.attribute_key ||
+          `${entity_type}__${tabs.columnName}`;
+        qb.andWhere(`json_data->>'${flatJsonKey}' = :tabValue`, {
+          tabValue: tabs.value,
+        });
+      }
+    }
+
+    // Step 7: Get tab counts if needed (before pagination)
+    let tabCounts: any[] = [];
+    if (tabs?.columnName && !tabs?.value) {
+      const tabMeta = attributeMetaMap[tabs.columnName];
+      if (tabMeta) {
+        const flatJsonKey =
+          tabMeta.attribute_key ||
+          `${entity_type}__${tabs.columnName}`;
+        tabCounts = await this.getJsonbTabCounts(
+          entity_type,
+          flatJsonKey,
+          jsonbConditions,
+        );
+      }
+    }
+
+    // Step 8: Apply sorting
+    if (sortby && sortby.length > 0) {
+      this.applyJsonbSorting(qb, sortby, attributeMetaMap);
+    } else {
+      // Default sort by created_date DESC
+      qb.orderBy('ej.created_at', 'DESC');
+    }
+
+    // Step 9: Get total count (before pagination)
+    const totalCount = await qb.getCount();
+
+    // Step 10: Apply pagination
+    if (page && size) {
+      const skip = (page - 1) * size;
+      qb.skip(skip).take(size);
+    }
+
+    const results = await qb.getMany();
+
+    await this.loggingService.log(
+      'info',
+      'FlatjsonFilterService',
+      'applyFlatjsonFilter',
+      `Found ${totalCount} total, returning ${results.length} records`,
+    );
+
+    // Map only json_data
+    const jsonDataResults = results.map((r) => r.json_data);
+
+    return {
+      data: jsonDataResults,
+      total: totalCount,
+      page: page || 1,
+      size: size || 20,
+      totalPages: size ? Math.ceil(totalCount / size) : 1,
+      tabCounts: tabCounts.length > 0 ? tabCounts : undefined,
+    };
+
+  }
+
+  /**
+   * Build JSONB where clauses from filter conditions
+   */
+  private buildJsonbConditions(
+    filters: FilterCondition[],
+    attributeMetaMap: Record<string, any>,
+  ): JsonbCondition[] {
+    const conditions: JsonbCondition[] = [];
+
+    for (const filter of filters) {
+      const meta = attributeMetaMap[filter.filter_attribute];
+      const condition = this.buildJsonbCondition(filter, meta);
+
+      if (condition) {
+        conditions.push(condition);
+      } else {
+        console.warn(
+          `Could not build condition for filter: ${filter.filter_attribute}`,
+        );
+      }
+    }
+
+    return conditions;
+  }
+
+  /**
+   * Resolve entity IDs to full entity data
+   */
+  private async resolveEntityData(
+    entityJsonRecords: EntityJson[],
+    entity_type: string,
+    loggedInUser: any,
+  ): Promise<any[]> {
+    if (entityJsonRecords.length === 0) return [];
+
+    const entityIds = entityJsonRecords.map((ej) => ej.entity_id);
+
+    try {
+      // Use resolver service to get full entity data
+      const fullEntities = await this.resolverService.getResolvedData(
+        entity_type,
+        entityIds,
+        loggedInUser,
+      );
+
+      // Return with json_data merged
+      return entityJsonRecords.map((ej) => {
+        const fullEntity = fullEntities.find((e) => e.id === ej.entity_id);
+        return {
+          ...fullEntity,
+          _flatjson: ej.json_data, // Include flatjson for debugging
+        };
+      });
+    } catch (error) {
+      console.error('Error resolving entity data:', error);
+      // Fallback: return just the entity IDs with json_data
+      return entityJsonRecords.map((ej) => ({
+        id: ej.entity_id,
+        entity_type: ej.entity_type,
+        ...ej.json_data,
+      }));
+    }
+  }
+
+  /**
+   * Build a single JSONB condition based on data type
+   */
+  private buildJsonbCondition(
+    filter: FilterCondition,
+    meta: any,
+  ): JsonbCondition | null {
+    if (!meta) return null;
+
+    const flatJsonKey =
+      meta.attribute_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 {
+    // 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;
+    }
+  }
+
+  /**
+   * Build number condition (JSONB ->> with ::numeric cast)
+   */
+  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;
+    }
+  }
+
+  /**
+   * Build date condition (JSONB ->> with ::bigint cast for epoch ms)
+   */
+  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) },
+        };
+
+      // 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;
+    }
+  }
+
+  /**
+   * Build select condition (single value)
+   */
+  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;
+    }
+  }
+
+  /**
+   * Build multiselect condition (JSONB -> with ? operators for arrays)
+   */
+  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}]::text[]`,
+          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}]::text[]`,
+          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}]::text[]`,
+          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}]::text[])`,
+          params: { [paramKey]: arr },
+        };
+
+      case 'equal':
+        // Exact array match (order matters in PostgreSQL)
+        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;
+    }
+  }
+
+  /**
+   * 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 }>> {
+    // Build a query that groups by the tab field
+    const qb = this.entityManager
+      .getRepository(EntityJson)
+      .createQueryBuilder('ej')
+      .select(`json_data->>'${flatJsonKey}'`, 'tab_value')
+      .addSelect('COUNT(*)', 'tab_value_count')
+      .where('ej.entity_type = :entity_type', { entity_type })
+      .groupBy(`json_data->>'${flatJsonKey}'`);
+
+    // Apply the same filter conditions (but not the tab filter itself)
+    whereClauses.forEach((condition) => {
+      qb.andWhere(condition.query, condition.params);
+    });
+
+    const results = await qb.getRawMany();
+
+    // Filter out NULL/undefined tab values and convert count to number
+    return results
+      .filter((r) => r.tab_value != null && r.tab_value !== '')
+      .map((r) => ({
+        tab_value: r.tab_value,
+        tab_value_count: parseInt(r.tab_value_count, 10),
+      }))
+      .sort((a, b) => b.tab_value_count - a.tab_value_count); // Sort by count DESC
+  }
+
+  /**
+   * Apply sorting on JSONB fields
+   */
+  private applyJsonbSorting(
+    qb: SelectQueryBuilder<EntityJson>,
+    sortby: SortConfig[],
+    attributeMetaMap: Record<string, any>,
+  ): void {
+    sortby.forEach((sort, index) => {
+      const meta = attributeMetaMap[sort.sortColum];
+
+      if (!meta) {
+        console.warn(`No metadata found for sort column: ${sort.sortColum}`);
+        return;
+      }
+
+      const flatJsonKey =
+        meta.attribute_key || `${meta.mapped_entity_type}__${sort.sortColum}`;
+      const direction = sort.sortType === 'ASC' ? 'ASC' : 'DESC';
+
+      // Apply type-specific casting for proper sorting
+      let sortExpression: string;
+
+      switch (meta.data_type) {
+        case 'number':
+        case 'year':
+          // Cast to numeric for number sorting
+          sortExpression = `(json_data->>'${flatJsonKey}')::numeric`;
+          break;
+
+        case 'date':
+          // Cast to bigint for date sorting (epoch ms)
+          sortExpression = `(json_data->>'${flatJsonKey}')::bigint`;
+          break;
+
+        case 'text':
+        case 'select':
+        case 'radio':
+        default:
+          // Text sorting (already lowercase)
+          sortExpression = `json_data->>'${flatJsonKey}'`;
+          break;
+      }
+
+      // Add to ORDER BY clause
+      if (index === 0) {
+        qb.orderBy(sortExpression, direction);
+      } else {
+        qb.addOrderBy(sortExpression, direction);
+      }
+    });
+  }
+}