rez_core 7.1.21 → 7.1.23

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

@@ -0,0 +1,1062 @@
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { EntityManager } from 'typeorm';
+import { AttributeMasterService } from 'src/module/entity/meta/service/attribute-master.service';
+import { EntityMasterService } from 'src/module/entity/meta/service/entity-master.service';
+import { EntityRelationService } from 'src/module/entity/meta/service/entity-relation.service';
+import { FilterCondition } from '../dto/filter-request.dto';
+import { SavedFilterService } from './saved-filter.service';
+import { ReflectionHelper } from 'src/utils/service/reflection-helper.service';
+
+// Import types
+import {
+  AttributeMetadata,
+  EavJoinInfo,
+  FilterClauses,
+  FilterDataResult,
+  PaginationParams,
+  WhereClause,
+} from './helpers/filter2.types';
+
+// Import EAV helpers
+import { isEavAttribute, processEavFilter } from './helpers/eav.helper';
+
+// Import FlatJson helpers
+import { processFlatJsonFilter } from './helpers/flatjson.helper';
+
+// Import DB_COL helpers
+import { processDbColFilter } from './helpers/db-col.helper';
+
+// Import Query Builder helpers
+import {
+  addEavJoins,
+  applyPagination,
+  applySorting,
+  applyWhereClauses,
+  buildPaginationResult,
+  getTotalCount,
+  getTotalCountFlatJson,
+} from './helpers/query-builder.helper';
+
+// Import Sub-Entity Filter helpers
+import {
+  buildSubEntityFilterSummary,
+  filterSubEntitiesInParallel,
+  groupFiltersByEntityType,
+  hasEmptySubEntityResults,
+  toBatchRelationRequests,
+} from './helpers/sub-entity-filter.helper';
+import { ListMasterService } from '../../../listmaster/service/list-master.service';
+
+/**
+ * Filter2.0 Service - Clean, Modular Filter Implementation
+ *
+ * This service provides a cleaner, more maintainable implementation of the filter service
+ * with better separation of concerns and smaller, focused functions.
+ *
+ * The logic is now broken down into separate helper modules:
+ * - filter2.types.ts: Type definitions and interfaces
+ * - eav.helper.ts: EAV (Entity-Attribute-Value) filtering logic
+ * - flatjson.helper.ts: FlatJson filtering logic
+ * - db-col.helper.ts: Database column filtering logic
+ * - query-builder.helper.ts: Query builder operations
+ */
+
+@Injectable()
+export class EntityFilterService {
+  private readonly schema: string;
+
+  constructor(
+    private readonly entityManager: EntityManager,
+    @Inject('AttributeMasterService')
+    private readonly attributeMasterService: AttributeMasterService,
+    @Inject('EntityMasterService')
+    private readonly entityMasterService: EntityMasterService,
+    @Inject('SavedFilterService')
+    private readonly savedFilterService: SavedFilterService,
+    @Inject('EntityRelationService')
+    private readonly entityRelationService: EntityRelationService,
+    private readonly configService: ConfigService,
+    private readonly reflectionHelper: ReflectionHelper,
+    @Inject('ListMasterService')
+    private readonly listMasterService: ListMasterService,
+  ) {
+    this.schema = this.configService.get('DB_SCHEMA') || 'public';
+  }
+
+  // ==========================================
+  // FILTER CLAUSE BUILDERS
+  // ==========================================
+
+  /**
+   * Build where clauses from filter conditions
+   * Separates DB_COL, EAV, and FlatJson filters
+   */
+  private buildFilterClauses(
+    filters: FilterCondition[],
+    attributeMetaMap: Record<string, AttributeMetadata>,
+    flatJson?: boolean,
+    jsonColumn?: string,
+  ): FilterClauses {
+    const dbColClauses: WhereClause[] = [];
+    const eavJoins: EavJoinInfo[] = [];
+    const eavClauses: WhereClause[] = [];
+
+    filters.forEach((filter, index) => {
+      const meta = attributeMetaMap[filter.filter_attribute];
+      if (!meta) return;
+
+      if (flatJson && jsonColumn) {
+        // Handle FlatJson attribute
+        processFlatJsonFilter(filter, meta, jsonColumn, dbColClauses);
+      } else if (isEavAttribute(meta)) {
+        // Handle EAV attribute
+        processEavFilter(filter, meta, index, eavJoins, eavClauses);
+      } else {
+        // Handle DB_COL attribute
+        processDbColFilter(filter, meta, dbColClauses);
+      }
+
+      // Normalize params
+      this.normalizeParams(dbColClauses[dbColClauses.length - 1]);
+      if (eavClauses.length > 0) {
+        this.normalizeParams(eavClauses[eavClauses.length - 1]);
+      }
+    });
+
+    return { dbColClauses, eavJoins, eavClauses };
+  }
+
+  /**
+   * Normalize parameters to string (except arrays)
+   */
+  private normalizeParams(clause: WhereClause): void {
+    if (!clause || !clause.params) return;
+
+    Object.keys(clause.params).forEach((key) => {
+      const val = clause.params[key];
+      if (!Array.isArray(val)) {
+        clause.params[key] = String(val);
+      }
+    });
+  }
+
+  // ==========================================
+  // SAVED FILTER HELPERS
+  // ==========================================
+
+  /**
+   * Get saved filters by code
+   */
+  private async getSavedFilters(filterCode?: string): Promise<any[]> {
+    if (!filterCode) return [];
+
+    const savedFilter = await this.savedFilterService.getDetailsByCode(filterCode);
+    if (!savedFilter) {
+      throw new BadRequestException(`Saved filter not found: ${filterCode}`);
+    }
+
+    return savedFilter;
+  }
+
+  /**
+   * Normalize saved filters to FilterCondition format
+   */
+  private normalizeSavedFilters(
+    savedFilters: any[],
+    entityType: string,
+  ): FilterCondition[] {
+    return savedFilters.map((f) => ({
+      filter_attribute: f.filter_attribute,
+      filter_operator: f.filter_operator,
+      filter_value: f.filter_value,
+      filter_entity_type: entityType,
+    }));
+  }
+
+  /**
+   * Merge and filter out empty values
+   */
+  private mergeFilters(...filterArrays: FilterCondition[][]): FilterCondition[] {
+    return filterArrays
+      .flat()
+      .filter((f) => f.filter_value !== '' && f.filter_value != null);
+  }
+
+  // ==========================================
+  // ATTRIBUTE METADATA HELPERS
+  // ==========================================
+
+  /**
+   * Get attribute metadata map
+   */
+  private async getAttributeMetaMap(
+    entityType: string,
+    userData: any,
+  ): Promise<Record<string, AttributeMetadata>> {
+    const attributes = await this.attributeMasterService.findAttributesByMappedEntityType(
+      entityType,
+      userData,
+    );
+
+    return attributes.reduce((acc, attr) => {
+      acc[attr.attribute_key] = attr;
+      return acc;
+    }, {} as Record<string, AttributeMetadata>);
+  }
+
+  // ==========================================
+  // MAIN PUBLIC METHODS
+  // ==========================================
+
+  /**
+   * Core filter data retrieval method
+   *
+   * @param entityType - Entity type to query
+   * @param filterConditions - Array of filter conditions
+   * @param sortColumns - Array of sort columns with order
+   * @param columns - Array of attribute keys to select (if empty, returns all)
+   * @param ids - Optional array of IDs to filter by
+   * @param pagination - Pagination parameters (page, size)
+   * @param userData - Logged in user data
+   * @param flatJson - Whether to use flatjson storage (entity_json table)
+   * @param jsonColumn - JSON column name (default: 'entity_json')
+   * @returns Object with entity_list and pagination info
+   */
+  async GetFilterData(
+    entityType: string,
+    filterConditions: FilterCondition[] = [],
+    sortColumns: { column: string; order: 'ASC' | 'DESC' }[] = [],
+    columns: string[] = [],
+    ids: number[] = [],
+    pagination?: PaginationParams,
+    userData?: any,
+    flatJson: boolean = false,
+    jsonColumn: string = 'entity_json',
+    disableDefaultFilter: boolean = false,
+  ): Promise<FilterDataResult> {
+    console.log('🔹 [Filter2.GetFilterData] Starting with params:', {
+      entityType,
+      filterCount: filterConditions.length,
+      sortColumns,
+      columns,
+      ids,
+      pagination,
+      flatJson,
+      jsonColumn,
+    });
+
+    // Get entity metadata
+    const entityMeta = await this.entityMasterService.getEntityData(entityType, userData);
+    let tableName = entityMeta?.data_source;
+
+    // Override table name for flatjson
+    if (flatJson) {
+      tableName = 'frm_entity_json';
+    }
+
+    if (!tableName) {
+      throw new BadRequestException(`Invalid entity_type: ${entityType}`);
+    }
+
+    // Get attribute metadata
+    const attributeMetaMap = await this.getAttributeMetaMap(entityType, userData);
+
+    // Build filter clauses
+    const { dbColClauses, eavJoins, eavClauses } = this.buildFilterClauses(
+      filterConditions,
+      attributeMetaMap,
+      flatJson,
+      jsonColumn,
+    );
+
+    // Add entity_type filter for flatjson
+    if (flatJson) {
+      dbColClauses.push({
+        query: 'e.entity_type = :entity_type',
+        params: { entity_type: entityType },
+      });
+    }
+
+    // Add default filters for enterprise_id, level_type, and level_id (unless disabled)
+    if (!disableDefaultFilter && userData) {
+      const { enterprise_id, level_type, level_id } = userData;
+      
+      dbColClauses.push({
+        query: [
+          enterprise_id ? 'e.enterprise_id = :enterprise_id' : null,
+          level_type ? 'e.level_type = :level_type' : null,
+          level_id ? 'e.level_id = :level_id' : null,
+        ].filter(Boolean).join(' AND '),
+        params: {
+          ...(enterprise_id && { enterprise_id: enterprise_id}),
+          ...(level_type && { level_type:level_type }),
+          ...(level_id && { level_id: level_id }),
+        },
+      });
+    }
+
+    // Add IDs filter if provided
+    if (ids && ids.length > 0) {
+      const idsStr = ids.map((id) => String(id));
+      if (flatJson) {
+        dbColClauses.push({
+          query: 'e.entity_id::text = ANY(:ids)',
+          params: { ids: `{${idsStr.join(',')}}` },
+        });
+      } else {
+        dbColClauses.push({
+          query: 'e.id::text = ANY(:ids)',
+          params: { ids: `{${idsStr.join(',')}}` },
+        });
+      }
+    }
+
+    // Build SELECT clause
+    let selectClause = 'e.*';
+    if (flatJson) {
+      // For flatjson, select entity_id and the JSON column
+      if (columns && columns.length > 0) {
+        const jsonSelects = columns
+          .filter((col) => attributeMetaMap[col])
+          .map((col) => `e.${jsonColumn}->>'${col}' AS ${col}`)
+          .join(', ');
+        selectClause = `e.entity_id AS id, ${jsonSelects}`;
+      } else {
+        selectClause = `e.entity_id AS id, e.${jsonColumn}`;
+      }
+    } else {
+      // Regular table selection
+      if (columns && columns.length > 0) {
+        const mandatoryColumns = ['id', 'name', 'code', 'status'];
+        const allRequestedColumns = new Set([...mandatoryColumns, ...(columns || [])]);
+        const validColumns = Array.from(allRequestedColumns)
+          .filter((col) => attributeMetaMap[col])
+          .map((col) => `e.${col}`)
+          .join(', ');
+        selectClause = validColumns || 'e.id, e.name';
+      }
+    }
+
+    // Build query
+    const qb = this.entityManager
+      .createQueryBuilder()
+      .select(selectClause)
+      .from(`${this.schema}.${tableName}`, 'e');
+
+    // Add EAV joins (only for non-flatjson)
+    if (!flatJson) {
+      addEavJoins(qb, eavJoins, this.schema);
+    }
+
+    // Apply WHERE clauses
+    applyWhereClauses(qb, dbColClauses);
+    if (!flatJson) {
+      applyWhereClauses(qb, eavClauses);
+    }
+
+    // Apply sorting
+    if (flatJson && sortColumns && sortColumns.length > 0) {
+      // Custom sorting for flatjson
+      sortColumns.forEach(({ column, order }) => {
+        if (attributeMetaMap[column]) {
+          qb.addOrderBy(`e.${jsonColumn}->>'${column}'`, order);
+        }
+      });
+    } else {
+      applySorting(qb, sortColumns, attributeMetaMap);
+    }
+
+    // Apply pagination
+    const { page, size } = applyPagination(qb, pagination);
+
+    // Execute query
+    const entity_list = await qb.getRawMany();
+
+    console.log(`🔹 [Filter2.GetFilterData] Fetched ${entity_list.length} records`);
+
+    // Build result
+    const result: FilterDataResult = { entity_list };
+
+    if (pagination) {
+      const total = flatJson
+        ? await getTotalCountFlatJson(
+          this.entityManager,
+          this.schema,
+          tableName,
+          entityType,
+          dbColClauses,
+        )
+        : await getTotalCount(
+          this.entityManager,
+          this.schema,
+          tableName,
+          dbColClauses,
+          eavJoins,
+          eavClauses,
+        );
+      result.pagination = buildPaginationResult(total, page, size);
+    }
+
+    return result;
+  }
+
+  /**
+   * Internal filter data retrieval with filter code resolution
+   *
+   * @param entityType - Entity type to query
+   * @param filterCode - Saved filter code to resolve
+   * @param quickFilter - Quick filter conditions
+   * @param columns - Array of attribute keys to select
+   * @param ids - Optional array of IDs to filter by
+   * @param userData - Logged in user data
+   * @param flatJson - Whether to use flatjson storage
+   * @param jsonColumn - JSON column name
+   * @returns Object with entity_list
+   */
+  async getFilterDataInternal(
+    entityType: string,
+    filterCode?: string,
+    quickFilter: FilterCondition[] = [],
+    columns: string[] = [],
+    ids: number[] = [],
+    userData?: any,
+    flatJson: boolean = false,
+    jsonColumn: string = 'entity_json',
+    disableDefaultFilter: boolean = false,
+  ): Promise<FilterDataResult> {
+    console.log('🔸 [Filter2.GetFilterDataInternal] Starting with params:', {
+      entityType,
+      filterCode,
+      quickFilterCount: quickFilter.length,
+      columns,
+      ids,
+      flatJson,
+      jsonColumn,
+    });
+
+    // Get saved filters
+    const savedFilters = await this.getSavedFilters(filterCode);
+    const savedFiltersNormalized = this.normalizeSavedFilters(savedFilters, entityType);
+
+    // Merge all filters
+    const allFilters = this.mergeFilters(quickFilter, savedFiltersNormalized);
+
+    // Call GetFilterData without pagination
+    return await this.GetFilterData(
+      entityType,
+      allFilters,
+      [],
+      columns,
+      ids,
+      undefined,
+      userData,
+      flatJson,
+      jsonColumn,
+      disableDefaultFilter,
+    );
+  }
+
+  /**
+   * Filter data retrieval for listing with layout preferences
+   *
+   * @param entityType - Entity type to query
+   * @param quickFilter - Quick filter conditions
+   * @param filterCode - Saved filter code to resolve
+   * @param attributeFilter - Attribute filter conditions
+   * @param sortColumn - Sort column with order (will be overridden by layout preference)
+   * @param pagination - Pagination parameters
+   * @param userData - Logged in user data
+   * @param flatJson - Whether to use flatjson storage
+   * @param jsonColumn - JSON column name
+   * @returns Object with entity_list and pagination info
+   */
+  async getFilterDataForListing(
+    entityType: string,
+    quickFilter: FilterCondition[] = [],
+    filterCode?: string,
+    attributeFilter: FilterCondition[] = [],
+    sortColumn?: { column: string; order: 'ASC' | 'DESC' },
+    pagination?: PaginationParams,
+    userData?: any,
+    flatJson: boolean = false,
+    jsonColumn: string = 'entity_json',
+    disableDefaultFilter: boolean = false,
+  ): Promise<FilterDataResult> {
+    console.log('🔷 [Filter2.GetFilterDataForListing] Starting with params:', {
+      entityType,
+      quickFilterCount: quickFilter.length,
+      filterCode,
+      attributeFilterCount: attributeFilter.length,
+      sortColumn,
+      pagination,
+      flatJson,
+      jsonColumn,
+    });
+
+    const { level_type, level_id, id: user_id } = userData || {};
+
+    // Get saved filters
+    const savedFilters = await this.getSavedFilters(filterCode);
+    const savedFiltersNormalized = this.normalizeSavedFilters(savedFilters, entityType);
+
+    // Merge all filters
+    const allFilters = this.mergeFilters(quickFilter, attributeFilter, savedFiltersNormalized);
+
+    // Get layout preference
+    const layoutPreferenceRepo = this.reflectionHelper.getRepoService('LayoutPreference');
+    const layoutPreference = await layoutPreferenceRepo.findOne({
+      where: {
+        user_id: user_id,
+        mapped_entity_type: entityType,
+        mapped_level_id: level_id,
+        mapped_level_type: level_type,
+        type: 'layout',
+      },
+    });
+
+    // Get columns from layout preference
+    let columns: string[] = [];
+    if (layoutPreference?.mapped_json?.columns) {
+      columns = layoutPreference.mapped_json.columns.map(
+        (col: any) => col.attribute_key || col,
+      );
+    } else {
+      columns = ['id', 'name', 'code', 'status', 'description'];
+    }
+
+    // Get sort columns from layout preference
+    let sortColumns: { column: string; order: 'ASC' | 'DESC' }[] = [];
+    if (layoutPreference?.mapped_json?.sorting?.sortby) {
+      sortColumns = layoutPreference.mapped_json.sorting.sortby.map((sort: any) => ({
+        column: sort.column,
+        order: sort.order?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC',
+      }));
+    } else if (sortColumn) {
+      sortColumns = [sortColumn];
+    }
+
+    console.log('🔷 [Filter2.GetFilterDataForListing] Using layout columns:', columns);
+    console.log('🔷 [Filter2.GetFilterDataForListing] Using sort columns:', sortColumns);
+
+    if (flatJson) {
+      // Call GetFilterData
+      return await this.GetFilterData(
+        entityType,
+        allFilters,
+        sortColumns,
+        columns,
+        [],
+        pagination,
+        userData,
+        flatJson,
+        jsonColumn,
+        disableDefaultFilter,
+      );
+    } else {
+      const groupedFilters = groupFiltersByEntityType(allFilters);
+      const subEntityFilters = Object.keys(groupedFilters)
+        .filter((type) => type !== entityType)
+        .reduce((acc, type) => {
+          acc[type] = groupedFilters[type];
+          return acc;
+        }, {} as Record<string, FilterCondition[]>);
+
+      const hasSubEntityFilters = Object.keys(subEntityFilters).length > 0;
+      if (hasSubEntityFilters) {
+        return await this.getFilterDataWithRelations(
+          entityType,
+          allFilters,
+          sortColumns,
+          columns,
+          pagination,
+          userData,
+          disableDefaultFilter,
+        );
+      } else {
+        return await this.GetFilterData(
+          entityType,
+          allFilters,
+          sortColumns,
+          columns,
+          [],
+          pagination,
+          userData,
+          false,
+          'entity_json',
+          disableDefaultFilter,
+        );
+      }
+    }
+  }
+
+  /**
+   * Get tabs with counts based on layout preferences
+   *
+   * @param entityType - Entity type to query
+   * @param quickFilter - Quick filter conditions
+   * @param filterCode - Saved filter code to resolve
+   * @param attributeFilter - Attribute filter conditions
+   * @param ids - Optional array of IDs to filter by
+   * @param userData - Logged in user data
+   * @param flatJson - Whether to use flatjson storage
+   * @param jsonColumn - JSON column name
+   * @param defaultTabsConfig - Default tabs configuration from UI (fallback if layout preference not found)
+   * @returns Array of tabs with name and count
+   */
+  async getTabsData(
+    entityType: string,
+    quickFilter: FilterCondition[] = [],
+    filterCode?: string,
+    attributeFilter: FilterCondition[] = [],
+    ids: number[] = [],
+    userData?: any,
+    flatJson: boolean = false,
+    jsonColumn: string = 'entity_json',
+    defaultTabsConfig?: {
+      attribute_key: string;
+      show_list?: string[];
+      sort_by?: 'alphabetically' | 'count_low_to_high' | 'count_high_to_low';
+      show_all?: boolean;
+      combined_other?: boolean;
+    },
+  ): Promise<{ tab_name: string; count: number }[]> {
+    console.log('🔵 [Filter2.GetTabsData] Starting with params:', {
+      entityType,
+      quickFilterCount: quickFilter.length,
+      filterCode,
+      attributeFilterCount: attributeFilter.length,
+      ids,
+      flatJson,
+      jsonColumn,
+      defaultTabsConfig,
+    });
+
+    const { level_type, level_id, id: user_id } = userData || {};
+
+    // Get saved filters
+    const savedFilters = await this.getSavedFilters(filterCode);
+    const savedFiltersNormalized = this.normalizeSavedFilters(savedFilters, entityType);
+
+    // Merge all filters
+    const allFilters = this.mergeFilters(quickFilter, attributeFilter, savedFiltersNormalized);
+
+    // Get layout preference
+    const layoutPreferenceRepo = this.reflectionHelper.getRepoService('LayoutPreference');
+    const layoutPreference = await layoutPreferenceRepo.findOne({
+      where: {
+        user_id: user_id,
+        mapped_entity_type: entityType,
+        mapped_level_id: level_id,
+        mapped_level_type: level_type,
+        type: 'layout',
+      },
+    });
+
+    // Get tabs configuration from layout or use default
+    let tabsConfig = layoutPreference?.mapped_json?.tabs;
+
+    // Fallback to default tabs config if layout preference doesn't have tabs
+    if (!tabsConfig || !tabsConfig.attribute_key) {
+      if (defaultTabsConfig && defaultTabsConfig.attribute_key) {
+        console.log('🔵 [Filter2.GetTabsData] Using default tabs config from UI');
+        tabsConfig = defaultTabsConfig;
+      } else {
+        throw new BadRequestException('Tabs configuration not found in layout preferences and no default provided');
+      }
+    }
+
+    const attributeKey = tabsConfig.attribute_key;
+    const showList = tabsConfig.show_list || [];
+    const sortBy = tabsConfig.sort_by || 'alphabetically'; // 'alphabetically' or 'count_low_to_high' or 'count_high_to_low'
+    const showAllTab = tabsConfig.show_all ?? true;
+    const combinedOther = tabsConfig.combined_other ?? false;
+
+    console.log('🔵 [Filter2.GetTabsData] Tabs config:', {
+      attributeKey,
+      showList,
+      sortBy,
+      showAllTab,
+      combinedOther,
+    });
+
+    // Get entity metadata
+    const entityMeta = await this.entityMasterService.getEntityData(entityType, userData);
+    let tableName = entityMeta?.data_source;
+
+    // Override table name for flatjson
+    if (flatJson) {
+      tableName = 'frm_entity_json';
+    }
+
+    if (!tableName) {
+      throw new BadRequestException(`Invalid entity_type: ${entityType}`);
+    }
+
+    // Get attribute metadata
+    const attributeMetaMap = await this.getAttributeMetaMap(entityType, userData);
+
+    // Build filter clauses
+    const { dbColClauses, eavJoins, eavClauses } = this.buildFilterClauses(
+      allFilters,
+      attributeMetaMap,
+      flatJson,
+      jsonColumn,
+    );
+
+    // Add entity_type filter for flatjson
+    if (flatJson) {
+      dbColClauses.push({
+        query: 'e.entity_type = :entity_type',
+        params: { entity_type: entityType },
+      });
+    }
+
+    // Add IDs filter if provided
+    if (ids && ids.length > 0) {
+      const idsStr = ids.map((id) => String(id));
+      if (flatJson) {
+        dbColClauses.push({
+          query: 'e.entity_id::text = ANY(:ids)',
+          params: { ids: `{${idsStr.join(',')}}` },
+        });
+      } else {
+        dbColClauses.push({
+          query: 'e.id::text = ANY(:ids)',
+          params: { ids: `{${idsStr.join(',')}}` },
+        });
+      }
+    }
+
+    // Build GROUP BY query
+    let groupByColumn: string;
+    if (flatJson) {
+      groupByColumn = `e.${jsonColumn}->>'${attributeKey}'`;
+    } else {
+      groupByColumn = `e.${attributeKey}`;
+    }
+
+    // Build query
+    const qb = this.entityManager
+      .createQueryBuilder()
+      .select(`${groupByColumn} AS tab_value`)
+      .addSelect('COUNT(*)', 'count')
+      .from(`${this.schema}.${tableName}`, 'e');
+
+    // Add EAV joins (only for non-flatjson)
+    if (!flatJson) {
+      addEavJoins(qb, eavJoins, this.schema);
+    }
+
+    // Apply WHERE clauses
+    applyWhereClauses(qb, dbColClauses);
+    if (!flatJson) {
+      applyWhereClauses(qb, eavClauses);
+    }
+
+    // Add GROUP BY
+    qb.groupBy(groupByColumn);
+
+    // Execute query
+    const tabResults = await qb.getRawMany();
+
+    console.log(`🔵 [Filter2.GetTabsData] Fetched ${tabResults.length} tab groups`);
+    // GET dropdown values for tab attributes
+    const tabDD = await this.listMasterService.getDropDownData(entityType, attributeKey, userData, {});
+
+    // Resolve tab values to display names
+    const resolvedTabs: { tab_name: string; count: number; original_value: string[] }[] = [];
+    for (const result of tabResults) {
+      const tabValue = result.tab_value;
+      const count = parseInt(result.count, 10);
+      const item = tabDD.find((opt) => opt.value == tabValue);
+
+      const tabName =
+        item?.label ||
+        (tabValue
+          ? String(tabValue).charAt(0).toUpperCase() + String(tabValue).slice(1).toLowerCase()
+          : 'Unknown');
+
+      const existingTab = resolvedTabs.find((t) => t.tab_name === tabName);
+
+      if (existingTab) {
+        existingTab.count += count;
+        if (Array.isArray(existingTab.original_value)) {
+          existingTab.original_value.push(tabValue);
+        } else {
+          // Should not happen based on new structure, but for safety
+          existingTab.original_value = [existingTab.original_value as string, tabValue];
+        }
+      } else {
+        resolvedTabs.push({
+          tab_name: tabName,
+          count,
+          original_value: [tabValue], // Now an array
+        });
+      }
+    }
+
+    // Filter tabs based on show_list
+    let filteredTabs: { tab_name: string; count: number; original_value?: string[] }[];
+    let otherTabsCount = 0;
+
+    if (showList.length > 0) {
+      filteredTabs = resolvedTabs.filter((tab) =>
+        tab.original_value.some((val) => showList.includes(val)),
+      );
+
+      if (combinedOther) {
+        // Calculate count for "Other" tab
+        otherTabsCount = resolvedTabs
+          .filter(
+            (tab) => !tab.original_value.some((val) => showList.includes(val)),
+          )
+          .reduce((sum, tab) => sum + tab.count, 0);
+      }
+    } else {
+      filteredTabs = resolvedTabs.map(({ tab_name, count }) => ({ tab_name, count }));
+    }
+
+    // Add "Other" tab if needed
+    if (combinedOther && otherTabsCount > 0) {
+      filteredTabs.push({
+        tab_name: 'Other',
+        count: otherTabsCount,
+      });
+    }
+
+    // Sort tabs
+    if (sortBy === 'count_low_to_high') {
+      filteredTabs.sort((a, b) => a.count - b.count);
+    } else if (sortBy === 'count_high_to_low') {
+      filteredTabs.sort((a, b) => b.count - a.count);
+    } else {
+      // Default: alphabetically
+      filteredTabs.sort((a, b) => a.tab_name.localeCompare(b.tab_name));
+    }
+
+    // Add "All" tab at the beginning if needed
+    const result: { tab_name: string; count: number }[] = [];
+    if (showAllTab) {
+      const totalCount = resolvedTabs.reduce((sum, tab) => sum + tab.count, 0);
+      result.push({
+        tab_name: 'All',
+        count: totalCount,
+      });
+    }
+
+    result.push(...filteredTabs);
+
+    console.log('🔵 [Filter2.GetTabsData] Returning tabs:', result);
+
+    return result;
+  }
+
+
+  /**
+   * Filter data with optimized sub-entity filtering
+   *
+   * This method extends GetFilterData to support filtering across related entities with:
+   * - Parallel sub-entity filtering (reduces wait time)
+   * - Batch relation lookup (single query instead of N queries)
+   * - Database-level AND logic (GROUP BY + HAVING)
+   *
+   * @param entityType - Main entity type to query (e.g., 'LEAD')
+   * @param filterConditions - Array of filter conditions (can include sub-entity filters)
+   * @param sortColumns - Array of sort columns with order
+   * @param columns - Array of attribute keys to select
+   * @param pagination - Pagination parameters (page, size)
+   * @param userData - Logged in user data
+   * @param flatJson - Whether to use flatjson storage
+   * @param jsonColumn - JSON column name
+   * @returns Object with entity_list and pagination info
+   *
+   * @example
+   * // Filter LEAD with conditions on both LEAD and its sub-entities (LFMG, LCO)
+   * const result = await filter2Service.GetFilterDataWithRelations(
+   *   'LEAD',
+   *   [
+   *     { filter_attribute: 'name', filter_operator: 'contains', filter_value: 'John', filter_entity_type: 'LEAD' },
+   *     { filter_attribute: 'father_sal', filter_operator: 'greater_than', filter_value: 50, filter_entity_type: 'LFMG' },
+   *     { filter_attribute: 'phone', filter_operator: 'contains', filter_value: '123', filter_entity_type: 'LCO' }
+   *   ],
+   *   [{ column: 'created_date', order: 'DESC' }],
+   *   ['id', 'name', 'email'],
+   *   { page: 1, size: 20 },
+   *   userData
+   * );
+   */
+  async getFilterDataWithRelations(
+    entityType: string,
+    filterConditions: FilterCondition[] = [],
+    sortColumns: { column: string; order: 'ASC' | 'DESC' }[] = [],
+    columns: string[] = [],
+    pagination?: PaginationParams,
+    userData?: any,
+    disableDefaultFilter: boolean = false,
+  ): Promise<FilterDataResult> {
+    console.log('🔶 [Filter2.GetFilterDataWithRelations] Starting with params:', {
+      entityType,
+      filterCount: filterConditions.length,
+      sortColumns,
+      columns,
+      pagination,
+    });
+
+    // Step 1: Group filters by entity type
+    const groupedFilters = groupFiltersByEntityType(filterConditions);
+    const entityTypes = Object.keys(groupedFilters);
+
+    console.log(
+      `🔶 [Filter2.GetFilterDataWithRelations] Grouped filters into ${entityTypes.length} entity types: ${entityTypes.join(', ')}`,
+    );
+
+    // Step 2: Separate main entity filters from sub-entity filters
+    const mainEntityFilters = groupedFilters[entityType] || [];
+    const subEntityFilters = Object.keys(groupedFilters)
+      .filter((type) => type !== entityType)
+      .reduce((acc, type) => {
+        acc[type] = groupedFilters[type];
+        return acc;
+      }, {} as Record<string, FilterCondition[]>);
+
+    const hasSubEntityFilters = Object.keys(subEntityFilters).length > 0;
+
+    console.log(
+      `🔶 [Filter2.GetFilterDataWithRelations] Main entity filters: ${mainEntityFilters.length}, Sub-entity types: ${Object.keys(subEntityFilters).length}`,
+    );
+
+    // If no sub-entity filters, just call regular GetFilterData
+    if (!hasSubEntityFilters) {
+      console.log(
+        '🔶 [Filter2.GetFilterDataWithRelations] No sub-entity filters, using regular GetFilterData',
+      );
+      return await this.GetFilterData(
+        entityType,
+        filterConditions,
+        sortColumns,
+        columns,
+        [],
+        pagination,
+        userData,
+        false,
+        'entity_json',
+        disableDefaultFilter,
+      );
+    }
+
+    // Step 3: Filter sub-entities in parallel
+    console.log(
+      '🔶 [Filter2.GetFilterDataWithRelations] Starting parallel sub-entity filtering',
+    );
+
+    const subEntityResults = await filterSubEntitiesInParallel(
+      subEntityFilters,
+      async (subEntityType, filters, userData) => {
+        return await this.GetFilterData(
+          subEntityType,
+          filters,
+          [],
+          ['id'], // Only need IDs for relation lookup
+          [],
+          undefined, // No pagination for sub-entities
+          userData,
+        );
+      },
+      userData,
+    );
+
+    console.log(
+      `🔶 [Filter2.GetFilterDataWithRelations] Sub-entity results: ${buildSubEntityFilterSummary(subEntityResults)}`,
+    );
+
+    // Step 4: Check if any sub-entity returned empty results (AND logic)
+    if (hasEmptySubEntityResults(subEntityResults)) {
+      console.log(
+        '🚫 [Filter2.GetFilterDataWithRelations] At least one sub-entity returned no results, returning empty',
+      );
+      return {
+        entity_list: [],
+        pagination: pagination
+          ? buildPaginationResult(0, pagination.page, pagination.size)
+          : undefined,
+      };
+    }
+
+    // Step 5: Get related main entity IDs using batch query
+    const batchRequests = toBatchRelationRequests(subEntityResults);
+
+    console.log(
+      `🔶 [Filter2.GetFilterDataWithRelations] Batch relation lookup for ${batchRequests.length} sub-entities`,
+    );
+
+    const relatedMainEntityIds = await this.entityRelationService.getRelatedEntityIdsBatch(
+      entityType,
+      batchRequests,
+      userData.enterprise_id,
+    );
+
+    console.log(
+      `🔶 [Filter2.GetFilterDataWithRelations] Batch lookup returned ${relatedMainEntityIds.length} ${entityType} IDs`,
+    );
+
+    if (relatedMainEntityIds.length === 0) {
+      console.log(
+        '🚫 [Filter2.GetFilterDataWithRelations] No related main entity IDs found, returning empty',
+      );
+      return {
+        entity_list: [],
+        pagination: pagination
+          ? buildPaginationResult(0, pagination.page, pagination.size)
+          : undefined,
+      };
+    }
+
+    // Step 6: Filter main entity with related IDs + main entity filters
+    console.log(
+      `🔶 [Filter2.GetFilterDataWithRelations] Filtering main entity with ${mainEntityFilters.length} filters and ${relatedMainEntityIds.length} related IDs`,
+    );
+
+    return await this.GetFilterData(
+      entityType,
+      mainEntityFilters,
+      sortColumns,
+      columns,
+      relatedMainEntityIds,
+      pagination,
+      userData,
+      false,
+      'entity_json',
+      disableDefaultFilter,
+    );
+  }
+
+  /**
+   * Evaluate the criteria for an entity using the filter service
+   * @param entityType type of entity
+   * @param entityId id of entity to evaluate
+   * @param criteriaFilterCode saved filter code for criteria
+   * @param filterService instance of your FilterService
+   */
+  async evaluateCriteria(
+    entityType: string,
+    criteriaFilterCode: string,
+    entityId: number,
+    loggedInUser: any,
+  ): Promise<boolean> {
+    if (!criteriaFilterCode) return true; // no criteria = always true
+
+    const filterRequest = {
+      entity_type: entityType,
+      savedFilterCode: criteriaFilterCode,
+      queryParams: { id: entityId },
+      page: 1,
+      size: 1,
+      loggedInUser: loggedInUser || { organization_id: null },
+    } as any;
+
+    const result = await this.getFilterDataInternal(filterRequest);
+
+    return result.entity_list?.length > 0;
+  }
+}