rez_core 5.0.152 → 5.0.154

package/dist/migrations/1732612800000-AddEntityJsonGinIndex.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddEntityJsonGinIndex1732612800000 = void 0;
-class AddEntityJsonGinIndex1732612800000 {
-    constructor() {
-        this.name = 'AddEntityJsonGinIndex1732612800000';
-    }
-    async up(queryRunner) {
-        await queryRunner.query(`
-      CREATE INDEX IF NOT EXISTS idx_entity_json_data_gin
-      ON frm_entity_json
-      USING GIN (json_data jsonb_path_ops);
-    `);
-        await queryRunner.query(`
-      CREATE INDEX IF NOT EXISTS idx_entity_json_entity_type
-      ON frm_entity_json (entity_type);
-    `);
-        await queryRunner.query(`
-      CREATE INDEX IF NOT EXISTS idx_entity_json_composite
-      ON frm_entity_json (entity_type, entity_id);
-    `);
-        console.log('✅ GIN indexes created successfully');
-    }
-    async down(queryRunner) {
-        await queryRunner.query(`DROP INDEX IF EXISTS idx_entity_json_data_gin;`);
-        await queryRunner.query(`DROP INDEX IF EXISTS idx_entity_json_entity_type;`);
-        await queryRunner.query(`DROP INDEX IF EXISTS idx_entity_json_composite;`);
-        console.log('✅ GIN indexes dropped successfully');
-    }
-}
-exports.AddEntityJsonGinIndex1732612800000 = AddEntityJsonGinIndex1732612800000;
-//# sourceMappingURL=1732612800000-AddEntityJsonGinIndex.js.map

package/dist/migrations/1732612800000-AddEntityJsonGinIndex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"1732612800000-AddEntityJsonGinIndex.js","sourceRoot":"","sources":["../../src/migrations/1732612800000-AddEntityJsonGinIndex.ts"],"names":[],"mappings":";;;AAEA,MAAa,kCAAkC;IAA/C;QACE,SAAI,GAAG,oCAAoC,CAAC;IAqC9C,CAAC;IAnCQ,KAAK,CAAC,EAAE,CAAC,WAAwB;QAGtC,MAAM,WAAW,CAAC,KAAK,CAAC;;;;KAIvB,CAAC,CAAC;QAGH,MAAM,WAAW,CAAC,KAAK,CAAC;;;KAGvB,CAAC,CAAC;QAGH,MAAM,WAAW,CAAC,KAAK,CAAC;;;KAGvB,CAAC,CAAC;QAEH,OAAO,CAAC,GAAG,CAAC,oCAAoC,CAAC,CAAC;IACpD,CAAC;IAEM,KAAK,CAAC,IAAI,CAAC,WAAwB;QACxC,MAAM,WAAW,CAAC,KAAK,CAAC,gDAAgD,CAAC,CAAC;QAC1E,MAAM,WAAW,CAAC,KAAK,CACrB,mDAAmD,CACpD,CAAC;QACF,MAAM,WAAW,CAAC,KAAK,CACrB,iDAAiD,CAClD,CAAC;QAEF,OAAO,CAAC,GAAG,CAAC,oCAAoC,CAAC,CAAC;IACpD,CAAC;CACF;AAtCD,gFAsCC"}

package/dist/module/filter/service/flatjson-filter.service.d.ts

@@ -1,30 +0,0 @@
-import { EntityManager } 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 } from '../dto/filter-request.dto';
-import { SavedFilterRepositoryService } from '../repository/saved-filter.repository';
-export declare class FlatjsonFilterService {
-    private readonly entityManager;
-    private readonly entityMasterService;
-    private readonly attributeMasterService;
-    private readonly resolverService;
-    private readonly loggingService;
-    private readonly configService;
-    private readonly savedFilterRepositoryService;
-    constructor(entityManager: EntityManager, entityMasterService: EntityMasterService, attributeMasterService: AttributeMasterService, resolverService: ResolverService, loggingService: LoggingService, configService: ConfigService, savedFilterRepositoryService: SavedFilterRepositoryService);
-    applyFlatjsonFilter(dto: FilterRequestDto): Promise<any>;
-    private buildJsonbConditions;
-    private resolveEntityData;
-    private buildJsonbCondition;
-    private buildTextCondition;
-    private buildNumberCondition;
-    private buildDateCondition;
-    private buildSelectCondition;
-    private buildMultiSelectCondition;
-    private buildYearCondition;
-    private getJsonbTabCounts;
-    private applyJsonbSorting;
-}

