rez_core 6.1.5 → 6.1.7

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

@@ -1,1370 +1,1406 @@
-import {
-  BadRequestException,
-  forwardRef,
-  Inject,
-  Injectable,
-} from '@nestjs/common';
-import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
-import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
-import { FilterCondition, FilterRequestDto } from '../dto/filter-request.dto';
-import { SavedFilterService } from './saved-filter.service';
-
-import * as moment from 'moment';
-import { EntityRelationService } from 'src/module/meta/service/entity-relation.service';
-import { ResolverService } from 'src/module/meta/service/resolver.service';
-import { LoggingService } from 'src/utils/service/loggingUtil.service';
-import { ConfigService } from '@nestjs/config';
-import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
-import { EntityManager } from 'typeorm';
-import { FlatjsonFilterService } from './flatjson-filter.service';
-
-@Injectable()
-export class FilterService {
-  constructor(
-    private entityManager: EntityManager,
-    @Inject(forwardRef(() => AttributeMasterService))
-    private readonly attributeMasterService: AttributeMasterService,
-    @Inject(forwardRef(() => EntityMasterService))
-    private readonly entityMasterService: EntityMasterService,
-    @Inject('EntityRelationService')
-    private readonly entityRelationService: EntityRelationService,
-    @Inject('SavedFilterService')
-    private readonly savedFilterService: SavedFilterService,
-    @Inject(forwardRef(() => ResolverService))
-    private readonly resolverService: ResolverService,
-    @Inject(forwardRef(() => LoggingService))
-    protected readonly loggingService: LoggingService,
-    private readonly configService: ConfigService,
-    @Inject(forwardRef(() => ReflectionHelper))
-    private readonly reflectionHelper: ReflectionHelper,
-    @Inject(forwardRef(() => FlatjsonFilterService))
-    private readonly flatjsonFilterService: FlatjsonFilterService,
-  ) {}
-
-  schema = this.configService.get('DB_SCHEMA');
-
-  private async gettab_value_counts(
-    tableName: string,
-    column: string | undefined,
-    whereClauses: { query: string; params: Record<string, any> }[],
-  ) {
-    if (!column) return [];
-
-    let whereSQL = '';
-    const values: any[] = [];
-    let paramIndex = 1; // PostgreSQL placeholders start at $1
-
-    if (whereClauses.length > 0) {
-      const clauseParts = whereClauses.map((clause) => {
-        let parsedQuery = clause.query.replace(/\be\./g, ''); // remove e.
-
-        Object.entries(clause.params).forEach(([key, val]) => {
-          if (Array.isArray(val)) {
-            // Create ($1,$2,$3)
-            const placeholders = val.map(() => `$${paramIndex++}`).join(', ');
-
-            parsedQuery = parsedQuery.replace(
-              new RegExp(`:${key}`, 'g'),
-              `(${placeholders})`,
-            );
-
-            values.push(...val.map((v) => String(v)));
-          } else {
-            // Create $1
-            const placeholder = `$${paramIndex++}`;
-
-            parsedQuery = parsedQuery.replace(
-              new RegExp(`:${key}`, 'g'),
-              placeholder,
-            );
-
-            values.push(String(val));
-          }
-        });
-
-        return parsedQuery;
-      });
-
-      whereSQL = `WHERE ${clauseParts.join(' AND ')}`;
-    }
-
-    const rawSQL = `
-        SELECT ${column} AS tab_value, COUNT(*) AS tab_value_count
-        FROM ${this.schema}.${tableName} ${whereSQL}
-        GROUP BY ${column}
-    `;
-
-    const rows = await this.entityManager.query(rawSQL, values);
-
-    const total = rows.reduce(
-      (sum, r) => sum + parseInt(r.tab_value_count, 10),
-      0,
-    );
-
-    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),
-      })),
-    ];
-  }
-
-  /**
-   * Route to flatjson or traditional filtering based on configuration
-   */
-  async applyFilterWithRouting(dto: FilterRequestDto) {
-    // Check if flatjson filtering is enabled via config or query param
-    const useFlatjson = dto.queryParams?.use_flatjson === 'true';
-
-    if (useFlatjson) {
-      await this.loggingService.log(
-        'info',
-        'FilterService',
-        'applyFilterWithRouting',
-        `Using FLATJSON filtering for ${dto.entity_type}`,
-      );
-
-      // Use new flatjson filtering service
-      const result = await this.flatjsonFilterService.applyFlatjsonFilter(dto);
-
-      // Transform to match existing response format
-      return {
-        success: true,
-        data: {
-          entity_tabs: result.tabCounts || [],
-          entity_list: result.data,
-          pagination: {
-            total: result.total,
-            page: result.page,
-            size: result.size,
-            totalPages: result.totalPages,
-          },
-        },
-      };
-    } else {
-      await this.loggingService.log(
-        'info',
-        'FilterService',
-        'applyFilterWithRouting',
-        `Using TRADITIONAL filtering for ${dto.entity_type}`,
-      );
-
-      // Use traditional filtering
-      return this.applyFilterWrapper(dto);
-    }
-  }
-
-  async applyFilterWrapper(dto: FilterRequestDto) {
-    const {
-      entity_type,
-      quickFilter = [],
-      savedFilterCode,
-      attributeFilter = [],
-      loggedInUser,
-    } = dto;
-
-    // 🔹 Step 1: Collect all filters (from body + savedFilter)
-    const savedFilters = await this.getSavedFilters(
-      savedFilterCode ?? undefined,
-    );
-    const allFilters = [
-      ...quickFilter,
-      ...attributeFilter,
-      ...savedFilters,
-    ].filter((f) => f.filter_value !== '');
-
-    // 🔹 Step 2: Group filters by filter_entity_type
-    const grouped = allFilters.reduce(
-      (acc, f) => {
-        if (!acc[f.filter_entity_type]) acc[f.filter_entity_type] = [];
-        acc[f.filter_entity_type].push(f);
-        return acc;
-      },
-      {} as Record<string, any[]>,
-    );
-
-    console.log('🟠 [FilterService] Grouped filters by entity type:', grouped);
-
-    // 🔹 Step 3: Handle sub-entities first
-    let intersectionIds: number[] | null = null;
-    for (const [subEntityType, filters] of Object.entries(grouped)) {
-      if (subEntityType === entity_type) continue; // skip main entity for now
-
-      let { queryParams, tabs, ...newDto } = dto;
-
-      const subDto: FilterRequestDto = {
-        ...newDto,
-        entity_type: subEntityType,
-        quickFilter: filters as FilterCondition[],
-        savedFilterCode: null, // already merged
-        attributeFilter: [],
-      };
-
-      const subResult = await this.applyFilter(subDto);
-      const subEntityIds = subResult.data.entity_list.map((row) => row.id);
-
-      console.log(
-        `🧩 [FilterService] Sub-entity ${subEntityType} returned IDs:`,
-        subEntityIds,
-      );
-
-      if (!subEntityIds.length) {
-        console.log(
-          `ℹ️ [FilterService] No records for sub-entity ${subEntityType}, returning empty result`,
-        );
-        return {
-          success: true,
-          data: { entity_tabs: [], entity_list: [], pagination: {} },
-        };
-      }
-
-      const relatedIds = await this.entityRelationService.getRelatedEntityIds(
-        entity_type,
-        subEntityType,
-        subEntityIds,
-        dto.loggedInUser.enterprise_id,
-      );
-
-      intersectionIds =
-        intersectionIds === null
-          ? relatedIds
-          : intersectionIds.filter((id) => relatedIds.includes(id));
-
-      if (intersectionIds.length === 0) {
-        console.log(
-          '🚫 [FilterService] No intersection IDs left, returning empty result',
-        );
-        return {
-          success: true,
-          data: { entity_tabs: [], entity_list: [], pagination: {} },
-        };
-      }
-    }
-
-    // 🔹 Step 4: Call applyFilter for main entity
-    const mainFilters = grouped[entity_type] || [];
-    const mainDto: FilterRequestDto = {
-      ...dto,
-      quickFilter: [...mainFilters],
-      savedFilterCode: null,
-      attributeFilter: [],
-    };
-
-    if (intersectionIds && intersectionIds.length > 0) {
-      (mainDto.quickFilter ??= []).push({
-        filter_attribute: 'id',
-        filter_operator: 'equal',
-        filter_value: intersectionIds,
-        filter_entity_type: entity_type,
-      });
-    }
-
-    return await this.applyFilter(mainDto);
-  }
-
-  async applyFilter(dto: FilterRequestDto) {
-    const {
-      entity_type,
-      quickFilter,
-      savedFilterCode,
-      attributeFilter,
-      tabs,
-      sortby,
-      loggedInUser,
-      queryParams,
-      customLevelType,
-      customLevelId,
-      customAppCode,
-    } = dto;
-
-    // abstract user details
-    const {
-      level_type,
-      level_id,
-      id: user_id,
-      appcode,
-      organization_id,
-      enterprise_id,
-    } = loggedInUser || {};
-
-    // Fetch meta from entity table service
-    const entityMeta = await this.entityMasterService.getEntityData(
-      entity_type,
-      loggedInUser,
-    );
-    const tableName = entityMeta?.data_source; // data_source is the table name
-
-    if (!tableName) {
-      console.error(`❌ [FilterService] Invalid entity_type: ${entity_type}`);
-      throw new BadRequestException(`Invalid entity_type: ${entity_type}`);
-    }
-
-    const getAttributeColumnMeta =
-      await this.attributeMasterService.findAttributesByMappedEntityType(
-        entity_type,
-        loggedInUser,
-      );
-
-    const attributeMetaMap = getAttributeColumnMeta.reduce(
-      (acc, attr) => {
-        acc[attr.attribute_key] = attr;
-        return acc;
-      },
-      {} as Record<string, any>,
-    );
-
-    // Get and parse saved filters
-    const savedFilters = await this.getSavedFilters(
-      savedFilterCode ?? undefined,
-    );
-    const savedFiltersNormalized = savedFilters.map((f) => ({
-      filter_attribute: f.filter_attribute,
-      filter_operator: f.filter_operator,
-      filter_value: f.filter_value,
-    }));
-
-    const baseFilters = [
-      ...(quickFilter || []).filter(
-        (f) => f.filter_value != null && f.filter_value !== '',
-      ),
-      ...savedFiltersNormalized.filter(
-        (f) => f.filter_value != null && f.filter_value !== '',
-      ),
-      ...(attributeFilter || []).filter(
-        (f) => f.filter_value != null && f.filter_value !== '',
-      ),
-    ];
-
-    // 🧱 Build where clausesx
-    const baseWhere = this.buildWhereClauses(baseFilters, attributeMetaMap);
-
-    // Handle TEMPLATE entity special condition
-    if (entity_type === 'TEMP' || entity_type === 'TEM') {
-      if (level_type === 'ORG') {
-        baseWhere.push({
-          query: `  ((e.level_type = 'ORG' AND e.level_id = '${loggedInUser.enterprise_id}'))`,
-          params: {},
-        });
-      } else if (level_type === 'SCH') {
-        baseWhere.push({
-          query: `
-        (
-          (e.level_type = 'SCH' AND e.level_id = '${loggedInUser.level_id}')
-          OR 
-          (
-            e.level_type = 'ORG'
-            AND e.level_id = '${loggedInUser.enterprise_id}'
-            AND e.enterprise_id = '${loggedInUser.enterprise_id}'
-            AND e.code NOT IN (
-              SELECT sub.code 
-              FROM frm_wf_comm_template AS sub 
-              WHERE sub.level_type = 'SCH' AND sub.level_id = '${loggedInUser.level_id}'
-            )
-          )
-        )
-      `,
-          params: {},
-        });
-      }
-    }
-
-    // Default org/level clause — skip TEMPLATE entity
-    if (
-      entity_type !== 'ORGP' &&
-      entity_type !== 'TEMP' &&
-      entity_type !== 'TEM' && // ✅ skip TEMPLATE
-      entity_type !== 'SCH' &&
-      level_type &&
-      level_id &&
-      organization_id &&
-      !customLevelType &&
-      !customLevelId
-    ) {
-      baseWhere.push({
-        query: 'e.level_type = :level_type AND e.level_id = :level_id',
-        params: {
-          level_type,
-          level_id,
-        },
-      });
-    }
-
-    if (entity_type == 'USR' || entity_type == 'UPR') {
-      baseWhere.push({
-        query: 'e.is_customer is NULL',
-        params: {},
-      });
-    }
-
-    if (customLevelType && customLevelId && customAppCode) {
-      baseWhere.push({
-        query:
-          'e.level_type = :customLevelType AND e.level_id = :customLevelId AND e.appcode = :customAppCode',
-        params: {
-          customLevelType,
-          customLevelId: String(customLevelId),
-          customAppCode,
-        },
-      });
-    }
-
-    // Handle queryParams filters
-    if (queryParams) {
-      Object.entries(queryParams).forEach(([key, value]) => {
-        if (!value) return;
-
-        // Always convert to string
-        const strValue = String(value);
-
-        if (key === 'attributeName' && queryParams['attributeValue']) {
-          const attrName = strValue;
-          const attrValue = String(queryParams['attributeValue']);
-
-          baseWhere.push({
-            query: `e.${attrName} = :${attrName}`,
-            params: { [attrName]: attrValue }, // <-- string
-          });
-        } else if (key !== 'attributeValue') {
-          baseWhere.push({
-            query: `e.${key} = :${key}`,
-            params: { [key]: strValue }, // <-- string
-          });
-        }
-      });
-    }
-
-    console.log('🟠 [FilterService] Constructed baseWhere clauses:', baseWhere);
-
-    let layoutPreferenceRepo =
-      this.reflectionHelper.getRepoService('LayoutPreference');
-
-    const layoutPreference = await layoutPreferenceRepo.findOne({
-      where: {
-        user_id: user_id,
-        mapped_entity_type: entity_type,
-        mapped_level_id: level_id,
-        mapped_level_type: level_type,
-        type: 'layout',
-      },
-    });
-
-    // Extract layout preference
-    const layout = layoutPreference?.mapped_json?.quick_tab || {};
-    const showList =
-      layout?.show_list?.map((val) => {
-        if (typeof val === 'string') {
-          // legacy case — old format like ['Active', 'Inactive']
-          return val.toLowerCase();
-        }
-
-        if (val && typeof val === 'object' && val.value !== undefined) {
-          // new format — [{ label: 'Active', value: '13023' }]
-          return String(val.value).toLowerCase();
-        }
-
-        return ''; // fallback safety
-      }) || [];
-
-    let filteredTabs = await this.getFilteredTabs(
-      layout,
-      showList,
-      entityMeta,
-      baseWhere,
-      tabs,
-      loggedInUser,
-    );
-
-    const dataWhere = [...baseWhere];
-
-    // if (tabs?.columnName && tabs?.value) {
-    //   const tabAttrMeta = attributeMetaMap[tabs.columnName];
-    //   const tabValue = tabs.value.toLowerCase();
-
-    //   if (tabValue === 'others') {
-    //     // Extract 'value' (IDs) from showList, ignore 'all'
-    //     const valuesToExclude = showList
-    //       .filter((v) => v.label.toLowerCase() !== 'all')
-    //       .map((v) => v.value);
-
-    //     if (valuesToExclude.length > 0) {
-    //       for (const value of valuesToExclude) {
-    //         const resolvedId = await this.resolverService.getResolvedId(
-    //           loggedInUser,
-    //           tabs.columnName,
-    //           value,
-    //           entity_type,
-    //         );
-    //         if (resolvedId) {
-    //           const tabCondition = this.buildCondition(
-    //             {
-    //               filter_attribute: tabs.columnName,
-    //               filter_operator: 'not_equal',
-    //               filter_value: [resolvedId],
-    //               skip_id: true,
-    //             },
-    //             tabAttrMeta,
-    //           );
-    //           if (tabCondition) dataWhere.push(tabCondition);
-    //         }
-    //       }
-    //     }
-    //   } else if (tabValue !== 'all') {
-    //     const resolvedId = await this.resolverService.getResolvedId(
-    //       loggedInUser,
-    //       tabs.columnName,
-    //       tabs.value,
-    //       entity_type,
-    //     );
-
-    //     if (resolvedId) {
-    //       const tabCondition = this.buildCondition(
-    //         {
-    //           filter_attribute: tabs.columnName,
-    //           filter_operator: 'equal',
-    //           filter_value: [resolvedId],
-    //           skip_id: true,
-    //         },
-    //         tabAttrMeta,
-    //       );
-    //       if (tabCondition) dataWhere.push(tabCondition);
-    //     }
-    //   }
-    // }
-
-    let qb = this.entityManager
-      .createQueryBuilder()
-      .select('e.*')
-      .from(`${this.schema}.${tableName}`, 'e');
-    dataWhere.forEach((clause) => qb.andWhere(clause.query, clause.params));
-
-    // Apply sorting
-    qb = await this.sortTabsByShowList(qb, sortby, layoutPreference, tabs);
-    const page = dto.page && dto.page > 0 ? dto.page : 1;
-    const size = dto.size && dto.size > 0 ? dto.size : 10;
-    if (dto.page && dto.size) {
-      qb.skip((page - 1) * size).take(size);
-    }
-
-    let query = await qb.getQuery();
-
-    console.log('------------------------------------------------------\n');
-    console.log(query);
-    console.log('\n------------------------------------------------------');
-    const entity_list = await qb.getRawMany();
-
-    console.log(`📦 [FilterService] Fetched ${entity_list.length} records`);
-
-    const dateAttributes = Object.entries(attributeMetaMap)
-      .filter(([_, attr]) => attr.data_type === 'date')
-      .map(([key]) => key);
-
-    const formatDate = (dateStr: string | null): string | null =>
-      dateStr ? moment(dateStr).format('DD-MM-YYYY') : '';
-
-    const formatDatesInRow = (row: any): any => {
-      const formattedRow = { ...row };
-      for (const key of dateAttributes) {
-        if (formattedRow[key])
-          formattedRow[key] = formatDate(formattedRow[key]);
-      }
-      return formattedRow;
-    };
-
-    const formattedEntityList = entity_list.map(formatDatesInRow);
-
-    // const resolvedEntityList = await Promise.all(
-    //   formattedEntityList.map((row) =>
-    //     this.resolverService.getResolvedData(loggedInUser, row, entity_type),
-    //   ),
-    // );
-
-    const resolvedTabs = await Promise.all(
-      filteredTabs.map(async (tab) => {
-        const tabAttrKey = layout?.attribute || tabs?.columnName;
-
-        if (
-          !tabAttrKey ||
-          tab.tab_value?.toLowerCase() === 'all' ||
-          tab.tab_value?.toLowerCase() === 'others'
-        ) {
-          return tab;
-        }
-
-        // const resolvedVal = await this.resolverService.getResolvedValue(
-        //   loggedInUser,
-        //   tabAttrKey,
-        //   tab.tab_value,
-        //   entity_type,
-        // );
-
-        return { ...tab, tab_value: tab.tab_value ?? tab.tab_value };
-      }),
-    );
-
-    const countQb = this.entityManager
-      .createQueryBuilder()
-      .select('COUNT(*)', 'count')
-      .from(`${this.schema}.${tableName}`, 'e');
-    dataWhere.forEach((clause) =>
-      countQb.andWhere(clause.query, clause.params),
-    );
-    const countResult = await countQb.getRawOne();
-    const total = parseInt(countResult.count, 10);
-
-    console.log('📊 [FilterService] Returning final result with total:', total);
-
-    return {
-      success: true,
-      data: {
-        entity_tabs: resolvedTabs,
-        entity_list: formattedEntityList,
-        pagination: {
-          total,
-          page,
-          size,
-          totalPages: Math.ceil(total / size),
-          hasNextPage: page * size < total,
-          hasPreviousPage: page > 1,
-        },
-      },
-    };
-  }
-
-  // GET FILTERED TABS LOGIC
-  private async getFilteredTabs(
-    layout: any,
-    showList: any,
-    entityMeta: any,
-    baseWhere: any,
-    tabs: any,
-    loggedInUser: any,
-  ) {
-    let allTabs;
-    if (layout.attribute) {
-      allTabs = await this.gettab_value_counts(
-        entityMeta?.data_source,
-        layout.attribute,
-        baseWhere,
-      );
-    } else {
-      allTabs = await this.gettab_value_counts(
-        entityMeta?.data_source,
-        tabs?.columnName,
-        baseWhere,
-      );
-    }
-
-    let filteredTabs: any[] = [];
-
-    if (showList?.length > 0) {
-      // Extract tab IDs (values)
-      const showValues = (showList || []).map((item) => {
-        const val = typeof item === 'object' ? item.value : item;
-        return val ? String(val).toLowerCase() : '';
-      });
-
-      // Handle "all" logic
-      const isAllNeeded = layout?.isAllSelected && !showValues.includes('all');
-      if (isAllNeeded) {
-        showList.push({ label: 'All', value: 'all' });
-        showValues.push('all');
-      }
-
-      // Filter by value IDs (not labels)
-      filteredTabs = allTabs.filter((tab) => {
-        const tabValueStr = tab.tab_value
-          ? String(tab.tab_value).toLowerCase()
-          : '';
-        return showValues.includes(tabValueStr);
-      });
-
-      // Handle "all" tab
-      const allTab = filteredTabs.find(
-        (tab) => tab.tab_value?.toString().toLowerCase() === 'all',
-      );
-      filteredTabs = filteredTabs.filter(
-        (tab) => tab.tab_value?.toString().toLowerCase() !== 'all',
-      );
-
-      // SORTING LOGIC
-      if (layout.sorting === 'asc') {
-        filteredTabs.sort((a, b) =>
-          a.tab_value.toString().localeCompare(b.tab_value.toString()),
-        );
-      } else if (layout.sorting === 'dsc') {
-        filteredTabs.sort((a, b) =>
-          b.tab_value.toString().localeCompare(a.tab_value.toString()),
-        );
-      } else if (layout.sorting === 'count_asc') {
-        filteredTabs.sort((a, b) => a.tab_value_count - b.tab_value_count);
-      } else if (layout.sorting === 'count_dsc') {
-        filteredTabs.sort((a, b) => b.tab_value_count - a.tab_value_count);
-      } else if (layout.sorting === 'custom') {
-        // Keep order same as showList
-        const orderMap = new Map<string, number>(
-          showList.map((item, index) => [
-            item.value?.toString().toLowerCase(),
-            index,
-          ]),
-        );
-        filteredTabs.sort((a, b) => {
-          const aIndex =
-            orderMap.get(a.tab_value?.toString().toLowerCase()) ?? Infinity;
-          const bIndex =
-            orderMap.get(b.tab_value?.toString().toLowerCase()) ?? Infinity;
-          return aIndex - bIndex;
-        });
-      }
-
-      // Re-add "all" tab at beginning if needed
-      if (allTab) filteredTabs.unshift(allTab);
-
-      // Combine others if enabled
-      if (layout?.isCombineOther) {
-        const originalAllTab = allTabs.find(
-          (tab) => tab.tab_value?.toString().toLowerCase() === 'all',
-        );
-        const allCount = originalAllTab?.tab_value_count ?? 0;
-        const knownTabCountSum = filteredTabs
-          .filter((tab) => tab.tab_value?.toString().toLowerCase() !== 'all')
-          .reduce((acc, tab) => acc + tab.tab_value_count, 0);
-
-        const othersCount = allCount - knownTabCountSum;
-        filteredTabs.push({
-          tab_value: 'OTHERS',
-          tab_value_count: othersCount < 0 ? 0 : othersCount,
-        });
-      }
-    } else {
-      filteredTabs = allTabs;
-    }
-
-    return filteredTabs;
-  }
-
-  // SORTING LOGIC FOR TABS
-  private async sortTabsByShowList(
-    qb: any,
-    sortby: any,
-    layoutPreference: any,
-    tabs: any,
-  ) {
-    const sorting = layoutPreference?.mapped_json?.sorting;
-
-    if (sorting) {
-      if (Array.isArray(sorting?.tabs)) {
-        const preferenceTabArray = sorting?.tabs;
-        const tabFilter = preferenceTabArray.find(
-          (tabData) => tabData.tab_name?.value === tabs?.value,
-        );
-
-        tabFilter?.sortby?.forEach(({ column, order }) => {
-          qb.addOrderBy(
-            `e.${column}`,
-            order?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC',
-          );
-        });
-      } else if (Array.isArray(sorting.sortby)) {
-        sorting?.sortby?.forEach(({ column, order }) => {
-          qb.addOrderBy(
-            `e.${column}`,
-            order?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC',
-          );
-        });
-      }
-    }
-
-    if (Array.isArray(sortby) && sortby.length > 0) {
-      sortby.forEach(({ sortColum, sortType }) => {
-        if (sortColum) {
-          qb.addOrderBy(
-            `e.${sortColum}`,
-            sortType?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC',
-          );
-        }
-      });
-    } else {
-      // fallback if no explicit sortby sent
-      qb.addOrderBy('e.created_date', 'DESC');
-    }
-
-    return qb;
-  }
-
-  private parseFilters(raw: any, isSingle = false): any[] {
-    if (!raw) return [];
-
-    if (typeof raw === 'string') {
-      try {
-        const parsed = JSON.parse(raw);
-        return isSingle ? [parsed] : parsed;
-      } catch {
-        throw new BadRequestException('Invalid JSON in filter input');
-      }
-    }
-
-    return isSingle ? [raw] : Array.isArray(raw) ? raw : [];
-  }
-
-  private async getSavedFilters(code?: string): Promise<any[]> {
-    if (!code) return [];
-
-    const savedFilter = await this.savedFilterService.getDetailsByCode(code);
-    if (!savedFilter) {
-      throw new BadRequestException(`Saved filter not found for code: ${code}`);
-    }
-    return savedFilter;
-  }
-
-  private buildWhereClauses(
-    filters: any[],
-    attributeMeta: Record<string, any>,
-  ) {
-    return filters
-      .map((f) => {
-        const clause = this.buildCondition(
-          f,
-          attributeMeta[f.filter_attribute],
-        );
-
-        if (!clause) return null;
-
-        // Force every param to be a string
-        if (clause.params) {
-          Object.keys(clause.params).forEach((k) => {
-            const val = clause.params[k];
-            if (!Array.isArray(val)) {
-              clause.params[k] = String(val); // only convert scalar values
-            }
-          });
-        }
-
-        return clause;
-      })
-      .filter(
-        (clause): clause is { query: string; params: Record<string, string> } =>
-          clause !== null,
-      );
-  }
-
-  private buildCondition(
-    filter: any,
-    meta: any,
-  ): { query: string; params: any } | null {
-    if (!meta) return null;
-
-    let attr = filter.filter_attribute;
-    const val = filter.filter_value;
-    const op = filter.filter_operator;
-    const key = `param_${attr}_${Math.random().toString(36).substring(2, 8)}`;
-
-    // if (
-    //   (meta.data_source_type === 'entity' ||
-    //     meta.data_source_type === 'master') &&
-    //   !filter.skip_id
-    // ) {
-    //   attr = `${attr}_id`;
-    // }
-
-    switch (meta.data_type) {
-      case 'text':
-        return this.buildTextCondition(attr, op, val, key);
-      case 'number':
-        return this.buildNumberCondition(attr, op, val, key);
-      case 'date':
-        return this.buildDateCondition(attr, op, val, key);
-      case 'select':
-        return this.buildMultiSelectCondition(attr, op, val, key);
-      case 'multiselect':
-        return this.buildMultiSelectCondition(attr, op, val, key);
-      case 'checkbox':
-        return this.buildMultiSelectCondition(attr, op, val, key);
-      case 'radio':
-        return this.buildMultiSelectCondition(attr, op, val, key);
-      case 'year':
-        return this.buildYearCondition(attr, op, val, key);
-      default:
-        return null;
-    }
-  }
-
-  private buildTextCondition(attr: string, op: string, val: any, key: string) {
-    switch (op) {
-      case 'contains':
-        return {
-          query: `LOWER(e.${attr}) LIKE :${key}`,
-          params: { [key]: `%${val ? val.toLowerCase() : ''}%` },
-        };
-      case 'equal':
-        return {
-          query: `e.${attr} = :${key}`,
-          params: { [key]: val },
-        };
-      case 'not_equal':
-        return {
-          query: `e.${attr} != :${key}`,
-          params: { [key]: val },
-        };
-      case 'empty':
-        return {
-          query: `e.${attr} IS NULL`,
-          params: {},
-        };
-      case 'not_empty':
-        return {
-          query: `e.${attr} IS NOT NULL`,
-          params: {},
-        };
-      default:
-        throw new BadRequestException(`Unsupported operator for text: ${op}`);
-    }
-  }
-
-  private buildNumberCondition(
-    attr: string,
-    op: string,
-    val: any,
-    key: string,
-  ) {
-    switch (op) {
-      case 'equal':
-        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
-      case 'not_equal':
-        return { query: `e.${attr} != :${key}`, params: { [key]: val } };
-      case 'greater_than':
-        return { query: `e.${attr} > :${key}`, params: { [key]: val } };
-      case 'less_than':
-        return { query: `e.${attr} < :${key}`, params: { [key]: val } };
-      case 'less_than_qual_to':
-        return { query: `e.${attr} <= :${key}`, params: { [key]: val } };
-      case 'greater_than_qual_to':
-        return { query: `e.${attr} >= :${key}`, params: { [key]: val } };
-      case 'empty':
-        return { query: `e.${attr} IS NULL`, params: {} };
-      case 'not_empty':
-        return { query: `e.${attr} IS NOT NULL`, params: {} };
-
-      default:
-        throw new BadRequestException(`Unsupported operator for number: ${op}`);
-    }
-  }
-
-  private buildDateCondition(attr: string, op: string, val: any, key: string) {
-    const dateColumn = `DATE(e.${attr})`;
-    const monthColumn = `DATE_TRUNC('month', e.${attr})`;
-
-    // convert to number when needed
-    const numVal = Number(val);
-
-    // INSIDE buildDateCondition
-    const subtractBusinessDays = (days: number): string => {
-      let d = new Date();
-      let count = 0;
-
-      while (count < days) {
-        d.setDate(d.getDate() - 1);
-
-        const day = d.getDay(); // 0 = Sunday, 6 = Saturday
-
-        if (day !== 0 && day !== 6) {
-          count++;
-        }
-      }
-
-      return d.toISOString().split('T')[0];
-    };
-
-    switch (op) {
-      // ============================================
-      // BASIC COMPARISONS
-      // ============================================
-      case 'equal':
-      case 'is':
-        return {
-          query: `${dateColumn} = :${key}`,
-          params: { [key]: val },
-        };
-
-      case 'before':
-      case 'is_before':
-        return {
-          query: `${dateColumn} < :${key}`,
-          params: { [key]: val },
-        };
-
-      case 'after':
-      case 'is_after':
-        return {
-          query: `${dateColumn} > :${key}`,
-          params: { [key]: val },
-        };
-
-      case 'is_on_or_before':
-        return {
-          query: `${dateColumn} <= :${key}`,
-          params: { [key]: val },
-        };
-
-      case 'is_on_or_after':
-        return {
-          query: `${dateColumn} >= :${key}`,
-          params: { [key]: val },
-        };
-
-      // ============================================
-      // EMPTY / NOT EMPTY
-      // ============================================
-      case 'empty':
-        return {
-          query: `e.${attr} IS NULL`,
-          params: {},
-        };
-
-      case 'not_empty':
-        return {
-          query: `e.${attr} IS NOT NULL`,
-          params: {},
-        };
-
-      // ============================================
-      // DAY OFFSET LOGIC (ALWAYS ADJUST -1 DAY)
-      // ============================================
-      case 'is_day_before':
-        if (isNaN(numVal)) {
-          throw new BadRequestException(
-            'Value must be a number for is_day_before',
-          );
-        }
-
-        const dayBefore = (() => {
-          const d = new Date();
-          d.setDate(d.getDate() - numVal);
-
-          // Format as YYYY-MM-DD in IST
-          return d.toLocaleDateString('en-CA', { timeZone: 'Asia/Kolkata' });
-        })();
-
-        return {
-          query: `${dateColumn} <= :${key}`,
-          params: { [key]: dayBefore },
-        };
-
-      case 'is_day_after':
-        if (isNaN(numVal)) {
-          throw new BadRequestException(
-            'Value must be a number for is_day_after',
-          );
-        }
-
-        const dayAfter = (() => {
-          const d = new Date();
-          d.setDate(d.getDate() - 1 + numVal); // -1 because DB stores previous day
-          return d.toISOString().split('T')[0];
-        })();
-
-        return {
-          query: `${dateColumn} > :${key}`,
-          params: { [key]: dayAfter },
-        };
-
-      // ============================================
-      // MONTH OFFSET LOGIC
-      // ============================================
-      case 'is_month_before':
-        if (isNaN(numVal)) {
-          throw new BadRequestException(
-            'Value must be a number for is_month_before',
-          );
-        }
-
-        const monthBefore = (() => {
-          const d = new Date();
-          d.setMonth(d.getMonth() - numVal);
-          d.setDate(1);
-          d.setDate(d.getDate() - 1);
-          return d.toISOString().split('T')[0];
-        })();
-
-        return {
-          query: `${monthColumn} < DATE_TRUNC('month', (:${key})::date)`,
-          params: { [key]: monthBefore },
-        };
-
-      case 'is_month_after':
-        if (isNaN(numVal)) {
-          throw new BadRequestException(
-            'Value must be a number for is_month_after',
-          );
-        }
-
-        const monthAfter = (() => {
-          const d = new Date();
-          d.setMonth(d.getMonth() + numVal);
-          d.setDate(1);
-          d.setDate(d.getDate() - 1);
-          return d.toISOString().split('T')[0];
-        })();
-
-        return {
-          query: `${monthColumn} > DATE_TRUNC('month', (:${key})::date)`,
-          params: { [key]: monthAfter },
-        };
-
-      // ===== BETWEEN =====
-      case 'between': {
-        if (typeof val === 'string') {
-          val = val.split(',').map((v) => v.trim());
-        }
-
-        if (
-          !Array.isArray(val) ||
-          val.length !== 2 ||
-          val[0] === '' ||
-          val[1] === ''
-        ) {
-          console.log(`Invalid value for between: ${val}`);
-          return null;
-        }
-
-        return {
-          query: `${dateColumn} BETWEEN :${key}_start AND :${key}_end`,
-          params: {
-            [`${key}_start`]: val[0],
-            [`${key}_end`]: val[1],
-          },
-        };
-      }
-
-      // ===== TODAY =====
-      case 'today': {
-        const today = moment().format('YYYY-MM-DD');
-        return {
-          query: `${dateColumn} = :today`,
-          params: { today },
-        };
-      }
-
-      // ============================================
-      // BUSINESS DAY OFFSET LOGIC (SKIPS WEEKENDS)
-      // ALWAYS ADJUST -1 DAY FOR DB SHIFT
-      // ============================================
-
-      case 'is_before_business_days': {
-        if (isNaN(numVal)) {
-          throw new BadRequestException('Value must be a number');
-        }
-
-        const targetDate = subtractBusinessDays(numVal);
-
-        return {
-          query: `${dateColumn} <= :${key} AND EXTRACT(DOW FROM ${dateColumn}) NOT IN (0, 6)`,
-          params: { [key]: targetDate },
-        };
-      }
-
-      case 'is_after_business_days': {
-        if (isNaN(numVal)) {
-          throw new BadRequestException(
-            'Value must be a number for is_after_business_days',
-          );
-        }
-
-        const businessAfter = (() => {
-          let d = new Date();
-          let count = 0;
-
-          while (count < numVal) {
-            d.setDate(d.getDate() + 1);
-            const day = d.getDay(); // 0=Sun, 6=Sat
-            if (day !== 0 && day !== 6) count++;
-          }
-
-          // DB shift -1 day
-          d.setDate(d.getDate() - 1);
-
-          return d.toISOString().split('T')[0];
-        })();
-
-        return {
-          query: `${dateColumn} > :${key}`,
-          params: { [key]: businessAfter },
-        };
-      }
-
-      // ============================================
-      // IN LAST DAY (range: today to N days before)
-      // ============================================
-      case 'in_last_day': {
-        if (isNaN(numVal)) {
-          throw new BadRequestException(
-            'Value must be a number for in_last_day',
-          );
-        }
-
-        const today = (() => {
-          const d = new Date();
-          return d.toISOString().split('T')[0];
-        })();
-
-        const lastN = (() => {
-          const d = new Date();
-          d.setDate(d.getDate() - numVal);
-          return d.toISOString().split('T')[0];
-        })();
-
-        return {
-          query: `${dateColumn} BETWEEN :${key}_start AND :${key}_end`,
-          params: {
-            [`${key}_start`]: lastN,
-            [`${key}_end`]: today,
-          },
-        };
-      }
-
-      // ============================================
-      // IN NEXT DAY (range: today to N days after)
-      // ============================================
-      case 'in_next_day': {
-        if (isNaN(numVal)) {
-          throw new BadRequestException(
-            'Value must be a number for in_next_day',
-          );
-        }
-
-        const today = (() => {
-          const d = new Date();
-          return d.toISOString().split('T')[0];
-        })();
-
-        const nextN = (() => {
-          const d = new Date();
-          d.setDate(d.getDate() + numVal);
-          return d.toISOString().split('T')[0];
-        })();
-
-        return {
-          query: `${dateColumn} BETWEEN :${key}_start AND :${key}_end`,
-          params: {
-            [`${key}_start`]: today,
-            [`${key}_end`]: nextN,
-          },
-        };
-      }
-
-      default:
-        throw new BadRequestException(`Unsupported operator for date: ${op}`);
-    }
-  }
-
-  private buildSelectCondition(
-    attr: string,
-    op: string,
-    val: any,
-    key: string,
-  ) {
-    switch (op) {
-      case 'equal':
-        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
-      case 'not_equal':
-        return { query: `e.${attr} != :${key}`, params: { [key]: val } };
-      case 'empty':
-        return { query: `e.${attr} IS NULL`, params: {} };
-      case 'not_empty':
-        return { query: `e.${attr} IS NOT NULL`, params: {} };
-      default:
-        throw new BadRequestException(`Unsupported operator for select: ${op}`);
-    }
-  }
-
-  private buildMultiSelectCondition(
-    attr: string,
-    op: string,
-    val: any,
-    key: string,
-  ) {
-    let arr: string[] = [];
-
-    // SAFETY: Convert all to array
-    if (Array.isArray(val)) {
-      arr = val.map((v) => String(v));
-    } else if (typeof val === 'string') {
-      arr = val.split(',').map((v) => v.trim());
-    } else {
-      throw new BadRequestException(`Invalid multiselect value`);
-    }
-
-    if (arr.length === 0) {
-      return { query: '1=1', params: {} };
-    }
-
-    if (op === 'equal') {
-      return {
-        query: `e.${attr}::text IN (:...${key})`,
-        params: { [key]: arr },
-      };
-    }
-
-    if (op === 'not_equal') {
-      return {
-        query: `e.${attr}::text NOT IN (:...${key})`,
-        params: { [key]: arr },
-      };
-    }
-
-    if (op === 'contains') {
-      return {
-        query: `e.${attr}::text LIKE :${key}`,
-        params: { [key]: `%${val}%` },
-      };
-    }
-
-    if (op === 'not_contains') {
-      return {
-        query: `e.${attr}::text NOT LIKE :${key}`,
-        params: { [key]: `%${val}%` },
-      };
-    }
-
-    if (op === 'empty') return { query: `e.${attr} IS NULL`, params: {} };
-    if (op === 'not_empty')
-      return { query: `e.${attr} IS NOT NULL`, params: {} };
-
-    throw new BadRequestException(`Unsupported operator: ${op}`);
-  }
-
-  private buildYearCondition(attr: string, op: string, val: any, key: string) {
-    switch (op) {
-      case 'equal':
-        return {
-          query: `e.${attr} = :${key}`,
-          params: { [key]: parseInt(val, 10) },
-        };
-      case 'not_equal':
-        return {
-          query: `e.${attr} != :${key}`,
-          params: { [key]: parseInt(val, 10) },
-        };
-      case 'greater_than':
-        return {
-          query: `e.${attr} > :${key}`,
-          params: { [key]: parseInt(val, 10) },
-        };
-      case 'less_than':
-        return {
-          query: `e.${attr} < :${key}`,
-          params: { [key]: parseInt(val, 10) },
-        };
-      default:
-        throw new BadRequestException(`Unsupported operator for year: ${op}`);
-    }
-  }
-
-  async queryWithSchema(sql: string, params: any[] = []) {
-    await this.entityManager.query('BEGIN');
-    await this.entityManager.query(`SET LOCAL search_path TO ${this.schema}`);
-    const result = await this.entityManager.query(sql, params);
-    await this.entityManager.query('COMMIT');
-    return result;
-  }
-}
+import {
+  BadRequestException,
+  forwardRef,
+  Inject,
+  Injectable,
+} from '@nestjs/common';
+import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
+import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
+import { FilterCondition, FilterRequestDto } from '../dto/filter-request.dto';
+import { SavedFilterService } from './saved-filter.service';
+
+import * as moment from 'moment';
+import { EntityRelationService } from 'src/module/meta/service/entity-relation.service';
+import { ResolverService } from 'src/module/meta/service/resolver.service';
+import { LoggingService } from 'src/utils/service/loggingUtil.service';
+import { ConfigService } from '@nestjs/config';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
+import { EntityManager } from 'typeorm';
+import { FlatjsonFilterService } from './flatjson-filter.service';
+
+@Injectable()
+export class FilterService {
+  constructor(
+    private entityManager: EntityManager,
+    @Inject(forwardRef(() => AttributeMasterService))
+    private readonly attributeMasterService: AttributeMasterService,
+    @Inject(forwardRef(() => EntityMasterService))
+    private readonly entityMasterService: EntityMasterService,
+    @Inject('EntityRelationService')
+    private readonly entityRelationService: EntityRelationService,
+    @Inject('SavedFilterService')
+    private readonly savedFilterService: SavedFilterService,
+    @Inject(forwardRef(() => ResolverService))
+    private readonly resolverService: ResolverService,
+    @Inject(forwardRef(() => LoggingService))
+    protected readonly loggingService: LoggingService,
+    private readonly configService: ConfigService,
+    @Inject(forwardRef(() => ReflectionHelper))
+    private readonly reflectionHelper: ReflectionHelper,
+    @Inject(forwardRef(() => FlatjsonFilterService))
+    private readonly flatjsonFilterService: FlatjsonFilterService,
+  ) {}
+
+  schema = this.configService.get('DB_SCHEMA');
+
+  private async gettab_value_counts(
+    tableName: string,
+    column: string | undefined,
+    whereClauses: { query: string; params: Record<string, any> }[],
+  ) {
+    if (!column) return [];
+
+    // let whereSQL = '';
+    // const values: any[] = [];
+    // let paramIndex = 1; // PostgreSQL placeholders start at $1
+
+    // if (whereClauses.length > 0) {
+    //   const clauseParts = whereClauses.map((clause) => {
+    //     let parsedQuery = clause.query.replace(/\be\./g, ''); // remove e.
+
+    //     Object.entries(clause.params).forEach(([key, val]) => {
+    //       if (Array.isArray(val)) {
+    //         // Create ($1,$2,$3)
+    //         const placeholders = val.map(() => `$${paramIndex++}`).join(', ');
+
+    //         parsedQuery = parsedQuery.replace(
+    //           new RegExp(`:${key}`, 'g'),
+    //           `(${placeholders})`,
+    //         );
+
+    //         values.push(...val.map((v) => String(v)));
+    //       } else {
+    //         // Create $1
+    //         const placeholder = `$${paramIndex++}`;
+
+    //         parsedQuery = parsedQuery.replace(
+    //           new RegExp(`:${key}`, 'g'),
+    //           placeholder,
+    //         );
+
+    //         values.push(String(val));
+    //       }
+    //     });
+
+    //     return parsedQuery;
+    //   });
+
+    //   whereSQL = `WHERE ${clauseParts.join(' AND ')}`;
+    // }
+
+    let whereSQL = '';
+    const values: any[] = [];
+    let paramIndex = 1;
+
+    if (whereClauses.length > 0) {
+      const clauseParts = whereClauses.map((clause) => {
+        let parsedQuery = clause.query.replace(/\be\./g, '');
+
+        Object.entries(clause.params).forEach(([key, val]) => {
+          if (Array.isArray(val)) {
+            // Create ($1,$2,$3)
+            const placeholders = val.map(() => `$${paramIndex++}`).join(', ');
+
+            parsedQuery = parsedQuery
+              .replace(new RegExp(`:...${key}`, 'g'), `(${placeholders})`)
+              .replace(new RegExp(`:${key}`, 'g'), `(${placeholders})`);
+
+            values.push(...val.map((v) => String(v)));
+          } else {
+            // Create $1
+            const placeholder = `$${paramIndex++}`;
+
+            parsedQuery = parsedQuery
+              .replace(new RegExp(`:...${key}`, 'g'), placeholder)
+              .replace(new RegExp(`:${key}`, 'g'), placeholder);
+
+            values.push(String(val));
+          }
+        });
+
+        return parsedQuery;
+      });
+
+      whereSQL = `WHERE ${clauseParts.join(' AND ')}`;
+    }
+
+    const rawSQL = `
+        SELECT ${column} AS tab_value, COUNT(*) AS tab_value_count
+        FROM ${this.schema}.${tableName} ${whereSQL}
+        GROUP BY ${column}
+    `;
+
+    const rows = await this.entityManager.query(rawSQL, values);
+
+    const total = rows.reduce(
+      (sum, r) => sum + parseInt(r.tab_value_count, 10),
+      0,
+    );
+
+    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),
+      })),
+    ];
+  }
+
+  /**
+   * Route to flatjson or traditional filtering based on configuration
+   */
+  async applyFilterWithRouting(dto: FilterRequestDto) {
+    // Check if flatjson filtering is enabled via config or query param
+    const useFlatjson = dto.queryParams?.use_flatjson === 'true';
+
+    if (useFlatjson) {
+      await this.loggingService.log(
+        'info',
+        'FilterService',
+        'applyFilterWithRouting',
+        `Using FLATJSON filtering for ${dto.entity_type}`,
+      );
+
+      // Use new flatjson filtering service
+      const result = await this.flatjsonFilterService.applyFlatjsonFilter(dto);
+
+      // Transform to match existing response format
+      return {
+        success: true,
+        data: {
+          entity_tabs: result.tabCounts || [],
+          entity_list: result.data,
+          pagination: {
+            total: result.total,
+            page: result.page,
+            size: result.size,
+            totalPages: result.totalPages,
+          },
+        },
+      };
+    } else {
+      await this.loggingService.log(
+        'info',
+        'FilterService',
+        'applyFilterWithRouting',
+        `Using TRADITIONAL filtering for ${dto.entity_type}`,
+      );
+
+      // Use traditional filtering
+      return this.applyFilterWrapper(dto);
+    }
+  }
+
+  async applyFilterWrapper(dto: FilterRequestDto) {
+    const {
+      entity_type,
+      quickFilter = [],
+      savedFilterCode,
+      attributeFilter = [],
+      loggedInUser,
+    } = dto;
+
+    // 🔹 Step 1: Collect all filters (from body + savedFilter)
+    const savedFilters = await this.getSavedFilters(
+      savedFilterCode ?? undefined,
+    );
+    const allFilters = [
+      ...quickFilter,
+      ...attributeFilter,
+      ...savedFilters,
+    ].filter((f) => f.filter_value !== '');
+
+    // 🔹 Step 2: Group filters by filter_entity_type
+    const grouped = allFilters.reduce(
+      (acc, f) => {
+        if (!acc[f.filter_entity_type]) acc[f.filter_entity_type] = [];
+        acc[f.filter_entity_type].push(f);
+        return acc;
+      },
+      {} as Record<string, any[]>,
+    );
+
+    console.log('🟠 [FilterService] Grouped filters by entity type:', grouped);
+
+    // 🔹 Step 3: Handle sub-entities first
+    let intersectionIds: number[] | null = null;
+    for (const [subEntityType, filters] of Object.entries(grouped)) {
+      if (subEntityType === entity_type) continue; // skip main entity for now
+
+      let { queryParams, tabs, ...newDto } = dto;
+
+      const subDto: FilterRequestDto = {
+        ...newDto,
+        entity_type: subEntityType,
+        quickFilter: filters as FilterCondition[],
+        savedFilterCode: null, // already merged
+        attributeFilter: [],
+      };
+
+      const subResult = await this.applyFilter(subDto);
+      const subEntityIds = subResult.data.entity_list.map((row) => row.id);
+
+      console.log(
+        `🧩 [FilterService] Sub-entity ${subEntityType} returned IDs:`,
+        subEntityIds,
+      );
+
+      if (!subEntityIds.length) {
+        console.log(
+          `ℹ️ [FilterService] No records for sub-entity ${subEntityType}, returning empty result`,
+        );
+        return {
+          success: true,
+          data: { entity_tabs: [], entity_list: [], pagination: {} },
+        };
+      }
+
+      const relatedIds = await this.entityRelationService.getRelatedEntityIds(
+        entity_type,
+        subEntityType,
+        subEntityIds,
+        dto.loggedInUser.enterprise_id,
+      );
+
+      intersectionIds =
+        intersectionIds === null
+          ? relatedIds
+          : intersectionIds.filter((id) => relatedIds.includes(id));
+
+      if (intersectionIds.length === 0) {
+        console.log(
+          '🚫 [FilterService] No intersection IDs left, returning empty result',
+        );
+        return {
+          success: true,
+          data: { entity_tabs: [], entity_list: [], pagination: {} },
+        };
+      }
+    }
+
+    // 🔹 Step 4: Call applyFilter for main entity
+    const mainFilters = grouped[entity_type] || [];
+    const mainDto: FilterRequestDto = {
+      ...dto,
+      quickFilter: [...mainFilters],
+      savedFilterCode: null,
+      attributeFilter: [],
+    };
+
+    if (intersectionIds && intersectionIds.length > 0) {
+      (mainDto.quickFilter ??= []).push({
+        filter_attribute: 'id',
+        filter_operator: 'equal',
+        filter_value: intersectionIds,
+        filter_entity_type: entity_type,
+      });
+    }
+
+    return await this.applyFilter(mainDto);
+  }
+
+  async applyFilter(dto: FilterRequestDto) {
+    const {
+      entity_type,
+      quickFilter,
+      savedFilterCode,
+      attributeFilter,
+      tabs,
+      sortby,
+      loggedInUser,
+      queryParams,
+      customLevelType,
+      customLevelId,
+      customAppCode,
+    } = dto;
+
+    // abstract user details
+    const {
+      level_type,
+      level_id,
+      id: user_id,
+      appcode,
+      organization_id,
+      enterprise_id,
+    } = loggedInUser || {};
+
+    // Fetch meta from entity table service
+    const entityMeta = await this.entityMasterService.getEntityData(
+      entity_type,
+      loggedInUser,
+    );
+    const tableName = entityMeta?.data_source; // data_source is the table name
+
+    if (!tableName) {
+      console.error(`❌ [FilterService] Invalid entity_type: ${entity_type}`);
+      throw new BadRequestException(`Invalid entity_type: ${entity_type}`);
+    }
+
+    const getAttributeColumnMeta =
+      await this.attributeMasterService.findAttributesByMappedEntityType(
+        entity_type,
+        loggedInUser,
+      );
+
+    const attributeMetaMap = getAttributeColumnMeta.reduce(
+      (acc, attr) => {
+        acc[attr.attribute_key] = attr;
+        return acc;
+      },
+      {} as Record<string, any>,
+    );
+
+    // Get and parse saved filters
+    const savedFilters = await this.getSavedFilters(
+      savedFilterCode ?? undefined,
+    );
+    const savedFiltersNormalized = savedFilters.map((f) => ({
+      filter_attribute: f.filter_attribute,
+      filter_operator: f.filter_operator,
+      filter_value: f.filter_value,
+    }));
+
+    const baseFilters = [
+      ...(quickFilter || []).filter(
+        (f) => f.filter_value != null && f.filter_value !== '',
+      ),
+      ...savedFiltersNormalized.filter(
+        (f) => f.filter_value != null && f.filter_value !== '',
+      ),
+      ...(attributeFilter || []).filter(
+        (f) => f.filter_value != null && f.filter_value !== '',
+      ),
+    ];
+
+    // 🧱 Build where clausesx
+    const baseWhere = this.buildWhereClauses(baseFilters, attributeMetaMap);
+
+    // Handle TEMPLATE entity special condition
+    if (entity_type === 'TEMP' || entity_type === 'TEM') {
+      if (level_type === 'ORG') {
+        baseWhere.push({
+          query: `  ((e.level_type = 'ORG' AND e.level_id = '${loggedInUser.enterprise_id}'))`,
+          params: {},
+        });
+      } else if (level_type === 'SCH') {
+        baseWhere.push({
+          query: `
+        (
+          (e.level_type = 'SCH' AND e.level_id = '${loggedInUser.level_id}')
+          OR 
+          (
+            e.level_type = 'ORG'
+            AND e.level_id = '${loggedInUser.enterprise_id}'
+            AND e.enterprise_id = '${loggedInUser.enterprise_id}'
+            AND e.code NOT IN (
+              SELECT sub.code 
+              FROM ${this.schema}.frm_wf_comm_template AS sub 
+              WHERE sub.level_type = 'SCH' AND sub.level_id = '${loggedInUser.level_id}'
+            )
+          )
+        )
+      `,
+          params: {},
+        });
+      }
+    }
+
+    // Default org/level clause — skip Tsaved-filEMPLATE entity
+    if (
+      entity_type !== 'ORGP' &&
+      entity_type !== 'TEMP' &&
+      entity_type !== 'TEM' && // ✅ skip TEMPLATE
+      entity_type !== 'SCH' &&
+      level_type &&
+      level_id &&
+      organization_id &&
+      !customLevelType &&
+      !customLevelId
+    ) {
+      baseWhere.push({
+        query: 'e.level_type = :level_type AND e.level_id = :level_id',
+        params: {
+          level_type,
+          level_id,
+        },
+      });
+    }
+
+    if (entity_type == 'USR' || entity_type == 'UPR') {
+      baseWhere.push({
+        query: 'e.is_customer is NULL',
+        params: {},
+      });
+    }
+
+    if (customLevelType && customLevelId && customAppCode) {
+      baseWhere.push({
+        query:
+          'e.level_type = :customLevelType AND e.level_id = :customLevelId AND e.appcode = :customAppCode',
+        params: {
+          customLevelType,
+          customLevelId: String(customLevelId),
+          customAppCode,
+        },
+      });
+    }
+
+    // Handle queryParams filters
+    if (queryParams) {
+      Object.entries(queryParams).forEach(([key, value]) => {
+        if (!value) return;
+
+        // Always convert to string
+        const strValue = String(value);
+
+        if (key === 'attributeName' && queryParams['attributeValue']) {
+          const attrName = strValue;
+          const attrValue = String(queryParams['attributeValue']);
+
+          baseWhere.push({
+            query: `e.${attrName} = :${attrName}`,
+            params: { [attrName]: attrValue }, // <-- string
+          });
+        } else if (key !== 'attributeValue') {
+          baseWhere.push({
+            query: `e.${key} = :${key}`,
+            params: { [key]: strValue }, // <-- string
+          });
+        }
+      });
+    }
+
+    console.log('🟠 [FilterService] Constructed baseWhere clauses:', baseWhere);
+
+    let layoutPreferenceRepo =
+      this.reflectionHelper.getRepoService('LayoutPreference');
+
+    const layoutPreference = await layoutPreferenceRepo.findOne({
+      where: {
+        user_id: user_id,
+        mapped_entity_type: entity_type,
+        mapped_level_id: level_id,
+        mapped_level_type: level_type,
+        type: 'layout',
+      },
+    });
+
+    // Extract layout preference
+    const layout = layoutPreference?.mapped_json?.quick_tab || {};
+    const showList =
+      layout?.show_list?.map((val) => {
+        if (typeof val === 'string') {
+          // legacy case — old format like ['Active', 'Inactive']
+          return val.toLowerCase();
+        }
+
+        if (val && typeof val === 'object' && val.value !== undefined) {
+          // new format — [{ label: 'Active', value: '13023' }]
+          return String(val.value).toLowerCase();
+        }
+
+        return ''; // fallback safety
+      }) || [];
+
+    let filteredTabs = await this.getFilteredTabs(
+      layout,
+      showList,
+      entityMeta,
+      baseWhere,
+      tabs,
+      loggedInUser,
+    );
+
+    const dataWhere = [...baseWhere];
+
+    // if (tabs?.columnName && tabs?.value) {
+    //   const tabAttrMeta = attributeMetaMap[tabs.columnName];
+    //   const tabValue = tabs.value.toLowerCase();
+
+    //   if (tabValue === 'others') {
+    //     // Extract 'value' (IDs) from showList, ignore 'all'
+    //     const valuesToExclude = showList
+    //       .filter((v) => v.label.toLowerCase() !== 'all')
+    //       .map((v) => v.value);
+
+    //     if (valuesToExclude.length > 0) {
+    //       for (const value of valuesToExclude) {
+    //         const resolvedId = await this.resolverService.getResolvedId(
+    //           loggedInUser,
+    //           tabs.columnName,
+    //           value,
+    //           entity_type,
+    //         );
+    //         if (resolvedId) {
+    //           const tabCondition = this.buildCondition(
+    //             {
+    //               filter_attribute: tabs.columnName,
+    //               filter_operator: 'not_equal',
+    //               filter_value: [resolvedId],
+    //               skip_id: true,
+    //             },
+    //             tabAttrMeta,
+    //           );
+    //           if (tabCondition) dataWhere.push(tabCondition);
+    //         }
+    //       }
+    //     }
+    //   } else if (tabValue !== 'all') {
+    //     const resolvedId = await this.resolverService.getResolvedId(
+    //       loggedInUser,
+    //       tabs.columnName,
+    //       tabs.value,
+    //       entity_type,
+    //     );
+
+    //     if (resolvedId) {
+    //       const tabCondition = this.buildCondition(
+    //         {
+    //           filter_attribute: tabs.columnName,
+    //           filter_operator: 'equal',
+    //           filter_value: [resolvedId],
+    //           skip_id: true,
+    //         },
+    //         tabAttrMeta,
+    //       );
+    //       if (tabCondition) dataWhere.push(tabCondition);
+    //     }
+    //   }
+    // }
+
+    let qb = this.entityManager
+      .createQueryBuilder()
+      .select('e.*')
+      .from(`${this.schema}.${tableName}`, 'e');
+    dataWhere.forEach((clause) => qb.andWhere(clause.query, clause.params));
+
+    // Apply sorting
+    qb = await this.sortTabsByShowList(qb, sortby, layoutPreference, tabs);
+    const page = dto.page && dto.page > 0 ? dto.page : 1;
+    const size = dto.size && dto.size > 0 ? dto.size : 10;
+    if (dto.page && dto.size) {
+      qb.skip((page - 1) * size).take(size);
+    }
+
+    let query = await qb.getQuery();
+
+    console.log('------------------------------------------------------\n');
+    console.log(query);
+    console.log('\n------------------------------------------------------');
+    const entity_list = await qb.getRawMany();
+
+    console.log(`📦 [FilterService] Fetched ${entity_list.length} records`);
+
+    const dateAttributes = Object.entries(attributeMetaMap)
+      .filter(([_, attr]) => attr.data_type === 'date')
+      .map(([key]) => key);
+
+    const formatDate = (dateStr: string | null): string | null =>
+      dateStr ? moment(dateStr).format('DD-MM-YYYY') : '';
+
+    const formatDatesInRow = (row: any): any => {
+      const formattedRow = { ...row };
+      for (const key of dateAttributes) {
+        if (formattedRow[key])
+          formattedRow[key] = formatDate(formattedRow[key]);
+      }
+      return formattedRow;
+    };
+
+    const formattedEntityList = entity_list.map(formatDatesInRow);
+
+    // const resolvedEntityList = await Promise.all(
+    //   formattedEntityList.map((row) =>
+    //     this.resolverService.getResolvedData(loggedInUser, row, entity_type),
+    //   ),
+    // );
+
+    const resolvedTabs = await Promise.all(
+      filteredTabs.map(async (tab) => {
+        const tabAttrKey = layout?.attribute || tabs?.columnName;
+
+        if (
+          !tabAttrKey ||
+          tab.tab_value?.toLowerCase() === 'all' ||
+          tab.tab_value?.toLowerCase() === 'others'
+        ) {
+          return tab;
+        }
+
+        // const resolvedVal = await this.resolverService.getResolvedValue(
+        //   loggedInUser,
+        //   tabAttrKey,
+        //   tab.tab_value,
+        //   entity_type,
+        // );
+
+        return { ...tab, tab_value: tab.tab_value ?? tab.tab_value };
+      }),
+    );
+
+    const countQb = this.entityManager
+      .createQueryBuilder()
+      .select('COUNT(*)', 'count')
+      .from(`${this.schema}.${tableName}`, 'e');
+    dataWhere.forEach((clause) =>
+      countQb.andWhere(clause.query, clause.params),
+    );
+    const countResult = await countQb.getRawOne();
+    const total = parseInt(countResult.count, 10);
+
+    console.log('📊 [FilterService] Returning final result with total:', total);
+
+    return {
+      success: true,
+      data: {
+        entity_tabs: resolvedTabs,
+        entity_list: formattedEntityList,
+        pagination: {
+          total,
+          page,
+          size,
+          totalPages: Math.ceil(total / size),
+          hasNextPage: page * size < total,
+          hasPreviousPage: page > 1,
+        },
+      },
+    };
+  }
+
+  // GET FILTERED TABS LOGIC
+  private async getFilteredTabs(
+    layout: any,
+    showList: any,
+    entityMeta: any,
+    baseWhere: any,
+    tabs: any,
+    loggedInUser: any,
+  ) {
+    let allTabs;
+    if (layout.attribute) {
+      allTabs = await this.gettab_value_counts(
+        entityMeta?.data_source,
+        layout.attribute,
+        baseWhere,
+      );
+    } else {
+      allTabs = await this.gettab_value_counts(
+        entityMeta?.data_source,
+        tabs?.columnName,
+        baseWhere,
+      );
+    }
+
+    let filteredTabs: any[] = [];
+
+    if (showList?.length > 0) {
+      // Extract tab IDs (values)
+      const showValues = (showList || []).map((item) => {
+        const val = typeof item === 'object' ? item.value : item;
+        return val ? String(val).toLowerCase() : '';
+      });
+
+      // Handle "all" logic
+      const isAllNeeded = layout?.isAllSelected && !showValues.includes('all');
+      if (isAllNeeded) {
+        showList.push({ label: 'All', value: 'all' });
+        showValues.push('all');
+      }
+
+      // Filter by value IDs (not labels)
+      filteredTabs = allTabs.filter((tab) => {
+        const tabValueStr = tab.tab_value
+          ? String(tab.tab_value).toLowerCase()
+          : '';
+        return showValues.includes(tabValueStr);
+      });
+
+      // Handle "all" tab
+      const allTab = filteredTabs.find(
+        (tab) => tab.tab_value?.toString().toLowerCase() === 'all',
+      );
+      filteredTabs = filteredTabs.filter(
+        (tab) => tab.tab_value?.toString().toLowerCase() !== 'all',
+      );
+
+      // SORTING LOGIC
+      if (layout.sorting === 'asc') {
+        filteredTabs.sort((a, b) =>
+          a.tab_value.toString().localeCompare(b.tab_value.toString()),
+        );
+      } else if (layout.sorting === 'dsc') {
+        filteredTabs.sort((a, b) =>
+          b.tab_value.toString().localeCompare(a.tab_value.toString()),
+        );
+      } else if (layout.sorting === 'count_asc') {
+        filteredTabs.sort((a, b) => a.tab_value_count - b.tab_value_count);
+      } else if (layout.sorting === 'count_dsc') {
+        filteredTabs.sort((a, b) => b.tab_value_count - a.tab_value_count);
+      } else if (layout.sorting === 'custom') {
+        // Keep order same as showList
+        const orderMap = new Map<string, number>(
+          showList.map((item, index) => [
+            item.value?.toString().toLowerCase(),
+            index,
+          ]),
+        );
+        filteredTabs.sort((a, b) => {
+          const aIndex =
+            orderMap.get(a.tab_value?.toString().toLowerCase()) ?? Infinity;
+          const bIndex =
+            orderMap.get(b.tab_value?.toString().toLowerCase()) ?? Infinity;
+          return aIndex - bIndex;
+        });
+      }
+
+      // Re-add "all" tab at beginning if needed
+      if (allTab) filteredTabs.unshift(allTab);
+
+      // Combine others if enabled
+      if (layout?.isCombineOther) {
+        const originalAllTab = allTabs.find(
+          (tab) => tab.tab_value?.toString().toLowerCase() === 'all',
+        );
+        const allCount = originalAllTab?.tab_value_count ?? 0;
+        const knownTabCountSum = filteredTabs
+          .filter((tab) => tab.tab_value?.toString().toLowerCase() !== 'all')
+          .reduce((acc, tab) => acc + tab.tab_value_count, 0);
+
+        const othersCount = allCount - knownTabCountSum;
+        filteredTabs.push({
+          tab_value: 'OTHERS',
+          tab_value_count: othersCount < 0 ? 0 : othersCount,
+        });
+      }
+    } else {
+      filteredTabs = allTabs;
+    }
+
+    return filteredTabs;
+  }
+
+  // SORTING LOGIC FOR TABS
+  private async sortTabsByShowList(
+    qb: any,
+    sortby: any,
+    layoutPreference: any,
+    tabs: any,
+  ) {
+    const sorting = layoutPreference?.mapped_json?.sorting;
+
+    if (sorting) {
+      if (Array.isArray(sorting?.tabs)) {
+        const preferenceTabArray = sorting?.tabs;
+        const tabFilter = preferenceTabArray.find(
+          (tabData) => tabData.tab_name?.value === tabs?.value,
+        );
+
+        tabFilter?.sortby?.forEach(({ column, order }) => {
+          qb.addOrderBy(
+            `e.${column}`,
+            order?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC',
+          );
+        });
+      } else if (Array.isArray(sorting.sortby)) {
+        sorting?.sortby?.forEach(({ column, order }) => {
+          qb.addOrderBy(
+            `e.${column}`,
+            order?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC',
+          );
+        });
+      }
+    }
+
+    if (Array.isArray(sortby) && sortby.length > 0) {
+      sortby.forEach(({ sortColum, sortType }) => {
+        if (sortColum) {
+          qb.addOrderBy(
+            `e.${sortColum}`,
+            sortType?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC',
+          );
+        }
+      });
+    } else {
+      // fallback if no explicit sortby sent
+      qb.addOrderBy('e.created_date', 'DESC');
+    }
+
+    return qb;
+  }
+
+  private parseFilters(raw: any, isSingle = false): any[] {
+    if (!raw) return [];
+
+    if (typeof raw === 'string') {
+      try {
+        const parsed = JSON.parse(raw);
+        return isSingle ? [parsed] : parsed;
+      } catch {
+        throw new BadRequestException('Invalid JSON in filter input');
+      }
+    }
+
+    return isSingle ? [raw] : Array.isArray(raw) ? raw : [];
+  }
+
+  private async getSavedFilters(code?: string): Promise<any[]> {
+    if (!code) return [];
+
+    const savedFilter = await this.savedFilterService.getDetailsByCode(code);
+    if (!savedFilter) {
+      throw new BadRequestException(`Saved filter not found for code: ${code}`);
+    }
+    return savedFilter;
+  }
+
+  private buildWhereClauses(
+    filters: any[],
+    attributeMeta: Record<string, any>,
+  ) {
+    return filters
+      .map((f) => {
+        const clause = this.buildCondition(
+          f,
+          attributeMeta[f.filter_attribute],
+        );
+
+        if (!clause) return null;
+
+        // Force every param to be a string
+        if (clause.params) {
+          Object.keys(clause.params).forEach((k) => {
+            const val = clause.params[k];
+            if (!Array.isArray(val)) {
+              clause.params[k] = String(val); // only convert scalar values
+            }
+          });
+        }
+
+        return clause;
+      })
+      .filter(
+        (clause): clause is { query: string; params: Record<string, string> } =>
+          clause !== null,
+      );
+  }
+
+  private buildCondition(
+    filter: any,
+    meta: any,
+  ): { query: string; params: any } | null {
+    if (!meta) return null;
+
+    let attr = filter.filter_attribute;
+    const val = filter.filter_value;
+    const op = filter.filter_operator;
+    const key = `param_${attr}_${Math.random().toString(36).substring(2, 8)}`;
+
+    // if (
+    //   (meta.data_source_type === 'entity' ||
+    //     meta.data_source_type === 'master') &&
+    //   !filter.skip_id
+    // ) {
+    //   attr = `${attr}_id`;
+    // }
+
+    switch (meta.data_type) {
+      case 'text':
+        return this.buildTextCondition(attr, op, val, key);
+      case 'number':
+        return this.buildNumberCondition(attr, op, val, key);
+      case 'date':
+        return this.buildDateCondition(attr, op, val, key);
+      case 'select':
+        return this.buildMultiSelectCondition(attr, op, val, key);
+      case 'multiselect':
+        return this.buildMultiSelectCondition(attr, op, val, key);
+      case 'checkbox':
+        return this.buildMultiSelectCondition(attr, op, val, key);
+      case 'radio':
+        return this.buildMultiSelectCondition(attr, op, val, key);
+      case 'year':
+        return this.buildYearCondition(attr, op, val, key);
+      default:
+        return null;
+    }
+  }
+
+  private buildTextCondition(attr: string, op: string, val: any, key: string) {
+    switch (op) {
+      case 'contains':
+        return {
+          query: `LOWER(e.${attr}) LIKE :${key}`,
+          params: { [key]: `%${val ? val.toLowerCase() : ''}%` },
+        };
+      case 'equal':
+        return {
+          query: `e.${attr} = :${key}`,
+          params: { [key]: val },
+        };
+      case 'not_equal':
+        return {
+          query: `e.${attr} != :${key}`,
+          params: { [key]: val },
+        };
+      case 'empty':
+        return {
+          query: `e.${attr} IS NULL`,
+          params: {},
+        };
+      case 'not_empty':
+        return {
+          query: `e.${attr} IS NOT NULL`,
+          params: {},
+        };
+      default:
+        throw new BadRequestException(`Unsupported operator for text: ${op}`);
+    }
+  }
+
+  private buildNumberCondition(
+    attr: string,
+    op: string,
+    val: any,
+    key: string,
+  ) {
+    switch (op) {
+      case 'equal':
+        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
+      case 'not_equal':
+        return { query: `e.${attr} != :${key}`, params: { [key]: val } };
+      case 'greater_than':
+        return { query: `e.${attr} > :${key}`, params: { [key]: val } };
+      case 'less_than':
+        return { query: `e.${attr} < :${key}`, params: { [key]: val } };
+      case 'less_than_qual_to':
+        return { query: `e.${attr} <= :${key}`, params: { [key]: val } };
+      case 'greater_than_qual_to':
+        return { query: `e.${attr} >= :${key}`, params: { [key]: val } };
+      case 'empty':
+        return { query: `e.${attr} IS NULL`, params: {} };
+      case 'not_empty':
+        return { query: `e.${attr} IS NOT NULL`, params: {} };
+
+      default:
+        throw new BadRequestException(`Unsupported operator for number: ${op}`);
+    }
+  }
+
+  private buildDateCondition(attr: string, op: string, val: any, key: string) {
+    const dateColumn = `DATE(e.${attr})`;
+    const monthColumn = `DATE_TRUNC('month', e.${attr})`;
+
+    // convert to number when needed
+    const numVal = Number(val);
+
+    // INSIDE buildDateCondition
+    const subtractBusinessDays = (days: number): string => {
+      let d = new Date();
+      let count = 0;
+
+      while (count < days) {
+        d.setDate(d.getDate() - 1);
+
+        const day = d.getDay(); // 0 = Sunday, 6 = Saturday
+
+        if (day !== 0 && day !== 6) {
+          count++;
+        }
+      }
+
+      return d.toISOString().split('T')[0];
+    };
+
+    switch (op) {
+      // ============================================
+      // BASIC COMPARISONS
+      // ============================================
+      case 'equal':
+      case 'is':
+        return {
+          query: `${dateColumn} = :${key}`,
+          params: { [key]: val },
+        };
+
+      case 'before':
+      case 'is_before':
+        return {
+          query: `${dateColumn} < :${key}`,
+          params: { [key]: val },
+        };
+
+      case 'after':
+      case 'is_after':
+        return {
+          query: `${dateColumn} > :${key}`,
+          params: { [key]: val },
+        };
+
+      case 'is_on_or_before':
+        return {
+          query: `${dateColumn} <= :${key}`,
+          params: { [key]: val },
+        };
+
+      case 'is_on_or_after':
+        return {
+          query: `${dateColumn} >= :${key}`,
+          params: { [key]: val },
+        };
+
+      // ============================================
+      // EMPTY / NOT EMPTY
+      // ============================================
+      case 'empty':
+        return {
+          query: `e.${attr} IS NULL`,
+          params: {},
+        };
+
+      case 'not_empty':
+        return {
+          query: `e.${attr} IS NOT NULL`,
+          params: {},
+        };
+
+      // ============================================
+      // DAY OFFSET LOGIC (ALWAYS ADJUST -1 DAY)
+      // ============================================
+      case 'is_day_before':
+        if (isNaN(numVal)) {
+          throw new BadRequestException(
+            'Value must be a number for is_day_before',
+          );
+        }
+
+        const dayBefore = (() => {
+          const d = new Date();
+          d.setDate(d.getDate() - numVal);
+
+          // Format as YYYY-MM-DD in IST
+          return d.toLocaleDateString('en-CA', { timeZone: 'Asia/Kolkata' });
+        })();
+
+        return {
+          query: `${dateColumn} <= :${key}`,
+          params: { [key]: dayBefore },
+        };
+
+      case 'is_day_after':
+        if (isNaN(numVal)) {
+          throw new BadRequestException(
+            'Value must be a number for is_day_after',
+          );
+        }
+
+        const dayAfter = (() => {
+          const d = new Date();
+          d.setDate(d.getDate() - 1 + numVal); // -1 because DB stores previous day
+          return d.toISOString().split('T')[0];
+        })();
+
+        return {
+          query: `${dateColumn} > :${key}`,
+          params: { [key]: dayAfter },
+        };
+
+      // ============================================
+      // MONTH OFFSET LOGIC
+      // ============================================
+      case 'is_month_before':
+        if (isNaN(numVal)) {
+          throw new BadRequestException(
+            'Value must be a number for is_month_before',
+          );
+        }
+
+        const monthBefore = (() => {
+          const d = new Date();
+          d.setMonth(d.getMonth() - numVal);
+          d.setDate(1);
+          d.setDate(d.getDate() - 1);
+          return d.toISOString().split('T')[0];
+        })();
+
+        return {
+          query: `${monthColumn} < DATE_TRUNC('month', (:${key})::date)`,
+          params: { [key]: monthBefore },
+        };
+
+      case 'is_month_after':
+        if (isNaN(numVal)) {
+          throw new BadRequestException(
+            'Value must be a number for is_month_after',
+          );
+        }
+
+        const monthAfter = (() => {
+          const d = new Date();
+          d.setMonth(d.getMonth() + numVal);
+          d.setDate(1);
+          d.setDate(d.getDate() - 1);
+          return d.toISOString().split('T')[0];
+        })();
+
+        return {
+          query: `${monthColumn} > DATE_TRUNC('month', (:${key})::date)`,
+          params: { [key]: monthAfter },
+        };
+
+      // ===== BETWEEN =====
+      case 'between': {
+        if (typeof val === 'string') {
+          val = val.split(',').map((v) => v.trim());
+        }
+
+        if (
+          !Array.isArray(val) ||
+          val.length !== 2 ||
+          val[0] === '' ||
+          val[1] === ''
+        ) {
+          console.log(`Invalid value for between: ${val}`);
+          return null;
+        }
+
+        return {
+          query: `${dateColumn} BETWEEN :${key}_start AND :${key}_end`,
+          params: {
+            [`${key}_start`]: val[0],
+            [`${key}_end`]: val[1],
+          },
+        };
+      }
+
+      // ===== TODAY =====
+      case 'today': {
+        const today = moment().format('YYYY-MM-DD');
+        return {
+          query: `${dateColumn} = :today`,
+          params: { today },
+        };
+      }
+
+      // ============================================
+      // BUSINESS DAY OFFSET LOGIC (SKIPS WEEKENDS)
+      // ALWAYS ADJUST -1 DAY FOR DB SHIFT
+      // ============================================
+
+      case 'is_before_business_days': {
+        if (isNaN(numVal)) {
+          throw new BadRequestException('Value must be a number');
+        }
+
+        const targetDate = subtractBusinessDays(numVal);
+
+        return {
+          query: `${dateColumn} <= :${key} AND EXTRACT(DOW FROM ${dateColumn}) NOT IN (0, 6)`,
+          params: { [key]: targetDate },
+        };
+      }
+
+      case 'is_after_business_days': {
+        if (isNaN(numVal)) {
+          throw new BadRequestException(
+            'Value must be a number for is_after_business_days',
+          );
+        }
+
+        const businessAfter = (() => {
+          let d = new Date();
+          let count = 0;
+
+          while (count < numVal) {
+            d.setDate(d.getDate() + 1);
+            const day = d.getDay(); // 0=Sun, 6=Sat
+            if (day !== 0 && day !== 6) count++;
+          }
+
+          // DB shift -1 day
+          d.setDate(d.getDate() - 1);
+
+          return d.toISOString().split('T')[0];
+        })();
+
+        return {
+          query: `${dateColumn} > :${key}`,
+          params: { [key]: businessAfter },
+        };
+      }
+
+      // ============================================
+      // IN LAST DAY (range: today to N days before)
+      // ============================================
+      case 'in_last_day': {
+        if (isNaN(numVal)) {
+          throw new BadRequestException(
+            'Value must be a number for in_last_day',
+          );
+        }
+
+        const today = (() => {
+          const d = new Date();
+          return d.toISOString().split('T')[0];
+        })();
+
+        const lastN = (() => {
+          const d = new Date();
+          d.setDate(d.getDate() - numVal);
+          return d.toISOString().split('T')[0];
+        })();
+
+        return {
+          query: `${dateColumn} BETWEEN :${key}_start AND :${key}_end`,
+          params: {
+            [`${key}_start`]: lastN,
+            [`${key}_end`]: today,
+          },
+        };
+      }
+
+      // ============================================
+      // IN NEXT DAY (range: today to N days after)
+      // ============================================
+      case 'in_next_day': {
+        if (isNaN(numVal)) {
+          throw new BadRequestException(
+            'Value must be a number for in_next_day',
+          );
+        }
+
+        const today = (() => {
+          const d = new Date();
+          return d.toISOString().split('T')[0];
+        })();
+
+        const nextN = (() => {
+          const d = new Date();
+          d.setDate(d.getDate() + numVal);
+          return d.toISOString().split('T')[0];
+        })();
+
+        return {
+          query: `${dateColumn} BETWEEN :${key}_start AND :${key}_end`,
+          params: {
+            [`${key}_start`]: today,
+            [`${key}_end`]: nextN,
+          },
+        };
+      }
+
+      default:
+        throw new BadRequestException(`Unsupported operator for date: ${op}`);
+    }
+  }
+
+  private buildSelectCondition(
+    attr: string,
+    op: string,
+    val: any,
+    key: string,
+  ) {
+    switch (op) {
+      case 'equal':
+        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
+      case 'not_equal':
+        return { query: `e.${attr} != :${key}`, params: { [key]: val } };
+      case 'empty':
+        return { query: `e.${attr} IS NULL`, params: {} };
+      case 'not_empty':
+        return { query: `e.${attr} IS NOT NULL`, params: {} };
+      default:
+        throw new BadRequestException(`Unsupported operator for select: ${op}`);
+    }
+  }
+
+  private buildMultiSelectCondition(
+    attr: string,
+    op: string,
+    val: any,
+    key: string,
+  ) {
+    let arr: string[] = [];
+
+    // SAFETY: Convert all to array
+    if (Array.isArray(val)) {
+      arr = val.map((v) => String(v));
+    } else if (typeof val === 'string') {
+      arr = val.split(',').map((v) => v.trim());
+    } else {
+      throw new BadRequestException(`Invalid multiselect value`);
+    }
+
+    if (arr.length === 0) {
+      return { query: '1=1', params: {} };
+    }
+
+    if (op === 'equal') {
+      return {
+        query: `e.${attr}::text IN (:...${key})`,
+        params: { [key]: arr },
+      };
+    }
+
+    if (op === 'not_equal') {
+      return {
+        query: `e.${attr}::text NOT IN (:...${key})`,
+        params: { [key]: arr },
+      };
+    }
+
+    if (op === 'contains') {
+      return {
+        query: `e.${attr}::text LIKE :${key}`,
+        params: { [key]: `%${val}%` },
+      };
+    }
+
+    if (op === 'not_contains') {
+      return {
+        query: `e.${attr}::text NOT LIKE :${key}`,
+        params: { [key]: `%${val}%` },
+      };
+    }
+
+    if (op === 'empty') return { query: `e.${attr} IS NULL`, params: {} };
+    if (op === 'not_empty')
+      return { query: `e.${attr} IS NOT NULL`, params: {} };
+
+    throw new BadRequestException(`Unsupported operator: ${op}`);
+  }
+
+  private buildYearCondition(attr: string, op: string, val: any, key: string) {
+    switch (op) {
+      case 'equal':
+        return {
+          query: `e.${attr} = :${key}`,
+          params: { [key]: parseInt(val, 10) },
+        };
+      case 'not_equal':
+        return {
+          query: `e.${attr} != :${key}`,
+          params: { [key]: parseInt(val, 10) },
+        };
+      case 'greater_than':
+        return {
+          query: `e.${attr} > :${key}`,
+          params: { [key]: parseInt(val, 10) },
+        };
+      case 'less_than':
+        return {
+          query: `e.${attr} < :${key}`,
+          params: { [key]: parseInt(val, 10) },
+        };
+      default:
+        throw new BadRequestException(`Unsupported operator for year: ${op}`);
+    }
+  }
+
+  async queryWithSchema(sql: string, params: any[] = []) {
+    await this.entityManager.query('BEGIN');
+    await this.entityManager.query(`SET LOCAL search_path TO ${this.schema}`);
+    const result = await this.entityManager.query(sql, params);
+    await this.entityManager.query('COMMIT');
+    return result;
+  }
+}