rez_core 5.0.211 → 6.1.0

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

@@ -0,0 +1,903 @@
+import { Injectable, BadRequestException, Inject, forwardRef } from '@nestjs/common';
+import { EntityManager, SelectQueryBuilder } from 'typeorm';
+import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
+import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
+import { ResolverService } from 'src/module/meta/service/resolver.service';
+import { LoggingService } from 'src/utils/service/loggingUtil.service';
+import { ConfigService } from '@nestjs/config';
+import {
+  FilterRequestDto,
+  FilterCondition,
+  SortConfig,
+} from '../dto/filter-request.dto';
+import { EntityJson } from 'src/module/entity_json/entity/entityJson.entity';
+import { SavedFilterRepositoryService } from '../repository/saved-filter.repository';
+import { EntityJSONService } from 'src/module/entity_json/service/entity_json.service';
+
+/**
+ * JSONB query condition structure
+ */
+interface JsonbCondition {
+  query: string;
+  params: Record<string, any>;
+}
+
+@Injectable()
+export class FlatjsonFilterService {
+  constructor(
+    private readonly entityManager: EntityManager,
+    @Inject(forwardRef(() => EntityMasterService))
+    private readonly entityMasterService: EntityMasterService,
+    @Inject(forwardRef(() => AttributeMasterService))
+    private readonly attributeMasterService: AttributeMasterService,
+    @Inject(forwardRef(() => ResolverService))
+    private readonly resolverService: ResolverService,
+    @Inject(forwardRef(() => LoggingService))
+    private readonly loggingService: LoggingService,
+    private readonly configService: ConfigService,
+    @Inject(forwardRef(() => SavedFilterRepositoryService))
+    private readonly savedFilterRepositoryService: SavedFilterRepositoryService,
+    @Inject(forwardRef(() => EntityJSONService))
+    private readonly entityJsonService: EntityJSONService,
+  ) {}
+
+  /**
+   * Main filtering method - queries frm_entity_json table
+   */
+  async applyFlatjsonFilter(dto: FilterRequestDto): Promise<any> {
+    const {
+      entity_type,
+      quickFilter = [],
+      savedFilterCode,
+      attributeFilter = [],
+      sortby = [],
+      tabs,
+      page = 1,
+      size = 20,
+      loggedInUser,
+    } = dto;
+
+    await this.loggingService.log(
+      'info',
+      'FlatjsonFilterService',
+      'applyFlatjsonFilter',
+      `Filtering entity: ${entity_type}`,
+    );
+
+    // Step 1: Load attribute metadata for this entity
+    let attributes =
+      await this.entityJsonService.getAttributeForFlatJSON(
+        entity_type,
+        loggedInUser,
+        'filter_attribute',
+      );
+
+    if (!attributes?.length) {
+      attributes =
+        await this.attributeMasterService.findAttributesByMappedEntityType(
+          entity_type,
+          loggedInUser,
+        );
+    }
+
+    attributes = attributes ?? [];
+
+    const attributeMetaMap: Record<string, any> = {};
+    attributes.forEach((attr) => {
+      attributeMetaMap[attr.flat_json_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_at', 'DESC');
+    }
+
+    // Step 9: Get total count (before pagination)
+    const totalCount = await qb.getCount();
+
+    // Step 10: Apply pagination
+    if (page && size) {
+      const skip = (page - 1) * size;
+      qb.skip(skip).take(size);
+    }
+
+    const results = await qb.getMany();
+
+    await this.loggingService.log(
+      'info',
+      'FlatjsonFilterService',
+      'applyFlatjsonFilter',
+      `Found ${totalCount} total, returning ${results.length} records`,
+    );
+
+    // Map only json_data
+    const jsonDataResults = results.map((r) => r.json_data);
+
+    return {
+      data: jsonDataResults,
+      total: totalCount,
+      page: page || 1,
+      size: size || 20,
+      totalPages: size ? Math.ceil(totalCount / size) : 1,
+      tabCounts: tabCounts.length > 0 ? tabCounts : undefined,
+    };
+
+  }
+
+  /**
+   * Build JSONB where clauses from filter conditions
+   */
+  private buildJsonbConditions(
+    filters: FilterCondition[],
+    attributeMetaMap: Record<string, any>,
+  ): JsonbCondition[] {
+    const conditions: JsonbCondition[] = [];
+
+    for (const filter of filters) {
+      const meta = attributeMetaMap[filter.filter_attribute];
+      const condition = this.buildJsonbCondition(filter, meta);
+
+      if (condition) {
+        conditions.push(condition);
+      } else {
+        console.warn(
+          `Could not build condition for filter: ${filter.filter_attribute}`,
+        );
+      }
+    }
+
+    return conditions;
+  }
+
+  /**
+   * Resolve entity IDs to full entity data
+   */
+  private async resolveEntityData(
+    entityJsonRecords: EntityJson[],
+    entity_type: string,
+    loggedInUser: any,
+  ): Promise<any[]> {
+    if (entityJsonRecords.length === 0) return [];
+
+    const entityIds = entityJsonRecords.map((ej) => ej.entity_id);
+
+    try {
+      // Use resolver service to get full entity data
+      const fullEntities = await this.resolverService.getResolvedData(
+        entity_type,
+        entityIds,
+        loggedInUser,
+      );
+
+      // Return with json_data merged
+      return entityJsonRecords.map((ej) => {
+        const fullEntity = fullEntities.find((e) => e.id === ej.entity_id);
+        return {
+          ...fullEntity,
+          _flatjson: ej.json_data, // Include flatjson for debugging
+        };
+      });
+    } catch (error) {
+      console.error('Error resolving entity data:', error);
+      // Fallback: return just the entity IDs with json_data
+      return entityJsonRecords.map((ej) => ({
+        id: ej.entity_id,
+        entity_type: ej.entity_type,
+        ...ej.json_data,
+      }));
+    }
+  }
+
+  /**
+   * Build a single JSONB condition based on data type
+   */
+  private buildJsonbCondition(
+    filter: FilterCondition,
+    meta: any,
+  ): JsonbCondition | null {
+    if (!meta) return null;
+
+    const flatJsonKey =
+      meta.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);
+      }
+    });
+  }
+}