package/dist/module/filter/service/flatjson-filter.service.js

@@ -1,615 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlatjsonFilterService = void 0;
-const common_1 = require("@nestjs/common");
-const typeorm_1 = require("typeorm");
-const entity_master_service_1 = require("../../meta/service/entity-master.service");
-const attribute_master_service_1 = require("../../meta/service/attribute-master.service");
-const resolver_service_1 = require("../../meta/service/resolver.service");
-const loggingUtil_service_1 = require("../../../utils/service/loggingUtil.service");
-const config_1 = require("@nestjs/config");
-const entityJson_entity_1 = require("../../entity_json/entity/entityJson.entity");
-const saved_filter_repository_1 = require("../repository/saved-filter.repository");
-let FlatjsonFilterService = class FlatjsonFilterService {
-    constructor(entityManager, entityMasterService, attributeMasterService, resolverService, loggingService, configService, savedFilterRepositoryService) {
-        this.entityManager = entityManager;
-        this.entityMasterService = entityMasterService;
-        this.attributeMasterService = attributeMasterService;
-        this.resolverService = resolverService;
-        this.loggingService = loggingService;
-        this.configService = configService;
-        this.savedFilterRepositoryService = savedFilterRepositoryService;
-    }
-    async applyFlatjsonFilter(dto) {
-        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}`);
-        const attributes = await this.attributeMasterService.findAttributesByMappedEntityType(entity_type, loggedInUser);
-        const attributeMetaMap = {};
-        attributes.forEach((attr) => {
-            attributeMetaMap[attr.attribute_key] = attr;
-        });
-        await this.loggingService.log('debug', 'FlatjsonFilterService', 'applyFlatjsonFilter', `Loaded ${attributes.length} attributes`);
-        let allFilters = [...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}`);
-        const jsonbConditions = this.buildJsonbConditions(allFilters, attributeMetaMap);
-        const qb = this.entityManager
-            .getRepository(entityJson_entity_1.EntityJson)
-            .createQueryBuilder('ej')
-            .where('ej.entity_type = :entity_type', { entity_type })
-            .andWhere('ej.organization_id = :orgId', {
-            orgId: loggedInUser.organization_id,
-        });
-        jsonbConditions.forEach((condition, index) => {
-            qb.andWhere(condition.query, condition.params);
-        });
-        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,
-                });
-            }
-        }
-        let tabCounts = [];
-        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);
-            }
-        }
-        if (sortby && sortby.length > 0) {
-            this.applyJsonbSorting(qb, sortby, attributeMetaMap);
-        }
-        else {
-            qb.orderBy('ej.created_date', 'DESC');
-        }
-        const totalCount = await qb.getCount();
-        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`);
-        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,
-        };
-    }
-    buildJsonbConditions(filters, attributeMetaMap) {
-        const conditions = [];
-        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;
-    }
-    async resolveEntityData(entityJsonRecords, entity_type, loggedInUser) {
-        if (entityJsonRecords.length === 0)
-            return [];
-        const entityIds = entityJsonRecords.map((ej) => ej.entity_id);
-        try {
-            const fullEntities = await this.resolverService.getResolvedData(entity_type, entityIds, loggedInUser);
-            return entityJsonRecords.map((ej) => {
-                const fullEntity = fullEntities.find((e) => e.id === ej.entity_id);
-                return {
-                    ...fullEntity,
-                    _flatjson: ej.json_data,
-                };
-            });
-        }
-        catch (error) {
-            console.error('Error resolving entity data:', error);
-            return entityJsonRecords.map((ej) => ({
-                id: ej.entity_id,
-                entity_type: ej.entity_type,
-                ...ej.json_data,
-            }));
-        }
-    }
-    buildJsonbCondition(filter, meta) {
-        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;
-        }
-    }
-    buildTextCondition(flatJsonKey, operator, value, paramKey) {
-        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;
-        }
-    }
-    buildNumberCondition(flatJsonKey, operator, value, paramKey) {
-        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': {
-                let range;
-                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;
-        }
-    }
-    buildDateCondition(flatJsonKey, operator, value, paramKey) {
-        const jsonbField = `(json_data->>'${flatJsonKey}')::bigint`;
-        const toEpochMs = (dateStr) => {
-            return new Date(dateStr).getTime();
-        };
-        const daysAgo = (days) => {
-            const d = new Date();
-            d.setDate(d.getDate() - days);
-            return d.getTime();
-        };
-        const daysFromNow = (days) => {
-            const d = new Date();
-            d.setDate(d.getDate() + days);
-            return d.getTime();
-        };
-        const subtractBusinessDays = (days) => {
-            let d = new Date();
-            let count = 0;
-            while (count < days) {
-                d.setDate(d.getDate() - 1);
-                const day = d.getDay();
-                if (day !== 0 && day !== 6) {
-                    count++;
-                }
-            }
-            return d.getTime();
-        };
-        const numVal = Number(value);
-        switch (operator) {
-            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) },
-                };
-            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) },
-                };
-            case 'is_before_business_days':
-                if (isNaN(numVal))
-                    return null;
-                return {
-                    query: `${jsonbField} <= :${paramKey}`,
-                    params: { [paramKey]: subtractBusinessDays(numVal) },
-                };
-            case 'between': {
-                let range;
-                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),
-                    },
-                };
-            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;
-        }
-    }
-    buildSelectCondition(flatJsonKey, operator, value, paramKey) {
-        switch (operator) {
-            case 'equal':
-                if (Array.isArray(value)) {
-                    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)) {
-                    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;
-        }
-    }
-    buildMultiSelectCondition(flatJsonKey, operator, value, paramKey) {
-        let arr;
-        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: {} };
-        }
-        switch (operator) {
-            case 'contains':
-            case 'has':
-                if (arr.length === 1) {
-                    return {
-                        query: `json_data->'${flatJsonKey}' ? :${paramKey}`,
-                        params: { [paramKey]: arr[0] },
-                    };
-                }
-                return {
-                    query: `json_data->'${flatJsonKey}' ?| ARRAY[:...${paramKey}]::text[]`,
-                    params: { [paramKey]: arr },
-                };
-            case 'contains_all':
-                return {
-                    query: `json_data->'${flatJsonKey}' ?& ARRAY[:...${paramKey}]::text[]`,
-                    params: { [paramKey]: arr },
-                };
-            case 'contains_any':
-                return {
-                    query: `json_data->'${flatJsonKey}' ?| ARRAY[:...${paramKey}]::text[]`,
-                    params: { [paramKey]: arr },
-                };
-            case 'not_contains':
-                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':
-                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;
-        }
-    }
-    buildYearCondition(flatJsonKey, operator, value, paramKey) {
-        return this.buildNumberCondition(flatJsonKey, operator, value, paramKey);
-    }
-    async getJsonbTabCounts(entity_type, flatJsonKey, whereClauses) {
-        const qb = this.entityManager
-            .getRepository(entityJson_entity_1.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}'`);
-        whereClauses.forEach((condition) => {
-            qb.andWhere(condition.query, condition.params);
-        });
-        const results = await qb.getRawMany();
-        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);
-    }
-    applyJsonbSorting(qb, sortby, attributeMetaMap) {
-        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';
-            let sortExpression;
-            switch (meta.data_type) {
-                case 'number':
-                case 'year':
-                    sortExpression = `(json_data->>'${flatJsonKey}')::numeric`;
-                    break;
-                case 'date':
-                    sortExpression = `(json_data->>'${flatJsonKey}')::bigint`;
-                    break;
-                case 'text':
-                case 'select':
-                case 'radio':
-                default:
-                    sortExpression = `json_data->>'${flatJsonKey}'`;
-                    break;
-            }
-            if (index === 0) {
-                qb.orderBy(sortExpression, direction);
-            }
-            else {
-                qb.addOrderBy(sortExpression, direction);
-            }
-        });
-    }
-};
-exports.FlatjsonFilterService = FlatjsonFilterService;
-exports.FlatjsonFilterService = FlatjsonFilterService = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [typeorm_1.EntityManager,
-        entity_master_service_1.EntityMasterService,
-        attribute_master_service_1.AttributeMasterService,
-        resolver_service_1.ResolverService,
-        loggingUtil_service_1.LoggingService,
-        config_1.ConfigService,
-        saved_filter_repository_1.SavedFilterRepositoryService])
-], FlatjsonFilterService);
-//# sourceMappingURL=flatjson-filter.service.js.map