@medusajs/index 3.0.0-snapshot-20250410112222 → 3.0.0-snapshot-20251104004624

package/dist/utils/query-builder.js

@@ -8,6 +8,47 @@ var _QueryBuilder_searchVectorColumnName;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryBuilder = exports.OPERATOR_MAP = void 0;
 const utils_1 = require("@medusajs/framework/utils");
+const normalze_table_name_1 = require("./normalze-table-name");
+const AND_OPERATOR = "$and";
+const OR_OPERATOR = "$or";
+const NOT_OPERATOR = "$not";
+function escapeJsonPathString(val) {
+    // Escape for JSONPath string
+    return val.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/'/g, "\\'");
+}
+function buildSafeJsonPathQuery(field, operator, value) {
+    let jsonPathOperator = operator;
+    let caseInsensitiveFlag = "";
+    if (operator === "=") {
+        jsonPathOperator = "==";
+    }
+    else if (operator.toUpperCase().includes("LIKE")) {
+        jsonPathOperator = "like_regex";
+        if (operator.toUpperCase() === "ILIKE") {
+            caseInsensitiveFlag = ' flag "i"';
+        }
+    }
+    else if (operator === "IS") {
+        jsonPathOperator = "==";
+    }
+    else if (operator === "IS NOT") {
+        jsonPathOperator = "!=";
+    }
+    if (typeof value === "string") {
+        let val = value;
+        if (jsonPathOperator === "like_regex") {
+            // Convert SQL LIKE wildcards to regex
+            val = val.replace(/%/g, ".*").replace(/_/g, ".");
+        }
+        value = `"${escapeJsonPathString(val)}"`;
+    }
+    else {
+        if ((operator === "IS" || operator === "IS NOT") && value === null) {
+            value = "null";
+        }
+    }
+    return `$.${field} ${jsonPathOperator} ${value}${caseInsensitiveFlag}`;
+}
 exports.OPERATOR_MAP = {
     $eq: "=",
     $lt: "<",
@@ -16,6 +57,7 @@ exports.OPERATOR_MAP = {
     $gte: ">=",
     $ne: "!=",
     $in: "IN",
+    $nin: "NOT IN",
     $is: "IS",
     $like: "LIKE",
     $ilike: "ILIKE",
@@ -32,9 +74,29 @@ class QueryBuilder {
         this.allSchemaFields = new Set(Object.values(this.schema).flatMap((entity) => entity.fields ?? []));
         this.rawConfig = args.rawConfig;
         this.requestedFields = args.requestedFields;
+        this.idsOnly = args.idsOnly ?? false;
+    }
+    isLogicalOperator(key) {
+        return key === AND_OPERATOR || key === OR_OPERATOR || key === NOT_OPERATOR;
     }
     getStructureKeys(structure) {
-        return Object.keys(structure ?? {}).filter((key) => key !== "entity");
+        const collectKeys = (obj, keys = new Set()) => {
+            if (!(0, utils_1.isObject)(obj)) {
+                return keys;
+            }
+            Object.keys(obj).forEach((key) => {
+                if (this.isLogicalOperator(key)) {
+                    if (Array.isArray(obj[key])) {
+                        obj[key].forEach((item) => collectKeys(item, keys));
+                    }
+                }
+                else if (key !== "entity") {
+                    keys.add(key);
+                }
+            });
+            return keys;
+        };
+        return [...collectKeys(structure ?? {})];
     }
     getEntity(path, throwWhenNotFound = true) {
         if (!this.schema._schemaPropertiesMap[path]) {
@@ -46,20 +108,18 @@ class QueryBuilder {
         return this.schema._schemaPropertiesMap[path];
     }
     getGraphQLType(path, field) {
+        if (this.isLogicalOperator(field)) {
+            return "JSON";
+        }
         const entity = this.getEntity(path)?.ref?.entity;
         const fieldRef = this.entityMap[entity]._fields[field];
         if (!fieldRef) {
             throw new Error(`Field ${field} is not indexed.`);
         }
-        let currentType = fieldRef.type;
-        let isArray = false;
-        while (currentType.ofType) {
-            if (currentType instanceof utils_1.GraphQLUtils.GraphQLList) {
-                isArray = true;
-            }
-            currentType = currentType.ofType;
-        }
-        return currentType.name + (isArray ? "[]" : "");
+        const fieldType = fieldRef.type.toString();
+        const isArray = fieldType.startsWith("[");
+        const currentType = fieldType.replace(/\[|\]|\!/g, "");
+        return currentType + (isArray ? "[]" : "");
     }
     transformValueToType(path, field, value) {
         if (value === null) {
@@ -120,10 +180,11 @@ class QueryBuilder {
             coalesce: generateCoalesceExpression,
         };
     }
-    parseWhere(aliasMapping, obj, builder) {
+    parseWhere(aliasMapping, obj, builder, parentPath = "") {
         const keys = Object.keys(obj);
         const getPathAndField = (key) => {
-            const path = key.split(".");
+            const fullKey = parentPath ? `${parentPath}.${key}` : key;
+            const path = fullKey.split(".");
             const field = [path.pop()];
             while (!aliasMapping[path.join(".")] && path.length > 0) {
                 field.unshift(path.pop());
@@ -140,52 +201,125 @@ class QueryBuilder {
             return JSON.stringify(result);
         };
         keys.forEach((key) => {
+            const pathAsArray = (parentPath ? `${parentPath}.${key}` : key).split(".");
+            const fieldOrLogicalOperator = pathAsArray.pop();
             let value = obj[key];
-            if ((key === "$and" || key === "$or") && !Array.isArray(value)) {
+            if (this.isLogicalOperator(fieldOrLogicalOperator) &&
+                !Array.isArray(value)) {
                 value = [value];
             }
-            if (key === "$and" && Array.isArray(value)) {
+            if (fieldOrLogicalOperator === AND_OPERATOR && Array.isArray(value)) {
                 builder.where((qb) => {
                     value.forEach((cond) => {
-                        qb.andWhere((subBuilder) => this.parseWhere(aliasMapping, cond, subBuilder));
+                        qb.andWhere((subBuilder) => this.parseWhere(aliasMapping, cond, subBuilder, pathAsArray.join(".")));
                     });
                 });
             }
-            else if (key === "$or" && Array.isArray(value)) {
+            else if (fieldOrLogicalOperator === OR_OPERATOR &&
+                Array.isArray(value)) {
                 builder.where((qb) => {
                     value.forEach((cond) => {
-                        qb.orWhere((subBuilder) => this.parseWhere(aliasMapping, cond, subBuilder));
+                        qb.orWhere((subBuilder) => this.parseWhere(aliasMapping, cond, subBuilder, pathAsArray.join(".")));
                     });
                 });
             }
-            else if ((0, utils_1.isObject)(value) && !Array.isArray(value)) {
-                const subKeys = Object.keys(value);
-                subKeys.forEach((subKey) => {
-                    let operator = exports.OPERATOR_MAP[subKey];
-                    if (operator) {
-                        const { field, attr } = getPathAndField(key);
-                        const nested = new Array(field.length).join("->?");
-                        const subValue = this.transformValueToType(attr, field, value[subKey]);
-                        const castType = this.getPostgresCastType(attr, [field]).cast;
-                        const val = operator === "IN" ? subValue : [subValue];
-                        if (operator === "=" && subValue === null) {
-                            operator = "IS";
-                        }
-                        else if (operator === "!=" && subValue === null) {
-                            operator = "IS NOT";
-                        }
-                        if (operator === "=") {
-                            builder.whereRaw(`${aliasMapping[attr]}.data @> '${getPathOperation(attr, field, subValue)}'::jsonb`);
-                        }
-                        else {
-                            builder.whereRaw(`(${aliasMapping[attr]}.data${nested}->>?)${castType} ${operator} ?`, [...field, ...val]);
-                        }
+            else if (fieldOrLogicalOperator === NOT_OPERATOR &&
+                (Array.isArray(value) || (0, utils_1.isObject)(value))) {
+                builder.whereNot((qb) => {
+                    if (Array.isArray(value)) {
+                        value.forEach((cond) => {
+                            qb.andWhere((subBuilder) => this.parseWhere(aliasMapping, cond, subBuilder, pathAsArray.join(".")));
+                        });
                     }
                     else {
-                        throw new Error(`Unsupported operator: ${subKey}`);
+                        this.parseWhere(aliasMapping, value, qb, pathAsArray.join("."));
                     }
                 });
             }
+            else if ((0, utils_1.isObject)(value) &&
+                !Array.isArray(value) &&
+                !this.isLogicalOperator(fieldOrLogicalOperator)) {
+                const currentPath = parentPath ? `${parentPath}.${key}` : key;
+                const subKeys = Object.keys(value);
+                const hasOperators = subKeys.some((subKey) => exports.OPERATOR_MAP[subKey]);
+                if (hasOperators) {
+                    const { field, attr } = getPathAndField(key);
+                    const subKeys = Object.keys(value);
+                    subKeys.forEach((subKey) => {
+                        let operator = exports.OPERATOR_MAP[subKey];
+                        if (operator) {
+                            const nested = new Array(field.length).join("->?");
+                            const subValue = this.transformValueToType(attr, field, value[subKey]);
+                            let val = operator === "IN" || operator === "NOT IN"
+                                ? subValue
+                                : [subValue];
+                            if (operator === "=" && subValue === null) {
+                                operator = "IS";
+                            }
+                            else if (operator === "!=" && subValue === null) {
+                                operator = "IS NOT";
+                            }
+                            if (operator === "=") {
+                                const hasId = field[field.length - 1] === "id";
+                                if (hasId) {
+                                    builder.whereRaw(`${aliasMapping[attr]}.id = ?`, subValue);
+                                }
+                                else {
+                                    builder.whereRaw(`${aliasMapping[attr]}.data @> '${getPathOperation(attr, field, subValue)}'::jsonb`);
+                                }
+                            }
+                            else if (operator === "IN" || operator === "NOT IN") {
+                                if (val && !Array.isArray(val)) {
+                                    val = [val];
+                                }
+                                if (!val || val.length === 0) {
+                                    return;
+                                }
+                                const inPlaceholders = val.map(() => "?").join(",");
+                                const hasId = field[field.length - 1] === "id";
+                                const isNegated = operator === "NOT IN";
+                                if (hasId) {
+                                    builder.whereRaw(`${aliasMapping[attr]}.id ${isNegated ? "NOT IN" : "IN"} (${inPlaceholders})`, val);
+                                }
+                                else {
+                                    const targetField = field[field.length - 1];
+                                    const jsonbValues = val.map((item) => JSON.stringify({
+                                        [targetField]: item === null ? null : item,
+                                    }));
+                                    if (isNegated) {
+                                        builder.whereRaw(`NOT EXISTS (SELECT 1 FROM unnest(ARRAY[${inPlaceholders}]::JSONB[]) AS v(val) WHERE ${aliasMapping[attr]}.data${nested} @> v.val)`, jsonbValues);
+                                    }
+                                    else {
+                                        builder.whereRaw(`${aliasMapping[attr]}.data${nested} @> ANY(ARRAY[${inPlaceholders}]::JSONB[])`, jsonbValues);
+                                    }
+                                }
+                            }
+                            else {
+                                const potentialIdFields = field[field.length - 1];
+                                const hasId = potentialIdFields === "id";
+                                if (hasId) {
+                                    builder.whereRaw(`(${aliasMapping[attr]}.id) ${operator} ?`, [
+                                        ...val,
+                                    ]);
+                                }
+                                else {
+                                    const targetField = field[field.length - 1];
+                                    const jsonPath = buildSafeJsonPathQuery(targetField, operator, val[0]);
+                                    builder.whereRaw(`${aliasMapping[attr]}.data${nested} @@ ?`, [
+                                        jsonPath,
+                                    ]);
+                                }
+                            }
+                        }
+                        else {
+                            throw new Error(`Unsupported operator: ${subKey}`);
+                        }
+                    });
+                }
+                else {
+                    this.parseWhere(aliasMapping, value, builder, currentPath);
+                }
+            }
             else {
                 const { field, attr } = getPathAndField(key);
                 const nested = new Array(field.length).join("->?");
@@ -194,49 +328,76 @@ class QueryBuilder {
                     if (value.length === 0) {
                         return;
                     }
-                    const castType = this.getPostgresCastType(attr, field).cast;
                     const inPlaceholders = value.map(() => "?").join(",");
-                    builder.whereRaw(`(${aliasMapping[attr]}.data${nested}->>?)${castType} IN (${inPlaceholders})`, [...field, ...value]);
+                    const hasId = field[field.length - 1] === "id";
+                    if (hasId) {
+                        builder.whereRaw(`${aliasMapping[attr]}.id IN (${inPlaceholders})`, [...value]);
+                    }
+                    else {
+                        const targetField = field[field.length - 1];
+                        const jsonbValues = value.map((item) => JSON.stringify({ [targetField]: item === null ? null : item }));
+                        builder.whereRaw(`${aliasMapping[attr]}.data${nested} @> ANY(ARRAY[${inPlaceholders}]::JSONB[])`, jsonbValues);
+                    }
                 }
                 else if ((0, utils_1.isDefined)(value)) {
-                    const operator = value === null ? "IS" : "=";
+                    let operator = "=";
                     if (operator === "=") {
-                        builder.whereRaw(`${aliasMapping[attr]}.data @> '${getPathOperation(attr, field, value)}'::jsonb`);
+                        const hasId = field[field.length - 1] === "id";
+                        if (hasId) {
+                            builder.whereRaw(`${aliasMapping[attr]}.id = ?`, value);
+                        }
+                        else {
+                            builder.whereRaw(`${aliasMapping[attr]}.data @> '${getPathOperation(attr, field, value)}'::jsonb`);
+                        }
                     }
                     else {
-                        const castType = this.getPostgresCastType(attr, field).cast;
-                        builder.whereRaw(`(${aliasMapping[attr]}.data${nested}->>?)${castType} ${operator} ?`, [...field, value]);
+                        if (value === null) {
+                            operator = "IS";
+                        }
+                        const hasId = field[field.length - 1] === "id";
+                        if (hasId) {
+                            builder.whereRaw(`(${aliasMapping[attr]}.id) ${operator} ?`, [
+                                value,
+                            ]);
+                        }
+                        else {
+                            const targetField = field[field.length - 1];
+                            const jsonPath = buildSafeJsonPathQuery(targetField, operator, value);
+                            builder.whereRaw(`${aliasMapping[attr]}.data${nested} @@ ?`, [
+                                jsonPath,
+                            ]);
+                        }
                     }
                 }
             }
         });
         return builder;
     }
-    getShortAlias(aliasMapping, alias) {
+    getShortAlias(aliasMapping, alias, level = 0) {
         aliasMapping.__aliasIndex ??= 0;
         if (aliasMapping[alias]) {
             return aliasMapping[alias];
         }
-        aliasMapping[alias] = "t_" + aliasMapping.__aliasIndex++ + "_";
+        aliasMapping[alias] =
+            "t_" + aliasMapping.__aliasIndex++ + (level > 0 ? `_${level}` : "");
         return aliasMapping[alias];
     }
     buildQueryParts(structure, parentAlias, parentEntity, parentProperty, aliasPath = [], level = 0, aliasMapping = {}) {
         const currentAliasPath = [...aliasPath, parentProperty].join(".");
         const isSelectableField = this.allSchemaFields.has(parentProperty);
         const entities = this.getEntity(currentAliasPath, false);
-        const entityRef = entities?.ref;
         // !entityRef.alias means the object has not table, it's a nested object
-        if (isSelectableField || !entities || !entityRef?.alias) {
+        if (isSelectableField || !entities || !entities?.ref?.alias) {
             // We are currently selecting a specific field of the parent entity or the entity is not found on the index schema
             // We don't need to build the query parts for this as there is no join
             return [];
         }
-        const mainEntity = entityRef.entity;
-        const mainAlias = this.getShortAlias(aliasMapping, mainEntity.toLowerCase()) + level;
+        const mainEntity = entities;
+        const mainAlias = this.getShortAlias(aliasMapping, mainEntity.ref.entity.toLowerCase(), level);
         const allEntities = [];
         if (!entities.shortCutOf) {
             allEntities.push({
-                entity: mainEntity,
+                entity: entities,
                 parEntity: parentEntity,
                 parAlias: parentAlias,
                 alias: mainAlias,
@@ -250,26 +411,24 @@ class QueryBuilder {
                     break;
                 }
                 intermediateAlias.pop();
-                if (intermediateEntity.ref.entity === parentEntity) {
+                if (intermediateEntity.ref.entity === parentEntity?.ref.entity) {
                     break;
                 }
                 const parentIntermediateEntity = this.getEntity(intermediateAlias.join("."));
-                const alias = this.getShortAlias(aliasMapping, intermediateEntity.ref.entity.toLowerCase()) +
-                    level +
+                const alias = this.getShortAlias(aliasMapping, intermediateEntity.ref.entity.toLowerCase(), level) +
                     "_" +
                     x;
-                const parAlias = parentIntermediateEntity.ref.entity === parentEntity
+                const parAlias = parentIntermediateEntity.ref.entity === parentEntity?.ref.entity
                     ? parentAlias
-                    : this.getShortAlias(aliasMapping, parentIntermediateEntity.ref.entity.toLowerCase()) +
-                        level +
+                    : this.getShortAlias(aliasMapping, parentIntermediateEntity.ref.entity.toLowerCase(), level) +
                         "_" +
                         (x + 1);
                 if (x === 0) {
                     aliasMapping[currentAliasPath] = alias;
                 }
                 allEntities.unshift({
-                    entity: intermediateEntity.ref.entity,
-                    parEntity: parentIntermediateEntity.ref.entity,
+                    entity: intermediateEntity,
+                    parEntity: parentIntermediateEntity,
                     parAlias,
                     alias,
                 });
@@ -281,12 +440,20 @@ class QueryBuilder {
             const { alias, entity, parEntity, parAlias } = join;
             aliasMapping[currentAliasPath] = alias;
             if (level > 0) {
-                const cName = entity.toLowerCase();
-                const pName = `${parEntity}${entity}`.toLowerCase();
+                const cName = (0, normalze_table_name_1.normalizeTableName)(entity.ref.entity);
                 let joinTable = `cat_${cName} AS ${alias}`;
-                const pivotTable = `cat_pivot_${pName}`;
-                joinBuilder.leftJoin(`${pivotTable} AS ${alias}_ref`, `${alias}_ref.parent_id`, `${parAlias}.id`);
-                joinBuilder.leftJoin(joinTable, `${alias}.id`, `${alias}_ref.child_id`);
+                if (entity.isInverse || parEntity.isInverse) {
+                    const pName = `${entity.ref.entity}${parEntity.ref.entity}`.toLowerCase();
+                    const pivotTable = (0, normalze_table_name_1.getPivotTableName)(pName);
+                    joinBuilder.leftJoin(`${pivotTable} AS ${alias}_ref`, `${alias}_ref.child_id`, `${parAlias}.id`);
+                    joinBuilder.leftJoin(joinTable, `${alias}.id`, `${alias}_ref.parent_id`);
+                }
+                else {
+                    const pName = `${parEntity.ref.entity}${entity.ref.entity}`.toLowerCase();
+                    const pivotTable = (0, normalze_table_name_1.getPivotTableName)(pName);
+                    joinBuilder.leftJoin(`${pivotTable} AS ${alias}_ref`, `${alias}_ref.parent_id`, `${parAlias}.id`);
+                    joinBuilder.leftJoin(joinTable, `${alias}.id`, `${alias}_ref.child_id`);
+                }
                 const joinWhere = this.selector.joinWhere ?? {};
                 const joinKey = Object.keys(joinWhere).find((key) => {
                     const k = key.split(".");
@@ -294,7 +461,7 @@ class QueryBuilder {
                     const curPath = k.join(".");
                     if (curPath === currentAliasPath) {
                         const relEntity = this.getEntity(curPath, false);
-                        return relEntity?.ref?.entity === entity;
+                        return relEntity?.ref?.entity === entity.ref.entity;
                     }
                     return false;
                 });
@@ -323,7 +490,12 @@ class QueryBuilder {
             const parentAliasPath = aliasPath.join(".");
             const alias = aliasMapping[parentAliasPath];
             delete selectParts[parentAliasPath];
-            selectParts[currentAliasPath] = this.knex.raw(`${alias}.data->'${parentProperty}'`);
+            if (parentProperty === "id") {
+                selectParts[currentAliasPath] = `${alias}.id`;
+            }
+            else if (!this.idsOnly) {
+                selectParts[currentAliasPath] = this.knex.raw(`${alias}.data->'${parentProperty}'`);
+            }
             return selectParts;
         }
         const alias = aliasMapping[currentAliasPath];
@@ -331,7 +503,9 @@ class QueryBuilder {
         if (!alias) {
             return selectParts;
         }
-        selectParts[currentAliasPath] = `${alias}.data`;
+        if (!this.idsOnly) {
+            selectParts[currentAliasPath] = `${alias}.data`;
+        }
         selectParts[currentAliasPath + ".id"] = `${alias}.id`;
         const children = this.getStructureKeys(structure);
         for (const child of children) {
@@ -372,21 +546,22 @@ class QueryBuilder {
         arr.forEach((obj) => nested(obj));
         return result;
     }
-    buildQuery({ hasPagination = true, hasCount = false, returnIdOnly = false, }) {
-        const queryBuilder = this.knex.queryBuilder();
+    buildQuery({ hasPagination = true, hasCount = false, }) {
         const selectOnlyStructure = this.selector.select;
         const structure = this.requestedFields;
         const filter = this.selector.where ?? {};
         const { orderBy: order, skip, take } = this.options ?? {};
         const orderBy = this.transformOrderBy((order && !Array.isArray(order) ? [order] : order) ?? []);
+        const take_ = !isNaN(+take) ? +take : 15;
+        const skip_ = !isNaN(+skip) ? +skip : 0;
         const rootKey = this.getStructureKeys(structure)[0];
         const rootStructure = structure[rootKey];
-        const entity = this.getEntity(rootKey).ref.entity;
-        const rootEntity = entity.toLowerCase();
+        const entity = this.getEntity(rootKey);
+        const rootEntity = entity.ref.entity.toLowerCase();
         const aliasMapping = {};
         let hasTextSearch = false;
         let textSearchQuery = null;
-        const searchQueryFilterProp = `${rootEntity}.q`;
+        const searchQueryFilterProp = `${rootKey}.q`;
         if (searchQueryFilterProp in filter) {
             if (!filter[searchQueryFilterProp]) {
                 delete filter[searchQueryFilterProp];
@@ -397,179 +572,109 @@ class QueryBuilder {
                 delete filter[searchQueryFilterProp];
             }
         }
-        const joinParts = this.buildQueryParts(rootStructure, "", entity, rootKey, [], 0, aliasMapping);
+        const filterSortStructure = (0, utils_1.unflattenObjectKeys)({
+            ...(this.rawConfig?.filters
+                ? (0, utils_1.unflattenObjectKeys)(this.rawConfig?.filters)
+                : {}),
+            ...orderBy,
+        })[rootKey] ?? {};
+        const joinParts = this.buildQueryParts(filterSortStructure, "", entity, rootKey, [], 0, aliasMapping);
         const rootAlias = aliasMapping[rootKey];
-        const selectParts = !returnIdOnly
-            ? this.buildSelectParts(selectOnlyStructure[rootKey], rootKey, aliasMapping)
-            : { [rootKey + ".id"]: `${rootAlias}.id` };
-        queryBuilder.select(selectParts);
-        queryBuilder.from(`cat_${rootEntity} AS ${this.getShortAlias(aliasMapping, rootEntity)}`);
+        const innerQueryBuilder = this.knex.queryBuilder();
+        // Outer query to select the full data based on the paginated IDs
+        const outerQueryBuilder = this.knex.queryBuilder();
+        innerQueryBuilder.distinct(`${rootAlias}.id`);
+        const orderBySelects = [];
+        const orderByClauses = [];
+        for (const aliasPath in orderBy) {
+            const path = aliasPath.split(".");
+            const field = path.pop();
+            const attr = path.join(".");
+            const alias = aliasMapping[attr];
+            const direction = orderBy[aliasPath];
+            const pgType = this.getPostgresCastType(attr, [field]);
+            const hasId = field === "id";
+            let orderExpression = `${rootAlias}.id ${direction}`;
+            if (alias) {
+                const aggregateAlias = `"${aliasPath}_agg"`;
+                let aggregateExpression = `(${alias}.data->>'${field}')${pgType.cast}`;
+                if (hasId) {
+                    aggregateExpression = `${alias}.id`;
+                }
+                else {
+                    orderBySelects.push(direction === "ASC"
+                        ? this.knex.raw(`MIN(${aggregateExpression}) AS ${aggregateAlias}`)
+                        : this.knex.raw(`MAX(${aggregateExpression}) AS ${aggregateAlias}`));
+                    orderExpression = `${aggregateAlias} ${direction}`;
+                }
+                outerQueryBuilder.orderByRaw(`${aggregateExpression} ${direction}`);
+            }
+            orderByClauses.push(orderExpression);
+        }
+        // Add ordering columns to the select list of the inner query
+        if (orderBySelects.length > 0) {
+            innerQueryBuilder.select(orderBySelects);
+        }
+        innerQueryBuilder.from(`cat_${(0, normalze_table_name_1.normalizeTableName)(rootEntity)} AS ${this.getShortAlias(aliasMapping, rootKey)}`);
         joinParts.forEach((joinPart) => {
-            queryBuilder.joinRaw(joinPart);
+            innerQueryBuilder.joinRaw(joinPart);
         });
-        let searchWhereParts = [];
         if (hasTextSearch) {
-            /**
-             * Build the search where parts for the query,.
-             * Apply the search query to the search vector column for every joined tabled except
-             * the pivot joined table.
-             */
-            searchWhereParts = [
-                `${this.getShortAlias(aliasMapping, rootEntity)}.${__classPrivateFieldGet(this, _QueryBuilder_searchVectorColumnName, "f")} @@ plainto_tsquery('simple', '${textSearchQuery}')`,
+            const searchWhereParts = [
+                `${rootAlias}.${__classPrivateFieldGet(this, _QueryBuilder_searchVectorColumnName, "f")} @@ plainto_tsquery('simple', ?)`,
                 ...joinParts.flatMap((part) => {
                     const aliases = part
                         .split(" as ")
                         .flatMap((chunk) => chunk.split(" on "))
                         .filter((alias) => alias.startsWith('"t_') && !alias.includes("_ref"));
-                    return aliases.map((alias) => `${alias}.${__classPrivateFieldGet(this, _QueryBuilder_searchVectorColumnName, "f")} @@ plainto_tsquery('simple', '${textSearchQuery}')`);
+                    return aliases.map((alias) => `${alias}.${__classPrivateFieldGet(this, _QueryBuilder_searchVectorColumnName, "f")} @@ plainto_tsquery('simple', ?)`);
                 }),
             ];
-            queryBuilder.whereRaw(`(${searchWhereParts.join(" OR ")})`);
+            innerQueryBuilder.whereRaw(`(${searchWhereParts.join(" OR ")})`, Array(searchWhereParts.length).fill(textSearchQuery));
         }
-        // WHERE clause
-        this.parseWhere(aliasMapping, filter, queryBuilder);
-        // ORDER BY clause
-        for (const aliasPath in orderBy) {
-            const path = aliasPath.split(".");
-            const field = path.pop();
-            const attr = path.join(".");
-            const pgType = this.getPostgresCastType(attr, [field]);
-            const alias = aliasMapping[attr];
-            const direction = orderBy[aliasPath];
-            queryBuilder.orderByRaw(`(${alias}.data->>'${field}')${pgType.cast}` + " " + direction);
+        this.parseWhere(aliasMapping, filter, innerQueryBuilder);
+        // Group by root ID in the inner query
+        if (orderBySelects.length > 0) {
+            innerQueryBuilder.groupBy(`${rootAlias}.id`);
         }
-        let take_ = !isNaN(+take) ? +take : 15;
-        let skip_ = !isNaN(+skip) ? +skip : 0;
-        let cte = "";
-        if (hasPagination) {
-            cte = this.buildCTEData({
-                hasCount,
-                searchWhereParts,
-                take: take_,
-                skip: skip_,
-                orderBy,
-            });
-            if (hasCount) {
-                queryBuilder.select(this.knex.raw("pd.count_total"));
-            }
-            queryBuilder.joinRaw(`JOIN paginated_data AS pd ON ${rootAlias}.id = pd.id`);
+        if (orderByClauses.length > 0) {
+            innerQueryBuilder.orderByRaw(orderByClauses.join(", "));
         }
-        return cte + queryBuilder.toQuery();
-    }
-    buildCTEData({ hasCount, searchWhereParts = [], skip, take, orderBy, }) {
-        const queryBuilder = this.knex.queryBuilder();
-        const hasWhere = (0, utils_1.isPresent)(this.rawConfig?.filters) || (0, utils_1.isPresent)(orderBy);
-        const structure = hasWhere && !searchWhereParts.length
-            ? (0, utils_1.unflattenObjectKeys)({
-                ...(this.rawConfig?.filters
-                    ? (0, utils_1.unflattenObjectKeys)(this.rawConfig?.filters)
-                    : {}),
-                ...orderBy,
-            })
-            : this.requestedFields;
-        const rootKey = this.getStructureKeys(structure)[0];
-        const rootStructure = structure[rootKey];
-        const entity = this.getEntity(rootKey).ref.entity;
-        const rootEntity = entity.toLowerCase();
-        const aliasMapping = {};
-        const joinParts = this.buildQueryParts(rootStructure, "", entity, rootKey, [], 0, aliasMapping);
-        const rootAlias = aliasMapping[rootKey];
-        queryBuilder.select(this.knex.raw(`${rootAlias}.id as id`));
-        queryBuilder.from(`cat_${rootEntity} AS ${this.getShortAlias(aliasMapping, rootEntity)}`);
-        if (hasWhere) {
-            joinParts.forEach((joinPart) => {
-                queryBuilder.joinRaw(joinPart);
-            });
-            if (searchWhereParts.length) {
-                queryBuilder.whereRaw(`(${searchWhereParts.join(" OR ")})`);
-            }
-            this.parseWhere(aliasMapping, this.selector.where, queryBuilder);
+        else {
+            innerQueryBuilder.orderBy(`${rootAlias}.id`, "ASC");
         }
-        // ORDER BY clause
-        const orderAliases = [];
-        for (const aliasPath in orderBy) {
-            const path = aliasPath.split(".");
-            const field = path.pop();
-            const attr = path.join(".");
-            const pgType = this.getPostgresCastType(attr, [field]);
-            const alias = aliasMapping[attr];
-            const direction = orderBy[aliasPath];
-            const orderAlias = `"${alias}.data->>'${field}'"`;
-            orderAliases.push(orderAlias + " " + direction);
-            // transform the order by clause to a select MIN/MAX
-            queryBuilder.select(direction === "ASC"
-                ? this.knex.raw(`MIN((${alias}.data->>'${field}')${pgType.cast}) as ${orderAlias}`)
-                : this.knex.raw(`MAX((${alias}.data->>'${field}')${pgType.cast}) as ${orderAlias}`));
+        // Count query to estimate the number of results in parallel
+        let countQuery;
+        if (hasCount) {
+            const estimateQuery = innerQueryBuilder.clone();
+            estimateQuery.clearSelect().select(1);
+            estimateQuery.clearOrder();
+            estimateQuery.clearCounters();
+            countQuery = this.knex.raw(`SELECT count_estimate(?) AS estimate_count`, estimateQuery.toQuery());
         }
-        queryBuilder.groupByRaw(`${rootAlias}.id`);
-        const countSubQuery = hasCount
-            ? `, (SELECT count(id) FROM data_select) as count_total`
-            : "";
-        return `
-      WITH data_select AS (
-        ${queryBuilder.toQuery()}
-      ),
-      paginated_data AS (
-        SELECT id ${countSubQuery}
-        FROM data_select
-        ${orderAliases.length ? "ORDER BY " + orderAliases.join(", ") : ""}
-        LIMIT ${take}
-        ${skip ? `OFFSET ${skip}` : ""}
-      )
-    `;
+        // Apply pagination to the inner query
+        if (hasPagination) {
+            innerQueryBuilder.limit(take_);
+            if (skip_ > 0) {
+                innerQueryBuilder.offset(skip_);
+            }
+        }
+        const innerQueryAlias = "paginated_ids";
+        outerQueryBuilder.from(`cat_${(0, normalze_table_name_1.normalizeTableName)(rootEntity)} AS ${this.getShortAlias(aliasMapping, rootKey)}`);
+        outerQueryBuilder.joinRaw(`INNER JOIN (${innerQueryBuilder.toQuery()}) AS ${innerQueryAlias} ON ${rootAlias}.id = ${innerQueryAlias}.id`);
+        this.parseWhere(aliasMapping, filter, outerQueryBuilder);
+        const joinPartsOuterQuery = this.buildQueryParts(rootStructure, "", entity, rootKey, [], 0, aliasMapping);
+        joinPartsOuterQuery.forEach((joinPart) => {
+            outerQueryBuilder.joinRaw(joinPart);
+        });
+        const finalSelectParts = this.buildSelectParts(selectOnlyStructure[rootKey], rootKey, aliasMapping);
+        outerQueryBuilder.select(finalSelectParts);
+        const finalSql = outerQueryBuilder.toQuery();
+        return {
+            sql: finalSql,
+            sqlCount: countQuery?.toQuery?.(),
+        };
     }
-    // NOTE: We are keeping the bellow code for now as reference to alternative implementation for us. DO NOT REMOVE
-    // public buildQueryCount(): string {
-    //   const queryBuilder = this.knex.queryBuilder()
-    //   const hasWhere = isPresent(this.rawConfig?.filters)
-    //   const structure = hasWhere ? this.rawConfig?.filters! : this.structure
-    //   const rootKey = this.getStructureKeys(structure)[0]
-    //   const rootStructure = structure[rootKey] as Select
-    //   const entity = this.getEntity(rootKey)!.ref.entity
-    //   const rootEntity = entity.toLowerCase()
-    //   const aliasMapping: { [path: string]: string } = {}
-    //   const joinParts = this.buildQueryParts(
-    //     rootStructure,
-    //     "",
-    //     entity,
-    //     rootKey,
-    //     [],
-    //     0,
-    //     aliasMapping
-    //   )
-    //   const rootAlias = aliasMapping[rootKey]
-    //   queryBuilder.select(this.knex.raw(`COUNT(${rootAlias}.id) as count`))
-    //   queryBuilder.from(
-    //     `cat_${rootEntity} AS ${this.getShortAlias(aliasMapping, rootEntity)}`
-    //   )
-    //   const self = this
-    //   if (hasWhere && joinParts.length) {
-    //     const fromExistsRaw = joinParts.shift()!
-    //     const [joinPartsExists, fromExistsPart] =
-    //       fromExistsRaw.split(" left join ")
-    //     const [fromExists, whereExists] = fromExistsPart.split(" on ")
-    //     joinParts.unshift(joinPartsExists)
-    //     queryBuilder.whereExists(function () {
-    //       this.select(self.knex.raw(`1`))
-    //       this.from(self.knex.raw(`${fromExists}`))
-    //       this.joinRaw(joinParts.join("\n"))
-    //       if (hasWhere) {
-    //         self.parseWhere(aliasMapping, self.selector.where!, this)
-    //         this.whereRaw(self.knex.raw(whereExists))
-    //         return
-    //       }
-    //       this.whereRaw(self.knex.raw(whereExists))
-    //     })
-    //   } else {
-    //     queryBuilder.whereExists(function () {
-    //       this.select(self.knex.raw(`1`))
-    //       if (hasWhere) {
-    //         self.parseWhere(aliasMapping, self.selector.where!, this)
-    //       }
-    //     })
-    //   }
-    //   return queryBuilder.toQuery()
-    // }
     buildObjectFromResultset(resultSet) {
         const structure = this.structure;
         const rootKey = this.getStructureKeys(structure)[0];