rez_core 5.0.152 → 5.0.154

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

@@ -1,888 +0,0 @@
-import { Injectable, BadRequestException, Inject } from '@nestjs/common';
-import { EntityManager, SelectQueryBuilder } from 'typeorm';
-import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
-import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
-import { ResolverService } from 'src/module/meta/service/resolver.service';
-import { LoggingService } from 'src/utils/service/loggingUtil.service';
-import { ConfigService } from '@nestjs/config';
-import {
-  FilterRequestDto,
-  FilterCondition,
-  SortConfig,
-} from '../dto/filter-request.dto';
-import { EntityJson } from 'src/module/entity_json/entity/entityJson.entity';
-import { SavedFilterRepositoryService } from '../repository/saved-filter.repository';
-
-/**
- * JSONB query condition structure
- */
-interface JsonbCondition {
-  query: string;
-  params: Record<string, any>;
-}
-
-@Injectable()
-export class FlatjsonFilterService {
-  constructor(
-    private readonly entityManager: EntityManager,
-    private readonly entityMasterService: EntityMasterService,
-    private readonly attributeMasterService: AttributeMasterService,
-    private readonly resolverService: ResolverService,
-    private readonly loggingService: LoggingService,
-    private readonly configService: ConfigService,
-    private readonly savedFilterRepositoryService: SavedFilterRepositoryService,
-  ) {}
-
-  /**
-   * Main filtering method - queries frm_entity_json table
-   */
-  async applyFlatjsonFilter(dto: FilterRequestDto): Promise<any> {
-    const {
-      entity_type,
-      quickFilter = [],
-      savedFilterCode,
-      attributeFilter = [],
-      sortby = [],
-      tabs,
-      page = 1,
-      size = 20,
-      loggedInUser,
-    } = dto;
-
-    await this.loggingService.log(
-      'info',
-      'FlatjsonFilterService',
-      'applyFlatjsonFilter',
-      `Filtering entity: ${entity_type}`,
-    );
-
-    // Step 1: Load attribute metadata for this entity
-    const attributes =
-      await this.attributeMasterService.findAttributesByMappedEntityType(
-        entity_type,
-        loggedInUser,
-      );
-
-    const attributeMetaMap: Record<string, any> = {};
-    attributes.forEach((attr) => {
-      attributeMetaMap[attr.attribute_key] = attr;
-    });
-
-    await this.loggingService.log(
-      'debug',
-      'FlatjsonFilterService',
-      'applyFlatjsonFilter',
-      `Loaded ${attributes.length} attributes`,
-    );
-
-    // Step 2: Merge filters (quickFilter + savedFilter + attributeFilter)
-    let allFilters: FilterCondition[] = [...quickFilter, ...attributeFilter];
-
-    if (savedFilterCode) {
-      const savedFilterDetails =
-        await this.savedFilterRepositoryService.getDetailsByCode(
-          savedFilterCode,
-        );
-      allFilters = [...allFilters, ...savedFilterDetails];
-    }
-
-    await this.loggingService.log(
-      'debug',
-      'FlatjsonFilterService',
-      'applyFlatjsonFilter',
-      `Total filters: ${allFilters.length}`,
-    );
-
-    // Step 3: Build JSONB conditions
-    const jsonbConditions = this.buildJsonbConditions(
-      allFilters,
-      attributeMetaMap,
-    );
-
-    // Step 4: Build base query
-    const qb = this.entityManager
-      .getRepository(EntityJson)
-      .createQueryBuilder('ej')
-      .where('ej.entity_type = :entity_type', { entity_type })
-      .andWhere('ej.organization_id = :orgId', {
-        orgId: loggedInUser.organization_id,
-      });
-
-    // Step 5: Apply JSONB conditions
-    jsonbConditions.forEach((condition, index) => {
-      qb.andWhere(condition.query, condition.params);
-    });
-
-    // Step 6: Apply tab filter if provided
-    if (tabs?.columnName && tabs?.value) {
-      const tabMeta = attributeMetaMap[tabs.columnName];
-      if (tabMeta) {
-        const flatJsonKey =
-          tabMeta.flat_json_key ||
-          `${entity_type}__${tabs.columnName}`;
-        qb.andWhere(`json_data->>'${flatJsonKey}' = :tabValue`, {
-          tabValue: tabs.value,
-        });
-      }
-    }
-
-    // Step 7: Get tab counts if needed (before pagination)
-    let tabCounts: any[] = [];
-    if (tabs?.columnName && !tabs?.value) {
-      const tabMeta = attributeMetaMap[tabs.columnName];
-      if (tabMeta) {
-        const flatJsonKey =
-          tabMeta.flat_json_key ||
-          `${entity_type}__${tabs.columnName}`;
-        tabCounts = await this.getJsonbTabCounts(
-          entity_type,
-          flatJsonKey,
-          jsonbConditions,
-        );
-      }
-    }
-
-    // Step 8: Apply sorting
-    if (sortby && sortby.length > 0) {
-      this.applyJsonbSorting(qb, sortby, attributeMetaMap);
-    } else {
-      // Default sort by created_date DESC
-      qb.orderBy('ej.created_date', 'DESC');
-    }
-
-    // Step 9: Get total count (before pagination)
-    const totalCount = await qb.getCount();
-
-    // Step 10: Apply pagination
-    if (page && size) {
-      const skip = (page - 1) * size;
-      qb.skip(skip).take(size);
-    }
-
-    // Step 11: Execute query
-    const results = await qb.getMany();
-
-    await this.loggingService.log(
-      'info',
-      'FlatjsonFilterService',
-      'applyFlatjsonFilter',
-      `Found ${totalCount} total, returning ${results.length} records`,
-    );
-
-    // Step 12: Resolve entity IDs to full entity data
-    const resolvedData = await this.resolveEntityData(
-      results,
-      entity_type,
-      loggedInUser,
-    );
-
-    return {
-      data: resolvedData,
-      total: totalCount,
-      page: page || 1,
-      size: size || 20,
-      totalPages: size ? Math.ceil(totalCount / size) : 1,
-      tabCounts: tabCounts.length > 0 ? tabCounts : undefined,
-    };
-  }
-
-  /**
-   * Build JSONB where clauses from filter conditions
-   */
-  private buildJsonbConditions(
-    filters: FilterCondition[],
-    attributeMetaMap: Record<string, any>,
-  ): JsonbCondition[] {
-    const conditions: JsonbCondition[] = [];
-
-    for (const filter of filters) {
-      const meta = attributeMetaMap[filter.filter_attribute];
-      const condition = this.buildJsonbCondition(filter, meta);
-
-      if (condition) {
-        conditions.push(condition);
-      } else {
-        console.warn(
-          `Could not build condition for filter: ${filter.filter_attribute}`,
-        );
-      }
-    }
-
-    return conditions;
-  }
-
-  /**
-   * Resolve entity IDs to full entity data
-   */
-  private async resolveEntityData(
-    entityJsonRecords: EntityJson[],
-    entity_type: string,
-    loggedInUser: any,
-  ): Promise<any[]> {
-    if (entityJsonRecords.length === 0) return [];
-
-    const entityIds = entityJsonRecords.map((ej) => ej.entity_id);
-
-    try {
-      // Use resolver service to get full entity data
-      const fullEntities = await this.resolverService.getResolvedData(
-        entity_type,
-        entityIds,
-        loggedInUser,
-      );
-
-      // Return with json_data merged
-      return entityJsonRecords.map((ej) => {
-        const fullEntity = fullEntities.find((e) => e.id === ej.entity_id);
-        return {
-          ...fullEntity,
-          _flatjson: ej.json_data, // Include flatjson for debugging
-        };
-      });
-    } catch (error) {
-      console.error('Error resolving entity data:', error);
-      // Fallback: return just the entity IDs with json_data
-      return entityJsonRecords.map((ej) => ({
-        id: ej.entity_id,
-        entity_type: ej.entity_type,
-        ...ej.json_data,
-      }));
-    }
-  }
-
-  /**
-   * Build a single JSONB condition based on data type
-   */
-  private buildJsonbCondition(
-    filter: FilterCondition,
-    meta: any,
-  ): JsonbCondition | null {
-    if (!meta) return null;
-
-    const flatJsonKey =
-      meta.flat_json_key ||
-      `${meta.mapped_entity_type}__${filter.filter_attribute}`;
-    const op = filter.filter_operator;
-    const val = filter.filter_value;
-    const key = `param_${filter.filter_attribute}_${Math.random().toString(36).substring(2, 8)}`;
-
-    switch (meta.data_type) {
-      case 'text':
-        return this.buildTextCondition(flatJsonKey, op, val, key);
-      case 'number':
-        return this.buildNumberCondition(flatJsonKey, op, val, key);
-      case 'date':
-        return this.buildDateCondition(flatJsonKey, op, val, key);
-      case 'select':
-      case 'radio':
-        return this.buildSelectCondition(flatJsonKey, op, val, key);
-      case 'multiselect':
-      case 'checkbox':
-        return this.buildMultiSelectCondition(flatJsonKey, op, val, key);
-      case 'year':
-        return this.buildYearCondition(flatJsonKey, op, val, key);
-      default:
-        return null;
-    }
-  }
-
-  /**
-   * Build text condition (JSONB ->> operator)
-   */
-  private buildTextCondition(
-    flatJsonKey: string,
-    operator: string,
-    value: any,
-    paramKey: string,
-  ): JsonbCondition | null {
-    // Text is already stored lowercase in flatjson
-    const lowerValue = value ? String(value).toLowerCase() : '';
-
-    switch (operator) {
-      case 'equal':
-        return {
-          query: `json_data->>'${flatJsonKey}' = :${paramKey}`,
-          params: { [paramKey]: lowerValue },
-        };
-
-      case 'not_equal':
-        return {
-          query: `json_data->>'${flatJsonKey}' != :${paramKey}`,
-          params: { [paramKey]: lowerValue },
-        };
-
-      case 'contains':
-        return {
-          query: `json_data->>'${flatJsonKey}' LIKE :${paramKey}`,
-          params: { [paramKey]: `%${lowerValue}%` },
-        };
-
-      case 'not_contains':
-        return {
-          query: `json_data->>'${flatJsonKey}' NOT LIKE :${paramKey}`,
-          params: { [paramKey]: `%${lowerValue}%` },
-        };
-
-      case 'starts_with':
-        return {
-          query: `json_data->>'${flatJsonKey}' LIKE :${paramKey}`,
-          params: { [paramKey]: `${lowerValue}%` },
-        };
-
-      case 'ends_with':
-        return {
-          query: `json_data->>'${flatJsonKey}' LIKE :${paramKey}`,
-          params: { [paramKey]: `%${lowerValue}` },
-        };
-
-      case 'empty':
-        return {
-          query: `(json_data->>'${flatJsonKey}' IS NULL OR json_data->>'${flatJsonKey}' = '')`,
-          params: {},
-        };
-
-      case 'not_empty':
-        return {
-          query: `(json_data->>'${flatJsonKey}' IS NOT NULL AND json_data->>'${flatJsonKey}' != '')`,
-          params: {},
-        };
-
-      default:
-        console.warn(`Unsupported text operator: ${operator}`);
-        return null;
-    }
-  }
-
-  /**
-   * Build number condition (JSONB ->> with ::numeric cast)
-   */
-  private buildNumberCondition(
-    flatJsonKey: string,
-    operator: string,
-    value: any,
-    paramKey: string,
-  ): JsonbCondition | null {
-    // Cast JSONB text to numeric for comparison
-    const jsonbField = `(json_data->>'${flatJsonKey}')::numeric`;
-
-    switch (operator) {
-      case 'equal':
-        return {
-          query: `${jsonbField} = :${paramKey}`,
-          params: { [paramKey]: Number(value) },
-        };
-
-      case 'not_equal':
-        return {
-          query: `${jsonbField} != :${paramKey}`,
-          params: { [paramKey]: Number(value) },
-        };
-
-      case 'greater_than':
-        return {
-          query: `${jsonbField} > :${paramKey}`,
-          params: { [paramKey]: Number(value) },
-        };
-
-      case 'less_than':
-        return {
-          query: `${jsonbField} < :${paramKey}`,
-          params: { [paramKey]: Number(value) },
-        };
-
-      case 'greater_than_equal_to':
-        return {
-          query: `${jsonbField} >= :${paramKey}`,
-          params: { [paramKey]: Number(value) },
-        };
-
-      case 'less_than_equal_to':
-        return {
-          query: `${jsonbField} <= :${paramKey}`,
-          params: { [paramKey]: Number(value) },
-        };
-
-      case 'between': {
-        // Value should be array [min, max] or string "min,max"
-        let range: number[];
-        if (typeof value === 'string') {
-          range = value.split(',').map((v) => Number(v.trim()));
-        } else if (Array.isArray(value)) {
-          range = value.map((v) => Number(v));
-        } else {
-          return null;
-        }
-
-        if (range.length !== 2) return null;
-
-        return {
-          query: `${jsonbField} BETWEEN :${paramKey}_min AND :${paramKey}_max`,
-          params: {
-            [`${paramKey}_min`]: range[0],
-            [`${paramKey}_max`]: range[1],
-          },
-        };
-      }
-
-      case 'empty':
-        return {
-          query: `json_data->>'${flatJsonKey}' IS NULL`,
-          params: {},
-        };
-
-      case 'not_empty':
-        return {
-          query: `json_data->>'${flatJsonKey}' IS NOT NULL`,
-          params: {},
-        };
-
-      default:
-        console.warn(`Unsupported number operator: ${operator}`);
-        return null;
-    }
-  }
-
-  /**
-   * Build date condition (JSONB ->> with ::bigint cast for epoch ms)
-   */
-  private buildDateCondition(
-    flatJsonKey: string,
-    operator: string,
-    value: any,
-    paramKey: string,
-  ): JsonbCondition | null {
-    // Dates stored as epoch milliseconds (bigint)
-    const jsonbField = `(json_data->>'${flatJsonKey}')::bigint`;
-
-    // Helper: Convert date string to epoch ms
-    const toEpochMs = (dateStr: string): number => {
-      return new Date(dateStr).getTime();
-    };
-
-    // Helper: Get date N days ago
-    const daysAgo = (days: number): number => {
-      const d = new Date();
-      d.setDate(d.getDate() - days);
-      return d.getTime();
-    };
-
-    // Helper: Get date N days from now
-    const daysFromNow = (days: number): number => {
-      const d = new Date();
-      d.setDate(d.getDate() + days);
-      return d.getTime();
-    };
-
-    // Helper: Subtract business days (skip weekends)
-    const subtractBusinessDays = (days: number): number => {
-      let d = new Date();
-      let count = 0;
-
-      while (count < days) {
-        d.setDate(d.getDate() - 1);
-        const day = d.getDay(); // 0=Sun, 6=Sat
-        if (day !== 0 && day !== 6) {
-          count++;
-        }
-      }
-
-      return d.getTime();
-    };
-
-    const numVal = Number(value);
-
-    switch (operator) {
-      // Basic comparisons
-      case 'equal':
-      case 'is':
-        return {
-          query: `${jsonbField} = :${paramKey}`,
-          params: { [paramKey]: toEpochMs(value) },
-        };
-
-      case 'before':
-      case 'is_before':
-        return {
-          query: `${jsonbField} < :${paramKey}`,
-          params: { [paramKey]: toEpochMs(value) },
-        };
-
-      case 'after':
-      case 'is_after':
-        return {
-          query: `${jsonbField} > :${paramKey}`,
-          params: { [paramKey]: toEpochMs(value) },
-        };
-
-      case 'is_on_or_before':
-        return {
-          query: `${jsonbField} <= :${paramKey}`,
-          params: { [paramKey]: toEpochMs(value) },
-        };
-
-      case 'is_on_or_after':
-        return {
-          query: `${jsonbField} >= :${paramKey}`,
-          params: { [paramKey]: toEpochMs(value) },
-        };
-
-      // Day offset logic
-      case 'is_day_before':
-        if (isNaN(numVal)) return null;
-        return {
-          query: `${jsonbField} <= :${paramKey}`,
-          params: { [paramKey]: daysAgo(numVal) },
-        };
-
-      case 'is_day_after':
-        if (isNaN(numVal)) return null;
-        return {
-          query: `${jsonbField} >= :${paramKey}`,
-          params: { [paramKey]: daysFromNow(numVal) },
-        };
-
-      // Business days (skip weekends)
-      case 'is_before_business_days':
-        if (isNaN(numVal)) return null;
-        return {
-          query: `${jsonbField} <= :${paramKey}`,
-          params: { [paramKey]: subtractBusinessDays(numVal) },
-        };
-
-      // Range operators
-      case 'between': {
-        let range: string[];
-        if (typeof value === 'string') {
-          range = value.split(',').map((v) => v.trim());
-        } else if (Array.isArray(value)) {
-          range = value;
-        } else {
-          return null;
-        }
-
-        if (range.length !== 2) return null;
-
-        return {
-          query: `${jsonbField} BETWEEN :${paramKey}_start AND :${paramKey}_end`,
-          params: {
-            [`${paramKey}_start`]: toEpochMs(range[0]),
-            [`${paramKey}_end`]: toEpochMs(range[1]),
-          },
-        };
-      }
-
-      case 'in_last_day':
-        if (isNaN(numVal)) return null;
-        return {
-          query: `${jsonbField} BETWEEN :${paramKey}_start AND :${paramKey}_end`,
-          params: {
-            [`${paramKey}_start`]: daysAgo(numVal),
-            [`${paramKey}_end`]: Date.now(),
-          },
-        };
-
-      case 'in_next_day':
-        if (isNaN(numVal)) return null;
-        return {
-          query: `${jsonbField} BETWEEN :${paramKey}_start AND :${paramKey}_end`,
-          params: {
-            [`${paramKey}_start`]: Date.now(),
-            [`${paramKey}_end`]: daysFromNow(numVal),
-          },
-        };
-
-      // Special cases
-      case 'today': {
-        const todayStart = new Date().setHours(0, 0, 0, 0);
-        const todayEnd = new Date().setHours(23, 59, 59, 999);
-        return {
-          query: `${jsonbField} BETWEEN :${paramKey}_start AND :${paramKey}_end`,
-          params: {
-            [`${paramKey}_start`]: todayStart,
-            [`${paramKey}_end`]: todayEnd,
-          },
-        };
-      }
-
-      case 'empty':
-        return {
-          query: `json_data->>'${flatJsonKey}' IS NULL`,
-          params: {},
-        };
-
-      case 'not_empty':
-        return {
-          query: `json_data->>'${flatJsonKey}' IS NOT NULL`,
-          params: {},
-        };
-
-      default:
-        console.warn(`Unsupported date operator: ${operator}`);
-        return null;
-    }
-  }
-
-  /**
-   * Build select condition (single value)
-   */
-  private buildSelectCondition(
-    flatJsonKey: string,
-    operator: string,
-    value: any,
-    paramKey: string,
-  ): JsonbCondition | null {
-    switch (operator) {
-      case 'equal':
-        if (Array.isArray(value)) {
-          // IN operator for multiple values
-          return {
-            query: `json_data->>'${flatJsonKey}' = ANY(:${paramKey})`,
-            params: { [paramKey]: value.map(String) },
-          };
-        }
-        return {
-          query: `json_data->>'${flatJsonKey}' = :${paramKey}`,
-          params: { [paramKey]: String(value) },
-        };
-
-      case 'not_equal':
-        if (Array.isArray(value)) {
-          // NOT IN operator
-          return {
-            query: `json_data->>'${flatJsonKey}' != ALL(:${paramKey})`,
-            params: { [paramKey]: value.map(String) },
-          };
-        }
-        return {
-          query: `json_data->>'${flatJsonKey}' != :${paramKey}`,
-          params: { [paramKey]: String(value) },
-        };
-
-      case 'in': {
-        const inValues = Array.isArray(value) ? value : [value];
-        return {
-          query: `json_data->>'${flatJsonKey}' = ANY(:${paramKey})`,
-          params: { [paramKey]: inValues.map(String) },
-        };
-      }
-
-      case 'not_in': {
-        const notInValues = Array.isArray(value) ? value : [value];
-        return {
-          query: `json_data->>'${flatJsonKey}' != ALL(:${paramKey})`,
-          params: { [paramKey]: notInValues.map(String) },
-        };
-      }
-
-      case 'empty':
-        return {
-          query: `json_data->>'${flatJsonKey}' IS NULL`,
-          params: {},
-        };
-
-      case 'not_empty':
-        return {
-          query: `json_data->>'${flatJsonKey}' IS NOT NULL`,
-          params: {},
-        };
-
-      default:
-        console.warn(`Unsupported select operator: ${operator}`);
-        return null;
-    }
-  }
-
-  /**
-   * Build multiselect condition (JSONB -> with ? operators for arrays)
-   */
-  private buildMultiSelectCondition(
-    flatJsonKey: string,
-    operator: string,
-    value: any,
-    paramKey: string,
-  ): JsonbCondition | null {
-    // Convert value to array if not already
-    let arr: string[];
-    if (Array.isArray(value)) {
-      arr = value.map(String);
-    } else if (typeof value === 'string') {
-      arr = value.split(',').map((v) => v.trim());
-    } else {
-      arr = [String(value)];
-    }
-
-    if (arr.length === 0) {
-      return { query: '1=1', params: {} }; // Always true for empty array
-    }
-
-    switch (operator) {
-      case 'contains':
-      case 'has':
-        // Check if JSON array contains this element
-        // json_data->'LEAD__languages' ? 'hindi'
-        if (arr.length === 1) {
-          return {
-            query: `json_data->'${flatJsonKey}' ? :${paramKey}`,
-            params: { [paramKey]: arr[0] },
-          };
-        }
-        // For multiple values, check if contains ANY
-        return {
-          query: `json_data->'${flatJsonKey}' ?| ARRAY[:...${paramKey}]::text[]`,
-          params: { [paramKey]: arr },
-        };
-
-      case 'contains_all':
-        // Check if JSON array contains ALL elements
-        // json_data->'LEAD__languages' ?& ARRAY['hindi', 'english']
-        return {
-          query: `json_data->'${flatJsonKey}' ?& ARRAY[:...${paramKey}]::text[]`,
-          params: { [paramKey]: arr },
-        };
-
-      case 'contains_any':
-        // Check if JSON array contains ANY element
-        // json_data->'LEAD__languages' ?| ARRAY['hindi', 'english']
-        return {
-          query: `json_data->'${flatJsonKey}' ?| ARRAY[:...${paramKey}]::text[]`,
-          params: { [paramKey]: arr },
-        };
-
-      case 'not_contains':
-        // Check if JSON array does NOT contain element
-        if (arr.length === 1) {
-          return {
-            query: `NOT (json_data->'${flatJsonKey}' ? :${paramKey})`,
-            params: { [paramKey]: arr[0] },
-          };
-        }
-        return {
-          query: `NOT (json_data->'${flatJsonKey}' ?| ARRAY[:...${paramKey}]::text[])`,
-          params: { [paramKey]: arr },
-        };
-
-      case 'equal':
-        // Exact array match (order matters in PostgreSQL)
-        return {
-          query: `json_data->'${flatJsonKey}'::jsonb = :${paramKey}::jsonb`,
-          params: { [paramKey]: JSON.stringify(arr) },
-        };
-
-      case 'empty':
-        return {
-          query: `(json_data->>'${flatJsonKey}' IS NULL OR json_data->'${flatJsonKey}' = '[]'::jsonb)`,
-          params: {},
-        };
-
-      case 'not_empty':
-        return {
-          query: `(json_data->>'${flatJsonKey}' IS NOT NULL AND json_data->'${flatJsonKey}' != '[]'::jsonb)`,
-          params: {},
-        };
-
-      default:
-        console.warn(`Unsupported multiselect operator: ${operator}`);
-        return null;
-    }
-  }
-
-  /**
-   * Build year condition
-   */
-  private buildYearCondition(
-    flatJsonKey: string,
-    operator: string,
-    value: any,
-    paramKey: string,
-  ): JsonbCondition | null {
-    // Similar to number condition
-    return this.buildNumberCondition(flatJsonKey, operator, value, paramKey);
-  }
-
-  /**
-   * Get tab aggregation counts from JSONB
-   */
-  private async getJsonbTabCounts(
-    entity_type: string,
-    flatJsonKey: string,
-    whereClauses: JsonbCondition[],
-  ): Promise<Array<{ tab_value: string; tab_value_count: number }>> {
-    // Build a query that groups by the tab field
-    const qb = this.entityManager
-      .getRepository(EntityJson)
-      .createQueryBuilder('ej')
-      .select(`json_data->>'${flatJsonKey}'`, 'tab_value')
-      .addSelect('COUNT(*)', 'tab_value_count')
-      .where('ej.entity_type = :entity_type', { entity_type })
-      .groupBy(`json_data->>'${flatJsonKey}'`);
-
-    // Apply the same filter conditions (but not the tab filter itself)
-    whereClauses.forEach((condition) => {
-      qb.andWhere(condition.query, condition.params);
-    });
-
-    const results = await qb.getRawMany();
-
-    // Filter out NULL/undefined tab values and convert count to number
-    return results
-      .filter((r) => r.tab_value != null && r.tab_value !== '')
-      .map((r) => ({
-        tab_value: r.tab_value,
-        tab_value_count: parseInt(r.tab_value_count, 10),
-      }))
-      .sort((a, b) => b.tab_value_count - a.tab_value_count); // Sort by count DESC
-  }
-
-  /**
-   * Apply sorting on JSONB fields
-   */
-  private applyJsonbSorting(
-    qb: SelectQueryBuilder<EntityJson>,
-    sortby: SortConfig[],
-    attributeMetaMap: Record<string, any>,
-  ): void {
-    sortby.forEach((sort, index) => {
-      const meta = attributeMetaMap[sort.sortColum];
-
-      if (!meta) {
-        console.warn(`No metadata found for sort column: ${sort.sortColum}`);
-        return;
-      }
-
-      const flatJsonKey =
-        meta.flat_json_key || `${meta.mapped_entity_type}__${sort.sortColum}`;
-      const direction = sort.sortType === 'ASC' ? 'ASC' : 'DESC';
-
-      // Apply type-specific casting for proper sorting
-      let sortExpression: string;
-
-      switch (meta.data_type) {
-        case 'number':
-        case 'year':
-          // Cast to numeric for number sorting
-          sortExpression = `(json_data->>'${flatJsonKey}')::numeric`;
-          break;
-
-        case 'date':
-          // Cast to bigint for date sorting (epoch ms)
-          sortExpression = `(json_data->>'${flatJsonKey}')::bigint`;
-          break;
-
-        case 'text':
-        case 'select':
-        case 'radio':
-        default:
-          // Text sorting (already lowercase)
-          sortExpression = `json_data->>'${flatJsonKey}'`;
-          break;
-      }
-
-      // Add to ORDER BY clause
-      if (index === 0) {
-        qb.orderBy(sortExpression, direction);
-      } else {
-        qb.addOrderBy(sortExpression, direction);
-      }
-    });
-  }
-}