@resolveio/server-lib 20.12.37 → 20.12.38

package/methods/report-builder.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -48,27 +59,63 @@ function loadReportBuilderMethods(methodManager) {
             check: new simpl_schema_1.default({
                 collection_root: {
                     type: String
+                },
+                collectionJoins: {
+                    type: Array,
+                    optional: true
+                },
+                'collectionJoins.$': {
+                    type: Object
+                },
+                'collectionJoins.$.collection': {
+                    type: String
+                },
+                'collectionJoins.$.alias': {
+                    type: String,
+                    optional: true
+                },
+                'collectionJoins.$.local_key': {
+                    type: String,
+                    optional: true
+                },
+                'collectionJoins.$.foreign_key': {
+                    type: String,
+                    optional: true
                 }
             }),
-            function: function (collection_root) {
-                var lookupSchemaData = (0, schema_report_builder_1.getReportLookupSchemas)(collection_root).sort(function (a, b) { return a.collection_name.localeCompare(b.collection_name); });
-                var lookupSchemaTree = lookupSchemaData.find(function (a) { return a.is_root === true; }).tree;
-                var treeItems = (0, schema_report_builder_1.buildTree)(collection_root, lookupSchemaTree);
-                Object.keys(lookupSchemaTree).filter(function (a) { return a.endsWith('(Lookup)'); }).forEach(function (lookup) {
-                    var fieldPath = lookup.split('.');
-                    var field = null;
-                    fieldPath.forEach(function (path) {
-                        if (!field) {
-                            field = treeItems.find(function (a) { return a.fieldName === path; });
-                        }
-                        else {
-                            field = field.children.find(function (a) { return a.fieldName === path; });
-                        }
+            function: function (collection_root, collectionJoins) {
+                if (collectionJoins === void 0) { collectionJoins = []; }
+                var baseRootTree = buildCollectionTree(collection_root);
+                var collectionTrees = [
+                    {
+                        collection: collection_root,
+                        alias: (0, common_1.toTitleCase)(collection_root.replace(/\_/g, ' ').replace(/-/g, ' ')),
+                        lookup_as: '',
+                        tree: (0, common_1.deepCopy)(baseRootTree)
+                    }
+                ];
+                var rootTree = baseRootTree;
+                (collectionJoins || []).forEach(function (join, joinIndex) {
+                    var joinLocalKey = join.local_key && join.local_key.trim().length ? join.local_key : '_id';
+                    var joinForeignKey = join.foreign_key && join.foreign_key.trim().length ? join.foreign_key : '_id';
+                    var joinAlias = buildJoinAlias(join, joinIndex);
+                    var joinNode = buildJoinLookupNode(collection_root, __assign(__assign({}, join), { local_key: joinLocalKey, foreign_key: joinForeignKey }), joinAlias);
+                    var joinTree = buildCollectionTree(join.collection, joinNode);
+                    joinNode.children = joinTree.children;
+                    joinNode.is_join = true;
+                    rootTree.children.push(joinNode);
+                    collectionTrees.push({
+                        collection: join.collection,
+                        alias: joinAlias,
+                        lookup_as: joinNode.lookup_as,
+                        tree: (0, common_1.deepCopy)(joinTree)
                     });
-                    field.children = (0, schema_report_builder_1.buildTree)(lookupSchemaTree[lookup].lookup_collection, lookupSchemaData.find(function (a) { return a.collection_name === lookupSchemaTree[lookup].lookup_collection; }).tree, field);
                 });
-                // console.log('----------- Tree Items -----------', treeItems);
-                return Promise.resolve({ isLeaf: false, children: treeItems });
+                return Promise.resolve({
+                    isLeaf: false,
+                    children: rootTree.children,
+                    trees: collectionTrees
+                });
             }
         },
         reportBuilderGetDistinctValue: {
@@ -82,8 +129,8 @@ function loadReportBuilderMethods(methodManager) {
                 return __awaiter(this, void 0, void 0, function () {
                     return __generator(this, function (_a) {
                         if (treeLeaf.fieldType === 'String') {
-                            if (treeLeaf.fieldPath.includes('(Lookup)')) {
-                                return [2 /*return*/, (0, schema_report_builder_1.mongoCommand)('distinct', treeLeaf.collection_name, treeLeaf.fieldPath.replace(/^.+\(.+\) \(Lookup\)\.\$\./g, '').replace(/\.\$/g, ''))];
+                            if (treeLeaf.fieldPath.includes('(Lookup') || treeLeaf.lookup_collection) {
+                                return [2 /*return*/, (0, schema_report_builder_1.mongoCommand)('distinct', treeLeaf.collection_name, treeLeaf.fieldPath.replace(/^.+\(.+\) \(Lookup.*\)\.\$\./g, '').replace(/\.\$/g, ''))];
                             }
                             else {
                                 return [2 /*return*/, (0, schema_report_builder_1.mongoCommand)('distinct', treeLeaf.collection_name, treeLeaf.fieldPath.replace(/\.\$/g, ''))];
@@ -189,7 +236,7 @@ function loadReportBuilderMethods(methodManager) {
             }),
             function: function (reportType_1, rootCollectionName_1, rootOptions_1) {
                 return __awaiter(this, arguments, void 0, function (reportType, rootCollectionName, rootOptions, filters, filterArrays, filterArrayFields, selectedFields, customFields, groupsRow, fieldsTotal, fieldsLink, date_field, date_interval, displayType) {
-                    var modelCollection, query_1, initialQueryMatchCondition_1, sizes_1, divFields_1, queryMatchConditionLookup_1, queryGroup_1, groupedSorts_1, queryProjection_1, _loop_1, i, res_1, err_1, tmpTotals_1, tmpRes;
+                    var modelCollection, lookupAliases, _a, rootFilters, lookupFilters, query_1, initialQueryMatchCondition_1, sizes_1, divFields_1, queryMatchConditionLookup_1, queryGroup_1, groupedSorts_1, queryProjection_1, _loop_1, i, res_1, err_1, tmpTotals_1, tmpRes;
                     if (filters === void 0) { filters = []; }
                     if (filterArrays === void 0) { filterArrays = []; }
                     if (filterArrayFields === void 0) { filterArrayFields = []; }
@@ -201,13 +248,15 @@ function loadReportBuilderMethods(methodManager) {
                     if (date_field === void 0) { date_field = ''; }
                     if (date_interval === void 0) { date_interval = ''; }
                     if (displayType === void 0) { displayType = ''; }
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
                             case 0:
                                 modelCollection = resolveio_server_app_1.ResolveIOServer.getMongoManager().collection(rootCollectionName);
                                 if (!!modelCollection) return [3 /*break*/, 1];
                                 throw new Error('Error in Report builder get results: Invalid collection');
                             case 1:
+                                lookupAliases = collectLookupAliases(selectedFields, filterArrayFields, groupsRow);
+                                _a = splitFiltersByLookup(filters, lookupAliases), rootFilters = _a.rootFilters, lookupFilters = _a.lookupFilters;
                                 query_1 = [];
                                 initialQueryMatchCondition_1 = {
                                     $and: []
@@ -221,14 +270,12 @@ function loadReportBuilderMethods(methodManager) {
                                 // 		]
                                 // 	});
                                 // });
-                                if (filters.filter(function (a) { return (!a['$or'] && !Object.keys(a).some(function (b) { return b.includes('(Lookup)'); })) || (a['$or'] && !a['$or'].some(function (b) { return Object.keys(b).some(function (c) { return c.includes('(Lookup)'); }); })); }).length) {
-                                    filters.filter(function (a) { return (!a['$or'] && !Object.keys(a).some(function (b) { return b.includes('(Lookup)'); })) || (a['$or'] && !a['$or'].some(function (b) { return Object.keys(b).some(function (c) { return c.includes('(Lookup)'); }); })); }).forEach(function (filter) {
-                                        initialQueryMatchCondition_1['$and'].push(filter);
-                                    });
+                                if (rootFilters.length) {
+                                    rootFilters.forEach(function (filter) { return initialQueryMatchCondition_1['$and'].push(filter); });
                                 }
                                 // Add filter to query
-                                // if (filters.filter(a => (!a['$or'] && !Object.keys(a).some(b => b.includes('(Lookup)'))) || (a['$or'] && !a['$or'].some(b => Object.keys(b).some(c => c.includes('(Lookup)'))))).length || selectedFields.filter(a => !a.fieldPath.includes('(Lookup')).length) {
-                                if (filters.filter(function (a) { return (!a['$or'] && !Object.keys(a).some(function (b) { return b.includes('(Lookup)'); })) || (a['$or'] && !a['$or'].some(function (b) { return Object.keys(b).some(function (c) { return c.includes('(Lookup)'); }); })); }).length) {
+                                // if (filters.filter(a => (!a['$or'] && !Object.keys(a).some(b => b.includes('(Lookup'))) || (a['$or'] && !a['$or'].some(b => Object.keys(b).some(c => c.includes('(Lookup)'))))).length || selectedFields.filter(a => !a.fieldPath.includes('(Lookup')).length) {
+                                if (initialQueryMatchCondition_1['$and'].length) {
                                     query_1.push({
                                         $match: initialQueryMatchCondition_1
                                     });
@@ -242,12 +289,12 @@ function loadReportBuilderMethods(methodManager) {
                                     var fieldPath = '';
                                     for (var i = 0; i < fieldData.length - 1; i++) {
                                         fieldPath += fieldData[i];
-                                        if (fieldPath.split('.$')[fieldPath.split('.$').length - 1].includes('(Lookup)')) {
+                                        if (filterField.lookup_collection || fieldPath.split('.$')[fieldPath.split('.$').length - 1].includes('(Lookup')) {
                                             if (!query_1.some(function (a) { return a.$lookup && a.$lookup.as === filterField.lookup_as.replace(/\.\$/g, ''); })) {
                                                 query_1.push({ $lookup: {
                                                         from: filterField.lookup_collection,
-                                                        localField: filterField.lookup_local_key,
-                                                        foreignField: filterField.lookup_foreign_key,
+                                                        localField: normalizeLookupField(filterField.lookup_local_key),
+                                                        foreignField: normalizeLookupField(filterField.lookup_foreign_key),
                                                         as: filterField.lookup_as.replace(/\.\$/g, '')
                                                     } });
                                                 sizes_1.push(filterField.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_'));
@@ -267,17 +314,18 @@ function loadReportBuilderMethods(methodManager) {
                                 // Groups - Lookups / Sizes / Unwinds
                                 groupsRow.forEach(function (row) {
                                     var _a, _b;
+                                    var _c;
                                     if (row.field.includes('$')) {
                                         var fieldData = row.field.split('.$');
                                         var fieldPath_1 = '';
                                         for (var i = 0; i < fieldData.length - 1; i++) {
                                             fieldPath_1 += fieldData[i];
-                                            if (fieldPath_1.split('.$')[fieldPath_1.split('.$').length - 1].includes('(Lookup)')) {
+                                            if (((_c = row.treeItem) === null || _c === void 0 ? void 0 : _c.lookup_collection) || fieldPath_1.split('.$')[fieldPath_1.split('.$').length - 1].includes('(Lookup')) {
                                                 if (!query_1.some(function (a) { return a.$lookup && a.$lookup.as === row.treeItem.lookup_as.replace(/\.\$/g, ''); })) {
                                                     query_1.push({ $lookup: {
                                                             from: row.treeItem.lookup_collection,
-                                                            localField: row.treeItem.lookup_local_key,
-                                                            foreignField: row.treeItem.lookup_foreign_key,
+                                                            localField: normalizeLookupField(row.treeItem.lookup_local_key),
+                                                            foreignField: normalizeLookupField(row.treeItem.lookup_foreign_key),
                                                             as: row.treeItem.lookup_as.replace(/\.\$/g, '')
                                                         } });
                                                     sizes_1.push(row.treeItem.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_'));
@@ -304,12 +352,12 @@ function loadReportBuilderMethods(methodManager) {
                                         var fieldPath_2 = '';
                                         for (var i = 0; i < fieldData.length - 1; i++) {
                                             fieldPath_2 += fieldData[i];
-                                            if (fieldPath_2.split('.$')[fieldPath_2.split('.$').length - 1].includes('(Lookup)')) {
+                                            if (field.lookup_collection || fieldPath_2.split('.$')[fieldPath_2.split('.$').length - 1].includes('(Lookup')) {
                                                 if (!query_1.some(function (a) { return a.$lookup && a.$lookup.as === field.lookup_as.replace(/\.\$/g, ''); })) {
                                                     query_1.push({ $lookup: {
                                                             from: field.lookup_collection,
-                                                            localField: field.lookup_local_key,
-                                                            foreignField: field.lookup_foreign_key,
+                                                            localField: normalizeLookupField(field.lookup_local_key),
+                                                            foreignField: normalizeLookupField(field.lookup_foreign_key),
                                                             as: field.lookup_as.replace(/\.\$/g, '')
                                                         } });
                                                     sizes_1.push(field.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_'));
@@ -317,7 +365,7 @@ function loadReportBuilderMethods(methodManager) {
                                                     query_1.push({ '$unwind': { path: '$' + field.lookup_as.replace(/\.\$/g, ''), preserveNullAndEmptyArrays: true } });
                                                 }
                                                 else {
-                                                    if (!fieldData[i].includes('(Lookup)')) {
+                                                    if (!fieldData[i].includes('(Lookup')) {
                                                         if (!query_1.some(function (a) { return a.$addFields && Object.keys(a.$addFields).includes('size_' + fieldPath_2.replace(/\./g, '_')); })) {
                                                             sizes_1.push(fieldPath_2.replace(/\./g, '_'));
                                                             query_1.push({ $addFields: (_b = {}, _b['size_' + fieldPath_2.replace(/\./g, '_')] = { $size: { $ifNull: ['$' + fieldPath_2, []] } }, _b) });
@@ -492,10 +540,8 @@ function loadReportBuilderMethods(methodManager) {
                                 queryMatchConditionLookup_1 = {
                                     $and: []
                                 };
-                                if (filters.filter(function (a) { return (!a['$or'] && Object.keys(a).some(function (b) { return b.includes('(Lookup)'); })) || (a['$or'] && a['$or'].some(function (b) { return Object.keys(b).some(function (c) { return c.includes('(Lookup)'); }); })); }).length) {
-                                    filters.filter(function (a) { return (!a['$or'] && Object.keys(a).some(function (b) { return b.includes('(Lookup)'); })) || (a['$or'] && a['$or'].some(function (b) { return Object.keys(b).some(function (c) { return c.includes('(Lookup)'); }); })); }).forEach(function (filter) {
-                                        queryMatchConditionLookup_1['$and'].push(filter);
-                                    });
+                                if (lookupFilters.length) {
+                                    lookupFilters.forEach(function (filter) { return queryMatchConditionLookup_1['$and'].push(filter); });
                                 }
                                 filterArrays.forEach(function (filter) {
                                     queryMatchConditionLookup_1['$and'].push(filter);
@@ -711,16 +757,14 @@ function loadReportBuilderMethods(methodManager) {
                                 }
                                 // SORT
                                 if (rootOptions.sort) {
-                                    query_1.push({
-                                        $sort: rootOptions.sort
-                                    });
+                                    appendSafeSort(query_1, rootOptions.sort, selectedFields, customFields);
                                 }
                                 if (reportType === 'Group' && groupsRow.length > 1) {
                                     _loop_1 = function (i) {
-                                        var _b;
+                                        var _c;
                                         var projQuery = { _id: 1 };
                                         projQuery[groupsRow[i].id] = {
-                                            _id: (_b = {}, _b[groupsRow[i].id] = '$_id.' + groupsRow[i].id, _b)
+                                            _id: (_c = {}, _c[groupsRow[i].id] = '$_id.' + groupsRow[i].id, _c)
                                         };
                                         if (i === groupsRow.length - 1) {
                                             selectedFields.forEach(function (field) {
@@ -781,7 +825,7 @@ function loadReportBuilderMethods(methodManager) {
                                             sortKeys_1.filter(function (a) { return !a.startsWith('_id.gr_'); }).forEach(function (key) {
                                                 sort_1[groupString_1 + key] = rootOptions.sort[key];
                                             });
-                                            query_1.push({ $sort: sort_1 });
+                                            appendSafeSort(query_1, sort_1, selectedFields, customFields);
                                         }
                                     };
                                     for (i = groupsRow.length - 1; i >= 1; i--) {
@@ -789,15 +833,15 @@ function loadReportBuilderMethods(methodManager) {
                                     }
                                 }
                                 res_1 = null;
-                                _a.label = 2;
+                                _b.label = 2;
                             case 2:
-                                _a.trys.push([2, 4, , 5]);
+                                _b.trys.push([2, 4, , 5]);
                                 return [4 /*yield*/, modelCollection.aggregate(query_1, { allowDiskUse: true, readPreference: this.serverConfig['ROOT_URL'] !== 'http://localhost:4200' ? 'secondary' : 'primary' }, true)];
                             case 3:
-                                res_1 = _a.sent();
+                                res_1 = _b.sent();
                                 return [3 /*break*/, 5];
                             case 4:
-                                err_1 = _a.sent();
+                                err_1 = _b.sent();
                                 console.log(err_1);
                                 return [3 /*break*/, 5];
                             case 5:
@@ -836,5 +880,209 @@ function loadReportBuilderMethods(methodManager) {
         }
     });
 }
+function buildCollectionTree(collectionName, lookupNode) {
+    var _a;
+    var lookupSchemaData = (0, schema_report_builder_1.getReportLookupSchemas)(collectionName).sort(function (a, b) { return a.collection_name.localeCompare(b.collection_name); });
+    var lookupSchemaTree = ((_a = lookupSchemaData.find(function (a) { return a.is_root === true; })) === null || _a === void 0 ? void 0 : _a.tree) || {};
+    var treeItems = (0, schema_report_builder_1.buildTree)(collectionName, lookupSchemaTree, lookupNode);
+    attachLookupChildren(treeItems, lookupSchemaData, lookupSchemaTree);
+    return { isLeaf: false, children: treeItems };
+}
+function attachLookupChildren(treeItems, lookupSchemaData, lookupSchemaTree) {
+    Object.keys(lookupSchemaTree || {}).filter(function (a) { return a.endsWith('(Lookup)'); }).forEach(function (lookup) {
+        var field = findFieldByPath(treeItems, lookup);
+        if (field) {
+            var lookupTree = lookupSchemaData.find(function (a) { return a.collection_name === lookupSchemaTree[lookup].lookup_collection; });
+            if (lookupTree) {
+                var childTree = (0, schema_report_builder_1.buildTree)(lookupSchemaTree[lookup].lookup_collection, lookupTree.tree, field);
+                attachLookupChildren(childTree, lookupSchemaData, lookupTree.tree);
+                field.children = childTree;
+            }
+        }
+    });
+}
+function findFieldByPath(treeItems, lookupPath) {
+    var fieldPath = lookupPath.split('.');
+    var field = null;
+    fieldPath.forEach(function (path) {
+        if (!field) {
+            field = treeItems.find(function (a) { return a.fieldName === path; });
+        }
+        else if (field.children) {
+            field = field.children.find(function (a) { return a.fieldName === path; });
+        }
+    });
+    return field;
+}
+function buildJoinLookupNode(collection_root, join, alias) {
+    return {
+        collection_name: collection_root,
+        columnName: alias,
+        fieldName: alias,
+        fieldType: 'Lookup',
+        fieldTypeName: 'Lookup',
+        distinctFieldValues: [],
+        fieldPath: alias,
+        fieldPathName: alias,
+        path: alias,
+        lookup_collection: join.collection,
+        lookup_local_key: join.local_key,
+        lookup_foreign_key: join.foreign_key,
+        lookup_as: alias,
+        text: alias,
+        value: alias,
+        isLeaf: false,
+        isActive: false,
+        isSelected: false,
+        is_join: false,
+        depth: 0,
+        leafValueType: '',
+        leafFormatType: '',
+        children: []
+    };
+}
+function buildJoinAlias(join, joinIndex) {
+    if (join.alias && join.alias.trim()) {
+        return join.alias.trim();
+    }
+    var joinName = (0, common_1.toTitleCase)(join.collection.replace(/\_/g, ' ').replace(/-/g, ' '));
+    var joinPath = (0, common_1.toTitleCase)(join.local_key.replace(/\.\$\./g, ' -> ').replace(/\./g, ' -> ').replace(/\_/g, ' '));
+    return "".concat(joinName, " (").concat(joinPath || 'Join', ") (Lookup ").concat(joinIndex + 1, ")");
+}
+function normalizeLookupField(path) {
+    if (!path) {
+        return path;
+    }
+    // Strip any lookup alias prefixes and ".$" tokens
+    var cleaned = path.replace(/\.\$/g, '');
+    // Remove leading alias like "Alias (Lookup 1)." or "Alias (Lookup 1).$."
+    cleaned = cleaned.replace(/^[^\.]*\(.*?Lookup.*?\)\.?/, '');
+    return cleaned;
+}
+function appendSafeSort(query, sortSpec, selectedFields, customFields) {
+    if (selectedFields === void 0) { selectedFields = []; }
+    if (customFields === void 0) { customFields = []; }
+    if (!sortSpec || !Object.keys(sortSpec).length) {
+        return;
+    }
+    var safeAddFields = {};
+    var safeSort = {};
+    Object.keys(sortSpec).forEach(function (key) {
+        if (key.startsWith('_id.')) {
+            safeSort[key] = sortSpec[key];
+            return;
+        }
+        if (isArrayLikeField(key, selectedFields, customFields)) {
+            var safeKey = 'sort_' + key.replace(/\./g, '_');
+            safeAddFields[safeKey] = {
+                $cond: [
+                    { $isArray: '$' + key },
+                    { $size: { $ifNull: ['$' + key, []] } },
+                    '$' + key
+                ]
+            };
+            safeSort[safeKey] = sortSpec[key];
+        }
+        else {
+            safeSort[key] = sortSpec[key];
+        }
+    });
+    if (Object.keys(safeAddFields).length) {
+        query.push({ $addFields: safeAddFields });
+    }
+    if (Object.keys(safeSort).length) {
+        query.push({ $sort: safeSort });
+    }
+}
+function isArrayLikeField(sortKey, selectedFields, customFields) {
+    if (selectedFields === void 0) { selectedFields = []; }
+    if (customFields === void 0) { customFields = []; }
+    var field = selectedFields.find(function (a) { return a.id === sortKey; });
+    var custom = customFields.find(function (a) { return a.selFieldId === sortKey; });
+    var leafValueType = field ? field.leafValueType : (custom ? custom.leafValueType : '');
+    return leafValueType !== 'Average' &&
+        leafValueType !== 'Sum' &&
+        leafValueType !== 'Count' &&
+        leafValueType !== 'Minimum' &&
+        leafValueType !== 'Maximum' &&
+        leafValueType !== 'First' &&
+        leafValueType !== 'Last' &&
+        leafValueType !== 'Unique';
+}
+function collectLookupAliases(selectedFields, filterArrayFields, groupsRow) {
+    if (selectedFields === void 0) { selectedFields = []; }
+    if (filterArrayFields === void 0) { filterArrayFields = []; }
+    if (groupsRow === void 0) { groupsRow = []; }
+    var aliases = new Set();
+    var addAlias = function (alias) {
+        var normalized = normalizeLookupAlias(alias);
+        if (normalized) {
+            aliases.add(normalized);
+        }
+    };
+    (selectedFields || []).forEach(function (field) {
+        if (field && (field.lookup_collection || (field.fieldPath && field.fieldPath.includes('(Lookup')))) {
+            addAlias(field.lookup_as || extractLookupAlias(field.fieldPath));
+        }
+    });
+    (filterArrayFields || []).forEach(function (field) {
+        if (field && (field.lookup_collection || (field.fieldPath && field.fieldPath.includes('(Lookup')))) {
+            addAlias(field.lookup_as || extractLookupAlias(field.fieldPath));
+        }
+    });
+    (groupsRow || []).forEach(function (group) {
+        if ((group === null || group === void 0 ? void 0 : group.treeItem) && (group.treeItem.lookup_collection || (group.treeItem.fieldPath && group.treeItem.fieldPath.includes('(Lookup')))) {
+            addAlias(group.treeItem.lookup_as || extractLookupAlias(group.treeItem.fieldPath));
+        }
+    });
+    return aliases;
+}
+function splitFiltersByLookup(filters, lookupAliases) {
+    if (filters === void 0) { filters = []; }
+    if (lookupAliases === void 0) { lookupAliases = new Set(); }
+    var rootFilters = [];
+    var lookupFilters = [];
+    (filters || []).forEach(function (filter) {
+        if (filterContainsLookup(filter, lookupAliases)) {
+            lookupFilters.push(filter);
+        }
+        else {
+            rootFilters.push(filter);
+        }
+    });
+    return { rootFilters: rootFilters, lookupFilters: lookupFilters };
+}
+function filterContainsLookup(filter, lookupAliases) {
+    if (!filter || typeof filter !== 'object') {
+        return false;
+    }
+    return Object.keys(filter).some(function (key) {
+        if (key === '$or' || key === '$and') {
+            var branch = filter[key];
+            return Array.isArray(branch) && branch.some(function (child) { return filterContainsLookup(child, lookupAliases); });
+        }
+        return isLookupPath(key, lookupAliases);
+    });
+}
+function isLookupPath(path, lookupAliases) {
+    if (!path) {
+        return false;
+    }
+    var normalizedPath = path.replace(/\.\$/g, '');
+    if (normalizedPath.includes('(Lookup')) {
+        return true;
+    }
+    var rootKey = normalizedPath.split('.')[0];
+    return lookupAliases.has(rootKey);
+}
+function extractLookupAlias(path) {
+    if (!path || !path.includes('(Lookup')) {
+        return '';
+    }
+    return path.replace(/\.\$/g, '').split('.')[0];
+}
+function normalizeLookupAlias(alias) {
+    return (alias || '').replace(/\.\$/g, '').trim();
+}
 
 //# sourceMappingURL=report-builder.js.map