@resolveio/server-lib 22.2.34 → 22.2.35

package/methods/report-builder.js

@@ -0,0 +1,3099 @@
+"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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadReportBuilderMethods = loadReportBuilderMethods;
+var simpl_schema_1 = require("simpl-schema");
+var report_builder_report_collection_1 = require("../collections/report-builder-report.collection");
+var user_collection_1 = require("../collections/user.collection");
+var openai_usage_ledger_manager_1 = require("../managers/openai-usage-ledger.manager");
+var pagination_model_1 = require("../models/pagination.model");
+var resolveio_server_app_1 = require("../resolveio-server-app");
+var codex_client_1 = require("../services/codex-client");
+var common_1 = require("../util/common");
+var report_builder_unwinds_1 = require("../util/report-builder-unwinds");
+var schema_report_builder_1 = require("../util/schema-report-builder");
+var tokenizer_1 = require("../util/tokenizer");
+var ai_terminal_1 = require("./ai-terminal");
+var DEFAULT_REPORT_BUILDER_CODEX_MODEL = 'gpt-5.3-codex';
+var DEFAULT_REPORT_BUILDER_CODEX_FALLBACK_MODEL = 'gpt-5.2-codex';
+var DEFAULT_REPORT_BUILDER_CODEX_TIMEOUT_MS = 60000;
+var reportBuilderCodexClient = null;
+function loadReportBuilderMethods(methodManager) {
+    methodManager.methods({
+        reportBuilderAiSuggest: {
+            check: new simpl_schema_1.default({
+                payload: {
+                    type: Object,
+                    blackbox: true
+                }
+            }),
+            function: function (payload) {
+                return __awaiter(this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, executeReportBuilderAi(payload || {}, this)];
+                            case 1: return [2 /*return*/, _a.sent()];
+                        }
+                    });
+                });
+            }
+        },
+        reportbuilderreportWithId: {
+            check: new simpl_schema_1.default({
+                id: {
+                    type: String
+                }
+            }),
+            function: function (id) {
+                return report_builder_report_collection_1.ReportBuilderReports.findOne({ _id: id });
+            }
+        },
+        reportBuilderBuildTree: {
+            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, 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)
+                    });
+                });
+                return Promise.resolve({
+                    isLeaf: false,
+                    children: rootTree.children,
+                    trees: collectionTrees
+                });
+            }
+        },
+        reportBuilderGetDistinctValue: {
+            check: new simpl_schema_1.default({
+                treeLeaf: {
+                    type: Object,
+                    blackbox: true
+                }
+            }),
+            function: function (treeLeaf) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var fieldPath;
+                    return __generator(this, function (_a) {
+                        if (treeLeaf.fieldType === 'String') {
+                            fieldPath = (treeLeaf && typeof treeLeaf.fieldPath === 'string') ? treeLeaf.fieldPath : '';
+                            if (fieldPath.includes('(Lookup') || treeLeaf.lookup_collection) {
+                                return [2 /*return*/, (0, schema_report_builder_1.mongoCommand)('distinct', treeLeaf.collection_name, fieldPath.replace(/^.+\(.+\) \(Lookup.*\)\.\$\./g, '').replace(/\.\$/g, ''))];
+                            }
+                            else {
+                                return [2 /*return*/, (0, schema_report_builder_1.mongoCommand)('distinct', treeLeaf.collection_name, fieldPath.replace(/\.\$/g, ''))];
+                            }
+                        }
+                        else {
+                            return [2 /*return*/, []];
+                        }
+                        return [2 /*return*/];
+                    });
+                });
+            }
+        },
+        reportBuilderGetResults: {
+            bypassSession: true,
+            check: new simpl_schema_1.default({
+                reportType: {
+                    type: String
+                },
+                rootCollectionName: {
+                    type: String
+                },
+                options: {
+                    type: pagination_model_1.PaginationOptionsSchema
+                },
+                filters: {
+                    type: Array,
+                    optional: true
+                },
+                'filters.$': {
+                    type: Object,
+                    blackbox: true,
+                    optional: true
+                },
+                filterArrays: {
+                    type: Array,
+                    optional: true
+                },
+                'filterArrays.$': {
+                    type: Object,
+                    blackbox: true,
+                    optional: true
+                },
+                filterArrayFields: {
+                    type: Array,
+                    optional: true
+                },
+                'filterArrayFields.$': {
+                    type: Object,
+                    blackbox: true,
+                    optional: true
+                },
+                selectedFields: {
+                    type: Array,
+                    optional: true
+                },
+                'selectedFields.$': {
+                    type: Object,
+                    optional: true,
+                    blackbox: true
+                },
+                customFields: {
+                    type: Array,
+                    optional: true
+                },
+                'customFields.$': {
+                    type: Object,
+                    optional: true,
+                    blackbox: true
+                },
+                groupsRow: {
+                    type: Array
+                },
+                'groupsRow.$': {
+                    type: Object,
+                    blackbox: true
+                },
+                fieldsTotal: {
+                    type: Array
+                },
+                'fieldsTotal.$': {
+                    type: Object,
+                    blackbox: true
+                },
+                fieldsLink: {
+                    type: Array
+                },
+                'fieldsLink.$': {
+                    type: Object,
+                    blackbox: true
+                },
+                date_field: {
+                    type: String,
+                    optional: true
+                },
+                date_interval: {
+                    type: String,
+                    optional: true
+                },
+                displayType: {
+                    type: String,
+                    optional: true
+                }
+            }),
+            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, datePaths, reportBuilderTimezone, lookupAliases, _a, rootFilters_1, lookupFilters_1, additionalCollectionsMap_1, additionalCollections, unionQuery_1, _b, sortToUse, layoutSortAdd, remappedFilters, remappedArrayFilters, postMatchAnd, readPreference_1, queryResult_1, err_1, tmpRes_1, query_1, initialQueryMatchCondition_1, sizes_1, divFields_1, queryMatchConditionLookup_1, queryGroup_1, groupedSorts_1, dateFieldPath, dateFieldExpr, utcHourExpr, utcMinuteExpr, utcSecondExpr, utcDayExpr, tzDayExpr, useUtcForDateOnlyExpr, groupingTimezoneExpr, queryProjection_1, _loop_1, i, readPreference, queryResult, err_2, tmpRes;
+                    if (filters === void 0) { filters = []; }
+                    if (filterArrays === void 0) { filterArrays = []; }
+                    if (filterArrayFields === void 0) { filterArrayFields = []; }
+                    if (selectedFields === void 0) { selectedFields = []; }
+                    if (customFields === void 0) { customFields = []; }
+                    if (groupsRow === void 0) { groupsRow = []; }
+                    if (fieldsTotal === void 0) { fieldsTotal = []; }
+                    if (fieldsLink === void 0) { fieldsLink = []; }
+                    if (date_field === void 0) { date_field = ''; }
+                    if (date_interval === void 0) { date_interval = ''; }
+                    if (displayType === void 0) { displayType = ''; }
+                    return __generator(this, function (_c) {
+                        switch (_c.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:
+                                filters = expandLayoutColumnFilters(filters, selectedFields);
+                                filterArrays = expandLayoutColumnFilters(filterArrays, selectedFields);
+                                datePaths = collectRootDatePaths(rootCollectionName);
+                                if (datePaths.size) {
+                                    coerceDateFilters(filters, datePaths);
+                                    coerceDateFilters(filterArrays, datePaths);
+                                }
+                                reportBuilderTimezone = process.env.TZ_CLIENT || 'America/Chicago';
+                                lookupAliases = collectLookupAliases(selectedFields, filterArrayFields, groupsRow);
+                                _a = splitFiltersByLookup(filters, lookupAliases), rootFilters_1 = _a.rootFilters, lookupFilters_1 = _a.lookupFilters;
+                                additionalCollectionsMap_1 = new Map();
+                                (selectedFields || [])
+                                    .filter(function (f) {
+                                    return f &&
+                                        f.lookup_collection &&
+                                        (!f.lookup_local_key || !f.lookup_foreign_key);
+                                })
+                                    .forEach(function (f) {
+                                    var alias = f.lookup_as || f.lookup_collection;
+                                    var key = "".concat(f.lookup_collection, "::").concat(alias);
+                                    if (!additionalCollectionsMap_1.has(key)) {
+                                        additionalCollectionsMap_1.set(key, { collection: f.lookup_collection, alias: alias });
+                                    }
+                                });
+                                additionalCollections = Array.from(additionalCollectionsMap_1.values());
+                                if (!additionalCollections.length) return [3 /*break*/, 6];
+                                unionQuery_1 = buildCollectionPipeline(rootCollectionName, '', selectedFields, filters.concat(rootFilters_1 || []), filterArrays.concat(lookupFilters_1 || []), true);
+                                additionalCollections.forEach(function (cfg) {
+                                    unionQuery_1.push({
+                                        $unionWith: {
+                                            coll: cfg.collection,
+                                            pipeline: buildCollectionPipeline(cfg.collection, cfg.alias, selectedFields, filters.concat(rootFilters_1 || []), filterArrays.concat(lookupFilters_1 || []), false)
+                                        }
+                                    });
+                                });
+                                if (rootOptions.sort) {
+                                    _b = buildLayoutSortSpec(rootOptions.sort, selectedFields), sortToUse = _b.sortSpec, layoutSortAdd = _b.addFields;
+                                    if (Object.keys(layoutSortAdd).length) {
+                                        unionQuery_1.push({ $addFields: layoutSortAdd });
+                                    }
+                                    appendSafeSort(unionQuery_1, sortToUse, selectedFields, customFields);
+                                }
+                                remappedFilters = remapFiltersToIds(filters.concat(rootFilters_1 || []), selectedFields);
+                                remappedArrayFilters = remapFiltersToIds(filterArrays.concat(lookupFilters_1 || []), selectedFields);
+                                postMatchAnd = [];
+                                if (remappedFilters.length) {
+                                    postMatchAnd.push.apply(postMatchAnd, __spreadArray([], __read(remappedFilters), false));
+                                }
+                                if (remappedArrayFilters.length) {
+                                    postMatchAnd.push.apply(postMatchAnd, __spreadArray([], __read(remappedArrayFilters), false));
+                                }
+                                if (postMatchAnd.length) {
+                                    unionQuery_1.push({ $match: { $and: postMatchAnd } });
+                                }
+                                readPreference_1 = this.serverConfig['ROOT_URL'] !== 'http://localhost:4200' ? 'secondary' : 'primary';
+                                queryResult_1 = {
+                                    count: 0,
+                                    results: [],
+                                    totals: {}
+                                };
+                                _c.label = 2;
+                            case 2:
+                                _c.trys.push([2, 4, , 5]);
+                                return [4 /*yield*/, executeReportBuilderQuery(modelCollection, unionQuery_1, rootOptions, fieldsTotal, selectedFields, customFields, readPreference_1)];
+                            case 3:
+                                queryResult_1 = _c.sent();
+                                return [3 /*break*/, 5];
+                            case 4:
+                                err_1 = _c.sent();
+                                console.log(err_1);
+                                return [3 /*break*/, 5];
+                            case 5:
+                                tmpRes_1 = [{
+                                        count: queryResult_1.count,
+                                        results: queryResult_1.results,
+                                        totals: queryResult_1.totals
+                                    }];
+                                return [2 /*return*/, tmpRes_1];
+                            case 6:
+                                query_1 = [];
+                                initialQueryMatchCondition_1 = {
+                                    $and: []
+                                };
+                                // selectedFields.filter(a => a.collection_name === rootCollectionName).forEach(field => {
+                                // 	initialQueryMatchCondition['$and'].push({
+                                // 		$and: [
+                                // 			{[field.fieldPath.replace(/\.\$/g, '')]: {$exists: 1}},
+                                // 			// {[field.fieldPath.replace(/\.\$/g, '')]: {$ne: ''}},
+                                // 			{[field.fieldPath.replace(/\.\$/g, '')]: {$ne: null}},
+                                // 		]
+                                // 	});
+                                // });
+                                if (rootFilters_1.length) {
+                                    rootFilters_1.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 (initialQueryMatchCondition_1['$and'].length) {
+                                    query_1.push({
+                                        $match: initialQueryMatchCondition_1
+                                    });
+                                }
+                                // Add count
+                                query_1.push({ $addFields: { count: { $sum: 1 } } });
+                                sizes_1 = [];
+                                filterArrayFields.filter(function (a) { return a.fieldPath; }).forEach(function (filterField) {
+                                    var fieldData = filterField.fieldPath.split('.$');
+                                    var fieldPath = '';
+                                    var _loop_2 = function (i) {
+                                        var _a, _b;
+                                        fieldPath += fieldData[i];
+                                        if (filterField.lookup_collection || fieldPath.split('.$')[fieldPath.split('.$').length - 1].includes('(Lookup')) {
+                                            (0, report_builder_unwinds_1.ensureLookupLocalKeyUnwinds)({
+                                                query: query_1,
+                                                sizes: sizes_1,
+                                                lookupLocalKey: filterField.lookup_local_key || '',
+                                                lookupAs: filterField.lookup_as || ''
+                                            });
+                                            var lookupAs_1 = filterField.lookup_as.replace(/\.\$/g, '');
+                                            if (!query_1.some(function (a) { return a.$lookup && a.$lookup.as === lookupAs_1; })) {
+                                                query_1.push({ $lookup: {
+                                                        from: filterField.lookup_collection,
+                                                        localField: (0, report_builder_unwinds_1.normalizeLookupField)(filterField.lookup_local_key),
+                                                        foreignField: (0, report_builder_unwinds_1.normalizeLookupField)(filterField.lookup_foreign_key),
+                                                        as: lookupAs_1
+                                                    } });
+                                                var lookupSizeKey = filterField.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_');
+                                                sizes_1.push(lookupSizeKey);
+                                                var lookupSourceExpr = '$' + lookupAs_1;
+                                                query_1.push({ $addFields: (_a = {}, _a['size_' + lookupSizeKey] = { $size: { $cond: [{ $isArray: lookupSourceExpr }, lookupSourceExpr, []] } }, _a) });
+                                                var unwindPath = '$' + lookupAs_1;
+                                                query_1.push({ '$unwind': { path: unwindPath, preserveNullAndEmptyArrays: true } });
+                                            }
+                                        }
+                                        else {
+                                            if (!query_1.some(function (a) { return a.$addFields && Object.keys(a.$addFields).includes('size_' + fieldPath.replace(/\./g, '_')); })) {
+                                                sizes_1.push(fieldPath.replace(/\./g, '_'));
+                                                var sourceExpr = '$' + fieldPath;
+                                                query_1.push({ $addFields: (_b = {}, _b['size_' + fieldPath.replace(/\./g, '_')] = { $size: { $cond: [{ $isArray: sourceExpr }, sourceExpr, []] } }, _b) });
+                                                var unwindPath = '$' + fieldPath;
+                                                query_1.push({ '$unwind': { path: unwindPath, preserveNullAndEmptyArrays: true } });
+                                            }
+                                        }
+                                    };
+                                    for (var i = 0; i < fieldData.length - 1; i++) {
+                                        _loop_2(i);
+                                    }
+                                });
+                                // Groups - Lookups / Sizes / Unwinds
+                                groupsRow.forEach(function (row) {
+                                    var _a, _b, _c;
+                                    var rowField = (row && typeof row.field === 'string') ? row.field : '';
+                                    if (rowField.includes('$')) {
+                                        var fieldData = rowField.split('.$');
+                                        var fieldPath_1 = '';
+                                        var _loop_3 = function (i) {
+                                            var _d, _e;
+                                            fieldPath_1 += fieldData[i];
+                                            var lastSegment = fieldPath_1.split('.$')[fieldPath_1.split('.$').length - 1];
+                                            var hasLookup = !!((_a = row.treeItem) === null || _a === void 0 ? void 0 : _a.lookup_collection) || (lastSegment || '').includes('(Lookup');
+                                            if (hasLookup && ((_b = row.treeItem) === null || _b === void 0 ? void 0 : _b.lookup_collection) && ((_c = row.treeItem) === null || _c === void 0 ? void 0 : _c.lookup_as)) {
+                                                (0, report_builder_unwinds_1.ensureLookupLocalKeyUnwinds)({
+                                                    query: query_1,
+                                                    sizes: sizes_1,
+                                                    lookupLocalKey: row.treeItem.lookup_local_key || '',
+                                                    lookupAs: row.treeItem.lookup_as || ''
+                                                });
+                                                var lookupAsRaw = row.treeItem.lookup_as || '';
+                                                var lookupAs_2 = lookupAsRaw.replace(/\.\$/g, '');
+                                                if (!query_1.some(function (a) { return a.$lookup && a.$lookup.as === lookupAs_2; })) {
+                                                    query_1.push({ $lookup: {
+                                                            from: row.treeItem.lookup_collection,
+                                                            localField: (0, report_builder_unwinds_1.normalizeLookupField)(row.treeItem.lookup_local_key || ''),
+                                                            foreignField: (0, report_builder_unwinds_1.normalizeLookupField)(row.treeItem.lookup_foreign_key || ''),
+                                                            as: lookupAs_2
+                                                        } });
+                                                    var sizeKey = lookupAsRaw.replace(/\.\$\./g, '_').replace(/\./g, '_');
+                                                    sizes_1.push(sizeKey);
+                                                    var sourceExpr = '$' + lookupAs_2;
+                                                    query_1.push({ $addFields: (_d = {}, _d['size_' + sizeKey] = { $size: { $cond: [{ $isArray: sourceExpr }, sourceExpr, []] } }, _d) });
+                                                    var unwindPath = '$' + lookupAs_2;
+                                                    query_1.push({ '$unwind': { path: unwindPath, preserveNullAndEmptyArrays: true } });
+                                                }
+                                            }
+                                            else {
+                                                if (!query_1.some(function (a) { return a.$addFields && Object.keys(a.$addFields).includes('size_' + fieldPath_1.replace(/\.\$\./g, '.').replace(/\./g, '_')); })) {
+                                                    var sizeKey = fieldPath_1.replace(/\.\$\./g, '.').replace(/\./g, '_');
+                                                    sizes_1.push(sizeKey);
+                                                    var sourceExpr = '$' + fieldPath_1.replace(/\.\$\./g, '.');
+                                                    query_1.push({ $addFields: (_e = {}, _e['size_' + sizeKey] = { $size: { $cond: [{ $isArray: sourceExpr }, sourceExpr, []] } }, _e) });
+                                                    var unwindPath = '$' + fieldPath_1.replace(/\.\$\./g, '.');
+                                                    query_1.push({ '$unwind': { path: unwindPath, preserveNullAndEmptyArrays: true } });
+                                                }
+                                            }
+                                            fieldPath_1 += '.$';
+                                        };
+                                        for (var i = 0; i < fieldData.length - 1; i++) {
+                                            _loop_3(i);
+                                        }
+                                    }
+                                });
+                                (0, report_builder_unwinds_1.applyLinkFieldUnwinds)({
+                                    query: query_1,
+                                    sizes: sizes_1,
+                                    fieldsLink: fieldsLink,
+                                    selectedFields: selectedFields,
+                                    filterArrayFields: filterArrayFields,
+                                    groupsRow: groupsRow
+                                });
+                                divFields_1 = { $addFields: {} };
+                                fieldsTotal.filter(function (a) { return a.type === 'sum'; }).forEach(function (total) {
+                                    selectedFields.filter(function (a) { return a.fieldType === 'Number' || a.leafValueType === 'Count'; }).forEach(function (field) {
+                                        var fieldPath = (field && typeof field.fieldPath === 'string') ? field.fieldPath : '';
+                                        if (!fieldPath && field.leafValueType !== 'Count') {
+                                            return;
+                                        }
+                                        var multFields = [];
+                                        if (!fieldPath.includes('.$')) {
+                                            sizes_1.forEach(function (size) {
+                                                multFields.push({ $cond: { if: { $gt: ['$size_' + size, 0] }, then: '$size_' + size, else: 1 } });
+                                            });
+                                        }
+                                        else {
+                                            sizes_1.filter(function (a) { return !fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) && !filterArrayFields.filter(function (a) { return a.fieldPath; }).some(function (b) { return b.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }) && !fieldsLink.some(function (b) { return b.field_first.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) || b.field_second.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }); }).forEach(function (size) {
+                                                multFields.push({ $cond: { if: { $gt: ['$size_' + size, 0] }, then: '$size_' + size, else: 1 } });
+                                            });
+                                        }
+                                        if (multFields.length) {
+                                            if (field.leafValueType === 'Count') {
+                                                divFields_1.$addFields[total.id + '_' + field.id] = {
+                                                    $divide: ['$count', { $multiply: multFields }]
+                                                };
+                                            }
+                                            else {
+                                                divFields_1.$addFields[total.id + '_' + field.id] = {
+                                                    $divide: [buildArrayAwareNumericFieldExpr(fieldPath), { $multiply: multFields }]
+                                                };
+                                            }
+                                        }
+                                        else {
+                                            if (field.leafValueType === 'Count') {
+                                                divFields_1.$addFields[total.id + '_' + field.id] = '$count';
+                                            }
+                                            else {
+                                                divFields_1.$addFields[total.id + '_' + field.id] = buildArrayAwareNumericFieldExpr(fieldPath);
+                                            }
+                                        }
+                                    });
+                                });
+                                selectedFields.filter(function (a) { return a.fieldType === 'Number' && a.leafValueType === 'Sum'; }).forEach(function (field) {
+                                    var fieldPath = (field && typeof field.fieldPath === 'string') ? field.fieldPath : '';
+                                    if (!fieldPath) {
+                                        return;
+                                    }
+                                    var multFields = [];
+                                    sizes_1.filter(function (a) { return !fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) && !groupsRow.some(function (b) { return (b.field || '').replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }) && !filterArrayFields.filter(function (a) { return a.fieldPath; }).some(function (b) { return b.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }) && !fieldsLink.some(function (b) { return b.field_first.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) || b.field_second.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }); }).forEach(function (size) {
+                                        multFields.push({ $cond: { if: { $gt: ['$size_' + size, 0] }, then: '$size_' + size, else: 1 } });
+                                    });
+                                    if (multFields.length) {
+                                        divFields_1.$addFields[fieldPath.replace(/\.\$/g, '')] = {
+                                            $divide: [buildArrayAwareNumericFieldExpr(fieldPath), { $multiply: multFields }]
+                                        };
+                                    }
+                                });
+                                selectedFields.filter(function (a) { return a.leafValueType === 'Count'; }).forEach(function (field) {
+                                    var fieldPath = (field && typeof field.fieldPath === 'string') ? field.fieldPath : '';
+                                    if (!fieldPath) {
+                                        return;
+                                    }
+                                    var multFields = [];
+                                    sizes_1.filter(function (a) { return !fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) && !groupsRow.some(function (b) { return (b.field || '').replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }) && !filterArrayFields.filter(function (a) { return a.fieldPath; }).some(function (b) { return b.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }) && !fieldsLink.some(function (b) { return b.field_first.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) || b.field_second.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }); }).forEach(function (size) {
+                                        multFields.push({ $cond: { if: { $gt: ['$size_' + size, 0] }, then: '$size_' + size, else: 1 } });
+                                    });
+                                    if (multFields.length) {
+                                        divFields_1.$addFields['count_' + fieldPath.replace(/\.\$/g, '')] = {
+                                            $divide: ['$count', { $multiply: multFields }]
+                                        };
+                                    }
+                                    else {
+                                        if (reportType !== 'Dated' && sizes_1.filter(function (a) { return fieldPath.replace(/\.\$\./g, '_').includes(a); }).length) {
+                                            sizes_1.filter(function (a) { return fieldPath.replace(/\.\$\./g, '_').includes(a); }).forEach(function (size) {
+                                                divFields_1.$addFields['count_' + fieldPath.replace(/\.\$/g, '')] = '$size_' + size;
+                                            });
+                                        }
+                                        else {
+                                            divFields_1.$addFields['count_' + fieldPath.replace(/\.\$/g, '')] = '$count';
+                                        }
+                                    }
+                                });
+                                fieldsTotal.filter(function (a) { return a.type === 'avg'; }).forEach(function (total) {
+                                    selectedFields.filter(function (a) { return a.fieldType === 'Number' || a.leafValueType === 'Count'; }).forEach(function (field) {
+                                        var fieldPath = (field && typeof field.fieldPath === 'string') ? field.fieldPath : '';
+                                        if (!fieldPath && field.leafValueType !== 'Count') {
+                                            return;
+                                        }
+                                        divFields_1.$addFields[total.id + '_' + field.id] = buildArrayAwareNumericFieldExpr(fieldPath);
+                                    });
+                                });
+                                if (Object.keys(divFields_1.$addFields).length > 0) {
+                                    query_1.push(divFields_1);
+                                }
+                                fieldsLink.filter(function (a) { return a.field_first && a.field_second; }).forEach(function (link) {
+                                    var _a, _b;
+                                    query_1.push({ $addFields: (_a = {}, _a[link.id] = { $cmp: ['$' + link.field_first.replace(/\.\$/g, ''), '$' + link.field_second.replace(/\.\$/g, '')] }, _a) });
+                                    query_1.push({ $match: (_b = {}, _b[link.id] = 0, _b) });
+                                });
+                                customFields.forEach(function (cust) {
+                                    cust.operations.filter(function (a) { return a.operation && !a.fields.some(function (b) { return (b.field === null || b.field === '') && b.value === null; }); }).forEach(function (operation, opIndex) {
+                                        var _a, _b;
+                                        var custFieldGroup = {};
+                                        if (operation.operation === 'divide') {
+                                            var condCheck_1 = [];
+                                            operation.fields.filter(function (a) { return a.field || a.value !== null; }).forEach(function (field) {
+                                                if (field.field) {
+                                                    condCheck_1.push({ $eq: ['$' + field.field.replace(/\.\$/g, ''), 0] });
+                                                    condCheck_1.push({ $eq: ['$' + field.field.replace(/\.\$/g, ''), null] });
+                                                }
+                                                else {
+                                                    condCheck_1.push({ $eq: [field.value, 0] });
+                                                    condCheck_1.push({ $eq: [field.value, null] });
+                                                }
+                                            });
+                                            if (opIndex > 0) {
+                                                condCheck_1.push({ $eq: ['$' + cust.selFieldId, 0] });
+                                                condCheck_1.push({ $eq: ['$' + cust.selFieldId, null] });
+                                            }
+                                            var tmpOperationFields_1 = [];
+                                            if (opIndex > 0) {
+                                                tmpOperationFields_1.push('$' + cust.selFieldId);
+                                            }
+                                            operation.fields.filter(function (a) { return a.field || a.value !== null; }).forEach(function (field) {
+                                                if (field.field) {
+                                                    tmpOperationFields_1.push('$' + field.field.replace(/\.\$/g, ''));
+                                                }
+                                                else {
+                                                    tmpOperationFields_1.push(field.value);
+                                                }
+                                            });
+                                            custFieldGroup[cust.selFieldId] = {
+                                                $cond: { if: { $or: condCheck_1 }, then: 0, else: (_a = {}, _a['$' + operation.operation] = tmpOperationFields_1, _a) }
+                                            };
+                                        }
+                                        else {
+                                            custFieldGroup[cust.selFieldId] = (_b = {},
+                                                _b['$' + operation.operation] = [],
+                                                _b);
+                                            if (opIndex > 0) {
+                                                custFieldGroup[cust.selFieldId]['$' + operation.operation].push({ $cond: { if: { $eq: ['$' + cust.selFieldId, null] }, then: 0, else: '$' + cust.selFieldId } });
+                                            }
+                                            var condOr_1 = [];
+                                            operation.fields.filter(function (a) { return a.field || a.value !== null; }).forEach(function (field) {
+                                                if (field.field) {
+                                                    condOr_1.push({ $eq: ['$' + field.field.replace(/\.\$/g, ''), null] });
+                                                }
+                                                else {
+                                                    condOr_1.push({ $eq: [field.value, null] });
+                                                }
+                                            });
+                                            operation.fields.filter(function (a) { return a.field || a.value !== null; }).forEach(function (field) {
+                                                if (field.field) {
+                                                    custFieldGroup[cust.selFieldId]['$' + operation.operation].push({ $cond: { if: { $or: condOr_1 }, then: 0, else: '$' + field.field.replace(/\.\$/g, '') } });
+                                                }
+                                                else {
+                                                    custFieldGroup[cust.selFieldId]['$' + operation.operation].push({ $cond: { if: { $or: condOr_1 }, then: 0, else: field.value } });
+                                                }
+                                            });
+                                        }
+                                        query_1.push({ $addFields: custFieldGroup });
+                                    });
+                                });
+                                fieldsTotal.forEach(function (total) {
+                                    customFields.forEach(function (field) {
+                                        var _a;
+                                        query_1.push({ $addFields: (_a = {}, _a[total.id + '_' + field.selFieldId] = '$' + field.selFieldId, _a) });
+                                    });
+                                });
+                                queryMatchConditionLookup_1 = {
+                                    $and: []
+                                };
+                                if (lookupFilters_1.length) {
+                                    lookupFilters_1.forEach(function (filter) { return queryMatchConditionLookup_1['$and'].push(filter); });
+                                }
+                                filterArrays.forEach(function (filter) {
+                                    queryMatchConditionLookup_1['$and'].push(filter);
+                                });
+                                if (queryMatchConditionLookup_1.$and.length) {
+                                    query_1.push({ $match: queryMatchConditionLookup_1 });
+                                }
+                                queryGroup_1 = {
+                                    _id: {}
+                                };
+                                if (groupsRow.length || !displayType || displayType === 'grouped') {
+                                    if (!groupsRow.length) {
+                                        queryGroup_1._id = '$_id';
+                                    }
+                                    else {
+                                        if (rootOptions.sort) {
+                                            groupedSorts_1 = {};
+                                            Object.keys(rootOptions.sort).forEach(function (sortField) {
+                                                var selField = selectedFields.find(function (a) { return a.id === sortField; });
+                                                if (selField) {
+                                                    var sortPath = (selField && typeof selField.fieldPath === 'string') ? selField.fieldPath.replace(/\.\$/g, '') : '';
+                                                    if (sortPath) {
+                                                        groupedSorts_1[sortPath] = rootOptions.sort[sortField];
+                                                    }
+                                                }
+                                            });
+                                            if (Object.keys(groupedSorts_1).length > 0) {
+                                                query_1.push({
+                                                    $sort: groupedSorts_1
+                                                });
+                                            }
+                                        }
+                                    }
+                                    if (groupsRow.length && date_field && date_interval) {
+                                        dateFieldPath = (typeof date_field === 'string') ? date_field.replace(/\.\$/g, '') : '';
+                                        if (dateFieldPath) {
+                                            dateFieldExpr = '$' + dateFieldPath;
+                                            utcHourExpr = { '$hour': { date: dateFieldExpr, timezone: 'UTC' } };
+                                            utcMinuteExpr = { '$minute': { date: dateFieldExpr, timezone: 'UTC' } };
+                                            utcSecondExpr = { '$second': { date: dateFieldExpr, timezone: 'UTC' } };
+                                            utcDayExpr = { '$dayOfMonth': { date: dateFieldExpr, timezone: 'UTC' } };
+                                            tzDayExpr = { '$dayOfMonth': { date: dateFieldExpr, timezone: reportBuilderTimezone } };
+                                            useUtcForDateOnlyExpr = {
+                                                $and: [
+                                                    { $eq: [utcHourExpr, 0] },
+                                                    { $eq: [utcMinuteExpr, 0] },
+                                                    { $eq: [utcSecondExpr, 0] },
+                                                    { $ne: [utcDayExpr, tzDayExpr] }
+                                                ]
+                                            };
+                                            groupingTimezoneExpr = { $cond: [useUtcForDateOnlyExpr, 'UTC', reportBuilderTimezone] };
+                                            if (date_interval === 'Seconds') {
+                                                queryGroup_1._id['second'] = { '$second': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['minute'] = { '$minute': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['hour'] = { '$hour': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['day'] = { '$dayOfMonth': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['month'] = { '$month': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['year'] = { '$year': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                            }
+                                            else if (date_interval === 'Minutes') {
+                                                queryGroup_1._id['minute'] = { '$minute': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['hour'] = { '$hour': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['day'] = { '$dayOfMonth': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['month'] = { '$month': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['year'] = { '$year': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                            }
+                                            else if (date_interval === 'Hours') {
+                                                queryGroup_1._id['hour'] = { '$hour': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['day'] = { '$dayOfMonth': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['month'] = { '$month': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['year'] = { '$year': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                            }
+                                            else if (date_interval === 'Daily') {
+                                                queryGroup_1._id['day'] = { '$dayOfMonth': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['month'] = { '$month': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['year'] = { '$year': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                            }
+                                            else if (date_interval === 'Weekly') {
+                                                queryGroup_1._id['week'] = { '$isoWeek': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['year'] = { '$isoWeekYear': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                            }
+                                            else if (date_interval === 'Monthly') {
+                                                queryGroup_1._id['month'] = { '$month': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['year'] = { '$year': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                            }
+                                            else if (date_interval === 'Quarterly') {
+                                                queryGroup_1._id['month'] = { '$month': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                                queryGroup_1._id['year'] = { '$year': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                            }
+                                            else if (date_interval === 'Yearly') {
+                                                queryGroup_1._id['year'] = { '$year': { 'date': dateFieldExpr, 'timezone': groupingTimezoneExpr } };
+                                            }
+                                        }
+                                    }
+                                    groupsRow.forEach(function (row) {
+                                        var rowField = (row && typeof row.field === 'string') ? row.field : '';
+                                        if (!rowField || !(row === null || row === void 0 ? void 0 : row.id)) {
+                                            return;
+                                        }
+                                        queryGroup_1._id[row.id] = '$' + rowField.replace(/\.\$/g, '');
+                                    });
+                                    selectedFields.forEach(function (field) {
+                                        var fieldPath = (field && typeof field.fieldPath === 'string') ? field.fieldPath : '';
+                                        if (!fieldPath) {
+                                            if (field.leafValueType === 'Count') {
+                                                queryGroup_1[field.id] = { '$sum': 1 };
+                                            }
+                                            return;
+                                        }
+                                        if (field.leafValueType === 'Average') {
+                                            queryGroup_1[field.id] = { '$avg': '$' + fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'Sum') {
+                                            queryGroup_1[field.id] = { '$sum': buildArrayAwareNumericFieldExpr(fieldPath) };
+                                        }
+                                        else if (field.leafValueType === 'Count') {
+                                            queryGroup_1[field.id] = { '$sum': '$count_' + fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'Minimum') {
+                                            queryGroup_1[field.id] = { '$min': '$' + fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'Maximum') {
+                                            queryGroup_1[field.id] = { '$max': '$' + fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'First') {
+                                            queryGroup_1[field.id] = { '$first': '$' + fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'Last') {
+                                            queryGroup_1[field.id] = { '$last': '$' + fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'Unique') {
+                                            queryGroup_1[field.id] = { '$addToSet': '$' + fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else {
+                                            queryGroup_1[field.id] = { '$push': { $ifNull: ['$' + fieldPath.replace(/\.\$/g, ''), null] } };
+                                        }
+                                    });
+                                    customFields.forEach(function (cust) {
+                                        if (cust.leafValueType === 'Average') {
+                                            queryGroup_1[cust.selFieldId] = { '$avg': '$' + cust.selFieldId };
+                                        }
+                                        else if (cust.leafValueType === 'Sum') {
+                                            queryGroup_1[cust.selFieldId] = { '$sum': '$' + cust.selFieldId };
+                                        }
+                                        else if (cust.leafValueType === 'Count') {
+                                            if (reportType === 'Dated') {
+                                                queryGroup_1[cust.selFieldId] = { '$sum': '$count_' + cust.selFieldId };
+                                            }
+                                            else {
+                                                queryGroup_1[cust.selFieldId] = { '$push': '$count_' + cust.selFieldId };
+                                            }
+                                        }
+                                        else if (cust.leafValueType === 'Minimum') {
+                                            queryGroup_1[cust.selFieldId] = { '$min': '$' + cust.selFieldId };
+                                        }
+                                        else if (cust.leafValueType === 'Maximum') {
+                                            queryGroup_1[cust.selFieldId] = { '$max': '$' + cust.selFieldId };
+                                        }
+                                        else if (cust.leafValueType === 'First') {
+                                            queryGroup_1[cust.selFieldId] = { '$first': '$' + cust.selFieldId };
+                                        }
+                                        else if (cust.leafValueType === 'Last') {
+                                            queryGroup_1[cust.selFieldId] = { '$last': '$' + cust.selFieldId };
+                                        }
+                                        else if (cust.leafValueType === 'Unique') {
+                                            queryGroup_1[cust.selFieldId] = { '$addToSet': '$' + cust.selFieldId };
+                                        }
+                                        else {
+                                            queryGroup_1[cust.selFieldId] = { '$push': { $ifNull: ['$' + cust.selFieldId, null] } };
+                                        }
+                                    });
+                                    // Totals
+                                    if (fieldsTotal.length) {
+                                        fieldsTotal.forEach(function (total) {
+                                            selectedFields.filter(function (a) { return a.fieldType === 'Number' || a.leafValueType === 'Count'; }).forEach(function (field) {
+                                                var _a;
+                                                queryGroup_1[total.id + '_' + field.id] = (_a = {}, _a['$' + total.type] = '$' + total.id + '_' + field.id, _a);
+                                            });
+                                            customFields.forEach(function (field) {
+                                                var _a;
+                                                queryGroup_1[total.id + '_' + field.selFieldId] = (_a = {}, _a['$' + total.type] = '$' + total.id + '_' + field.selFieldId, _a);
+                                            });
+                                        });
+                                    }
+                                    query_1.push({ $group: queryGroup_1 });
+                                }
+                                else {
+                                    queryProjection_1 = {
+                                        _id: 1
+                                    };
+                                    selectedFields.forEach(function (field) {
+                                        var fieldPath = (field && typeof field.fieldPath === 'string') ? field.fieldPath : '';
+                                        if (!fieldPath && field.leafValueType !== 'Count') {
+                                            return;
+                                        }
+                                        if (field.leafValueType === 'Average') {
+                                            queryProjection_1[field.id] = buildArrayAwareAverageFieldExpr(fieldPath);
+                                        }
+                                        else if (field.leafValueType === 'Sum') {
+                                            queryProjection_1[field.id] = buildArrayAwareNumericFieldExpr(fieldPath);
+                                        }
+                                        else if (field.leafValueType === 'Count') {
+                                            queryProjection_1[field.id] = { $sum: 1 };
+                                        }
+                                        else if (field.leafValueType === 'Minimum') {
+                                            queryProjection_1[field.id] = { $min: '$' + fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'Maximum') {
+                                            queryProjection_1[field.id] = { $max: '$' + fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else {
+                                            queryProjection_1[field.id] = '$' + fieldPath.replace(/\.\$/g, '');
+                                        }
+                                    });
+                                    customFields.forEach(function (cust) {
+                                        if (cust === 'Average') {
+                                            queryProjection_1[cust.selFieldId] = { $avg: '$' + cust.selFieldId };
+                                        }
+                                        else if (cust === 'Sum') {
+                                            queryProjection_1[cust.selFieldId] = { $sum: '$' + cust.selFieldId };
+                                        }
+                                        else if (cust === 'Count') {
+                                            queryProjection_1[cust.selFieldId] = { $sum: 1 };
+                                        }
+                                        else if (cust === 'Minimum') {
+                                            queryProjection_1[cust.selFieldId] = { $min: '$' + cust.selFieldId };
+                                        }
+                                        else if (cust === 'Maximum') {
+                                            queryProjection_1[cust.selFieldId] = { $max: '$' + cust.selFieldId };
+                                        }
+                                        else {
+                                            queryProjection_1[cust.selFieldId] = '$' + cust.selFieldId;
+                                        }
+                                    });
+                                    //Totals
+                                    if (fieldsTotal.length && (reportType === 'List' || reportType === 'Dated')) {
+                                        fieldsTotal.forEach(function (total) {
+                                            selectedFields.filter(function (a) { return a.fieldType === 'Number' || a.leafValueType === 'Count'; }).forEach(function (field) {
+                                                var _a;
+                                                var totalFieldPath = total.id + '_' + field.id;
+                                                if (total.type === 'sum') {
+                                                    queryProjection_1[totalFieldPath] = buildArrayAwareNumericFieldExpr(totalFieldPath);
+                                                }
+                                                else if (total.type === 'avg') {
+                                                    queryProjection_1[totalFieldPath] = buildArrayAwareAverageFieldExpr(totalFieldPath);
+                                                }
+                                                else {
+                                                    queryProjection_1[totalFieldPath] = (_a = {}, _a['$' + total.type] = '$' + totalFieldPath, _a);
+                                                }
+                                            });
+                                            customFields.forEach(function (field) {
+                                                var _a;
+                                                queryProjection_1[total.id + '_' + field.selFieldId] = (_a = {}, _a['$' + total.type] = '$' + total.id + '_' + field.selFieldId, _a);
+                                            });
+                                        });
+                                    }
+                                    query_1.push({ $project: queryProjection_1 });
+                                }
+                                // SORT
+                                if (rootOptions.sort) {
+                                    appendSafeSort(query_1, rootOptions.sort, selectedFields, customFields);
+                                }
+                                if (reportType === 'Group' && groupsRow.length > 1) {
+                                    _loop_1 = function (i) {
+                                        var _d;
+                                        var projQuery = { _id: 1 };
+                                        projQuery[groupsRow[i].id] = {
+                                            _id: (_d = {}, _d[groupsRow[i].id] = '$_id.' + groupsRow[i].id, _d)
+                                        };
+                                        if (i === groupsRow.length - 1) {
+                                            selectedFields.forEach(function (field) {
+                                                projQuery[groupsRow[i].id][field.id] = '$' + field.id;
+                                            });
+                                            customFields.forEach(function (field) {
+                                                projQuery[groupsRow[i].id][field.selFieldId] = '$' + field.selFieldId;
+                                            });
+                                        }
+                                        else {
+                                            projQuery[groupsRow[i].id][groupsRow[i + 1].id] = '$' + groupsRow[i + 1].id;
+                                        }
+                                        fieldsTotal.forEach(function (totField) {
+                                            selectedFields.filter(function (b) { return b.fieldType === 'Number' || b.leafValueType === 'Count'; }).forEach(function (selField) {
+                                                projQuery[totField.id + '_' + selField.id] = 1;
+                                                projQuery[groupsRow[i].id][totField.id + '_' + selField.id] = '$' + totField.id + '_' + selField.id;
+                                            });
+                                            customFields.forEach(function (field) {
+                                                projQuery[groupsRow[i].id][totField.id + '_' + field.selFieldId] = '$' + totField.id + '_' + field.selFieldId;
+                                            });
+                                        });
+                                        query_1.push({ $project: projQuery });
+                                        var grQuery = {
+                                            _id: {}
+                                        };
+                                        for (var j = 0; j < i; j++) {
+                                            grQuery._id[groupsRow[j].id] = '$_id.' + groupsRow[j].id;
+                                        }
+                                        grQuery[groupsRow[i].id] = {
+                                            $push: '$' + groupsRow[i].id
+                                        };
+                                        fieldsTotal.forEach(function (totField) {
+                                            selectedFields.filter(function (b) { return b.fieldType === 'Number' || b.leafValueType === 'Count'; }).forEach(function (selField) {
+                                                var _a;
+                                                grQuery[totField.id + '_' + selField.id] = (_a = {}, _a['$' + totField.type] = '$' + totField.id + '_' + selField.id, _a);
+                                            });
+                                            customFields.forEach(function (field) {
+                                                var _a;
+                                                grQuery[totField.id + '_' + field.selFieldId] = (_a = {}, _a['$' + totField.type] = '$' + totField.id + '_' + field.selFieldId, _a);
+                                            });
+                                        });
+                                        query_1.push({ $group: grQuery });
+                                        if (rootOptions.sort) {
+                                            var sortKeys_1 = Object.keys(rootOptions.sort);
+                                            var sort_1 = {};
+                                            var groupString_1 = '';
+                                            groupsRow.forEach(function (row, groupIndex) {
+                                                if (groupIndex > 0) {
+                                                    groupString_1 += 'gr_' + (groupIndex + 1) + '.';
+                                                }
+                                                if (sortKeys_1.includes('_id.gr_' + (groupIndex + 1))) {
+                                                    sort_1[groupString_1 + '_id.gr_' + (groupIndex + 1)] = rootOptions.sort['_id.gr_' + (groupIndex + 1)];
+                                                }
+                                                else {
+                                                    sort_1[groupString_1 + '_id.gr_' + (groupIndex + 1)] = 1;
+                                                }
+                                            });
+                                            sortKeys_1.filter(function (a) { return !a.startsWith('_id.gr_'); }).forEach(function (key) {
+                                                sort_1[groupString_1 + key] = rootOptions.sort[key];
+                                            });
+                                            appendSafeSort(query_1, sort_1, selectedFields, customFields);
+                                        }
+                                    };
+                                    for (i = groupsRow.length - 1; i >= 1; i--) {
+                                        _loop_1(i);
+                                    }
+                                }
+                                if (this.serverConfig['ROOT_URL'] === 'http://localhost:4200') {
+                                    console.log('_____________ query __________');
+                                    console.log(JSON.stringify(query_1, null, 2));
+                                }
+                                readPreference = this.serverConfig['ROOT_URL'] !== 'http://localhost:4200' ? 'secondary' : 'primary';
+                                queryResult = {
+                                    count: 0,
+                                    results: [],
+                                    totals: {}
+                                };
+                                _c.label = 7;
+                            case 7:
+                                _c.trys.push([7, 9, , 10]);
+                                return [4 /*yield*/, executeReportBuilderQuery(modelCollection, query_1, rootOptions, fieldsTotal, selectedFields, customFields, readPreference)];
+                            case 8:
+                                queryResult = _c.sent();
+                                return [3 /*break*/, 10];
+                            case 9:
+                                err_2 = _c.sent();
+                                console.log(err_2);
+                                return [3 /*break*/, 10];
+                            case 10:
+                                tmpRes = [{
+                                        count: queryResult.count,
+                                        results: queryResult.results,
+                                        totals: queryResult.totals
+                                    }];
+                                return [2 /*return*/, tmpRes];
+                        }
+                    });
+                });
+            },
+            workerTaskWeight: 2
+        }
+    });
+}
+function coerceReportBuilderNumeric(value) {
+    if (Array.isArray(value)) {
+        return value.map(function (v) { return coerceReportBuilderNumeric(v); }).reduce(function (a, b) { return a + b; }, 0);
+    }
+    var num = typeof value === 'number' ? value : (value !== null && value !== undefined ? Number(value) : 0);
+    return isNaN(num) ? 0 : num;
+}
+function buildReportBuilderTotalsFieldKeySets(fieldsTotal, selectedFields, customFields) {
+    if (fieldsTotal === void 0) { fieldsTotal = []; }
+    if (selectedFields === void 0) { selectedFields = []; }
+    if (customFields === void 0) { customFields = []; }
+    var numericSelectedFields = selectedFields.filter(function (field) { return (field === null || field === void 0 ? void 0 : field.fieldType) === 'Number' || (field === null || field === void 0 ? void 0 : field.leafValueType) === 'Count'; });
+    var sumKeys = new Set();
+    var avgKeys = new Set();
+    fieldsTotal.forEach(function (totalField) {
+        numericSelectedFields.forEach(function (selectedField) {
+            var key = "".concat(totalField.id, "_").concat(selectedField.id);
+            if (!key) {
+                return;
+            }
+            if (totalField.type === 'sum') {
+                sumKeys.add(key);
+            }
+            else if (totalField.type === 'avg') {
+                avgKeys.add(key);
+            }
+        });
+        customFields.forEach(function (customField) {
+            var customId = customField === null || customField === void 0 ? void 0 : customField.selFieldId;
+            if (!customId) {
+                return;
+            }
+            var key = "".concat(totalField.id, "_").concat(customId);
+            if (totalField.type === 'sum') {
+                sumKeys.add(key);
+            }
+            else if (totalField.type === 'avg') {
+                avgKeys.add(key);
+            }
+        });
+    });
+    return { sumKeys: sumKeys, avgKeys: avgKeys };
+}
+function buildReportBuilderTotalsFromSums(fieldsTotal, selectedFields, customFields, sumValues, count) {
+    if (fieldsTotal === void 0) { fieldsTotal = []; }
+    if (selectedFields === void 0) { selectedFields = []; }
+    if (customFields === void 0) { customFields = []; }
+    if (sumValues === void 0) { sumValues = {}; }
+    if (count === void 0) { count = 0; }
+    var numericSelectedFields = selectedFields.filter(function (field) { return (field === null || field === void 0 ? void 0 : field.fieldType) === 'Number' || (field === null || field === void 0 ? void 0 : field.leafValueType) === 'Count'; });
+    var totals = {};
+    fieldsTotal.forEach(function (totalField) {
+        numericSelectedFields.forEach(function (selectedField) {
+            var key = "".concat(totalField.id, "_").concat(selectedField.id);
+            var sum = coerceReportBuilderNumeric(sumValues[key]);
+            if (totalField.type === 'sum') {
+                totals[key] = sum;
+            }
+            else if (totalField.type === 'avg') {
+                totals[key] = count ? (0, common_1.round)(sum / count) : 0;
+            }
+        });
+        customFields.forEach(function (customField) {
+            var customId = customField === null || customField === void 0 ? void 0 : customField.selFieldId;
+            if (!customId) {
+                return;
+            }
+            var key = "".concat(totalField.id, "_").concat(customId);
+            var sum = coerceReportBuilderNumeric(sumValues[key]);
+            if (totalField.type === 'sum') {
+                totals[key] = sum;
+            }
+            else if (totalField.type === 'avg') {
+                totals[key] = count ? (0, common_1.round)(sum / count) : 0;
+            }
+        });
+    });
+    return totals;
+}
+function buildReportBuilderNumericSumExpr(fieldKey) {
+    var fieldExpr = '$' + fieldKey;
+    return {
+        $cond: [
+            { $isArray: fieldExpr },
+            {
+                $reduce: {
+                    input: fieldExpr,
+                    initialValue: 0,
+                    in: {
+                        $add: [
+                            '$$value',
+                            { $convert: { input: '$$this', to: 'double', onError: 0, onNull: 0 } }
+                        ]
+                    }
+                }
+            },
+            { $convert: { input: fieldExpr, to: 'double', onError: 0, onNull: 0 } }
+        ]
+    };
+}
+function executeReportBuilderQuery(modelCollection_1, query_2, rootOptions_1) {
+    return __awaiter(this, arguments, void 0, function (modelCollection, query, rootOptions, fieldsTotal, selectedFields, customFields, readPreference) {
+        var aggregateOptions, _a, sumKeys, avgKeys, allTotalKeys, resultsFacet, facet, totalsGroup_1, facetedQuery, facetedResult, facetDoc, count, results_1, totalsDoc_1, sumValues_1, totals_1, fullResult, rows, sumValues, results, totals;
+        var _b, _c, _d;
+        if (fieldsTotal === void 0) { fieldsTotal = []; }
+        if (selectedFields === void 0) { selectedFields = []; }
+        if (customFields === void 0) { customFields = []; }
+        if (readPreference === void 0) { readPreference = 'primary'; }
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    aggregateOptions = {
+                        allowDiskUse: true,
+                        readPreference: readPreference
+                    };
+                    _a = buildReportBuilderTotalsFieldKeySets(fieldsTotal, selectedFields, customFields), sumKeys = _a.sumKeys, avgKeys = _a.avgKeys;
+                    allTotalKeys = new Set(__spreadArray(__spreadArray([], __read(sumKeys), false), __read(avgKeys), false));
+                    if (!((rootOptions === null || rootOptions === void 0 ? void 0 : rootOptions.limit) && rootOptions.limit > 0)) return [3 /*break*/, 2];
+                    resultsFacet = [];
+                    if (rootOptions.skip && rootOptions.skip > 0) {
+                        resultsFacet.push({ $skip: rootOptions.skip });
+                    }
+                    resultsFacet.push({ $limit: rootOptions.limit });
+                    facet = {
+                        results: resultsFacet,
+                        count: [{ $count: 'count' }],
+                        totals: []
+                    };
+                    if (allTotalKeys.size) {
+                        totalsGroup_1 = {
+                            _id: null,
+                            __count: { $sum: 1 }
+                        };
+                        Array.from(allTotalKeys).forEach(function (key) {
+                            totalsGroup_1[key] = { $sum: buildReportBuilderNumericSumExpr(key) };
+                        });
+                        facet.totals = [
+                            { $group: totalsGroup_1 }
+                        ];
+                    }
+                    facetedQuery = query.concat([
+                        { $facet: facet }
+                    ]);
+                    return [4 /*yield*/, modelCollection.aggregate(facetedQuery, aggregateOptions, true)];
+                case 1:
+                    facetedResult = _e.sent();
+                    facetDoc = Array.isArray(facetedResult) && facetedResult.length ? facetedResult[0] : {};
+                    count = ((_c = (_b = facetDoc === null || facetDoc === void 0 ? void 0 : facetDoc.count) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.count) || 0;
+                    results_1 = Array.isArray(facetDoc === null || facetDoc === void 0 ? void 0 : facetDoc.results) ? facetDoc.results : [];
+                    totalsDoc_1 = ((_d = facetDoc === null || facetDoc === void 0 ? void 0 : facetDoc.totals) === null || _d === void 0 ? void 0 : _d[0]) || {};
+                    sumValues_1 = {};
+                    Array.from(allTotalKeys).forEach(function (key) {
+                        sumValues_1[key] = coerceReportBuilderNumeric(totalsDoc_1[key]);
+                    });
+                    totals_1 = buildReportBuilderTotalsFromSums(fieldsTotal, selectedFields, customFields, sumValues_1, count);
+                    return [2 /*return*/, { count: count, results: results_1, totals: totals_1 }];
+                case 2: return [4 /*yield*/, modelCollection.aggregate(query, aggregateOptions, true)];
+                case 3:
+                    fullResult = _e.sent();
+                    rows = Array.isArray(fullResult) ? fullResult : [];
+                    sumValues = {};
+                    Array.from(allTotalKeys).forEach(function (key) {
+                        sumValues[key] = rows.map(function (row) { return coerceReportBuilderNumeric(row ? row[key] : 0); }).reduce(function (a, b) { return a + b; }, 0);
+                    });
+                    results = rows;
+                    if ((rootOptions === null || rootOptions === void 0 ? void 0 : rootOptions.skip) && rootOptions.skip > 0) {
+                        results = results.slice(rootOptions.skip);
+                    }
+                    if ((rootOptions === null || rootOptions === void 0 ? void 0 : rootOptions.limit) && rootOptions.limit > 0) {
+                        results = results.slice(0, rootOptions.limit);
+                    }
+                    totals = buildReportBuilderTotalsFromSums(fieldsTotal, selectedFields, customFields, sumValues, rows.length);
+                    return [2 /*return*/, {
+                            count: rows.length,
+                            results: results,
+                            totals: totals
+                        }];
+            }
+        });
+    });
+}
+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 buildArrayAwareNumericFieldExpr(fieldPath) {
+    var normalizedFieldPath = (fieldPath || '').replace(/\.\$/g, '');
+    if (!normalizedFieldPath) {
+        return 0;
+    }
+    var fieldExpr = '$' + normalizedFieldPath;
+    return {
+        $cond: [
+            { $isArray: fieldExpr },
+            { $sum: { $ifNull: [fieldExpr, []] } },
+            { $ifNull: [fieldExpr, 0] }
+        ]
+    };
+}
+function buildArrayAwareAverageFieldExpr(fieldPath) {
+    var normalizedFieldPath = (fieldPath || '').replace(/\.\$/g, '');
+    if (!normalizedFieldPath) {
+        return 0;
+    }
+    var fieldExpr = '$' + normalizedFieldPath;
+    return {
+        $cond: [
+            { $isArray: fieldExpr },
+            {
+                $cond: [
+                    { $gt: [{ $size: { $ifNull: [fieldExpr, []] } }, 0] },
+                    { $avg: { $ifNull: [fieldExpr, []] } },
+                    0
+                ]
+            },
+            { $ifNull: [fieldExpr, 0] }
+        ]
+    };
+}
+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) {
+        var summary = summarizeFilterTargets(filter, lookupAliases);
+        if (summary.hasLookup) {
+            // If the filter mixes root + lookup, keep it together in lookupFilters so it stays a single $match/$or
+            lookupFilters.push(filter);
+        }
+        else {
+            rootFilters.push(filter);
+        }
+    });
+    return { rootFilters: rootFilters, lookupFilters: lookupFilters };
+}
+function summarizeFilterTargets(filter, lookupAliases) {
+    var result = { hasLookup: false, hasRoot: false };
+    if (!filter || typeof filter !== 'object') {
+        return result;
+    }
+    Object.keys(filter).forEach(function (key) {
+        if (key === '$or' || key === '$and') {
+            var branch = filter[key];
+            if (Array.isArray(branch)) {
+                branch.forEach(function (child) {
+                    var childSummary = summarizeFilterTargets(child, lookupAliases);
+                    result.hasLookup = result.hasLookup || childSummary.hasLookup;
+                    result.hasRoot = result.hasRoot || childSummary.hasRoot;
+                });
+            }
+        }
+        else {
+            var isLookup = isLookupPath(key, lookupAliases);
+            if (isLookup) {
+                result.hasLookup = true;
+            }
+            else {
+                result.hasRoot = true;
+            }
+        }
+    });
+    return result;
+}
+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();
+}
+function collectRootDatePaths(collectionName) {
+    var out = new Set();
+    var collection = resolveio_server_app_1.ResolveIOServer.getMongoManager().collection(collectionName);
+    var schema = (collection === null || collection === void 0 ? void 0 : collection.rbSchema) || {};
+    Object.keys(schema).forEach(function (path) {
+        var _a;
+        if (((_a = schema[path]) === null || _a === void 0 ? void 0 : _a.rbType) === 'Date') {
+            out.add(path.replace(/\.\$/g, ''));
+        }
+    });
+    return out;
+}
+function coerceDateFilters(filters, datePaths) {
+    if (filters === void 0) { filters = []; }
+    var coerceDateValue = function (value) {
+        if (value instanceof Date) {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return value.map(coerceDateValue);
+        }
+        if (typeof value === 'string' || typeof value === 'number') {
+            var parsed = new Date(value);
+            if (!isNaN(parsed.getTime())) {
+                return parsed;
+            }
+        }
+        return value;
+    };
+    var coerceFilterObject = function (obj) {
+        if (!obj || typeof obj !== 'object') {
+            return obj;
+        }
+        if (Array.isArray(obj)) {
+            obj.forEach(coerceFilterObject);
+            return obj;
+        }
+        if (obj.$or) {
+            obj.$or = obj.$or.map(coerceFilterObject).filter(Boolean);
+            return obj;
+        }
+        if (obj.$and) {
+            obj.$and = obj.$and.map(coerceFilterObject).filter(Boolean);
+            return obj;
+        }
+        Object.keys(obj).forEach(function (key) {
+            if (key.startsWith('$')) {
+                return;
+            }
+            var normalizedKey = key.replace(/\.\$/g, '');
+            if (!datePaths.has(normalizedKey)) {
+                return;
+            }
+            var value = obj[key];
+            if (value && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
+                Object.keys(value).forEach(function (op) {
+                    if (op.startsWith('$')) {
+                        value[op] = coerceDateValue(value[op]);
+                    }
+                });
+            }
+            else {
+                obj[key] = coerceDateValue(value);
+            }
+        });
+        return obj;
+    };
+    (filters || []).forEach(coerceFilterObject);
+}
+// Helpers to support union-based joins (collection_joins without local/foreign key)
+function stripAliasFromPath(path, alias) {
+    if (!path) {
+        return path;
+    }
+    var cleanAlias = alias.replace(/\.\$/g, '');
+    var cleanPath = path.replace(/\.\$/g, '');
+    if (cleanPath.startsWith(cleanAlias + '.')) {
+        return cleanPath.substring(cleanAlias.length + 1);
+    }
+    return cleanPath;
+}
+function buildCollectionPipeline(collectionName, alias, selectedFields, filters, filterArrays, isRoot) {
+    if (selectedFields === void 0) { selectedFields = []; }
+    if (filters === void 0) { filters = []; }
+    if (filterArrays === void 0) { filterArrays = []; }
+    if (isRoot === void 0) { isRoot = false; }
+    var pipeline = [];
+    var matchClauses = [];
+    var matchArrayClauses = [];
+    var targetAlias = isRoot ? '' : alias.replace(/\.\$/g, '');
+    var mapFilterForCollection = function (filterObj, toArray) {
+        if (!filterObj || typeof filterObj !== 'object') {
+            return;
+        }
+        var mapped = mapFilterPaths(filterObj, targetAlias, isRoot);
+        if (mapped) {
+            (toArray ? matchArrayClauses : matchClauses).push(mapped);
+        }
+    };
+    (filters || []).forEach(function (f) { return mapFilterForCollection(f, false); });
+    (filterArrays || []).forEach(function (f) { return mapFilterForCollection(f, true); });
+    if (matchClauses.length || matchArrayClauses.length) {
+        var match = { $and: __spreadArray(__spreadArray([], __read(matchClauses), false), __read(matchArrayClauses), false) };
+        pipeline.push({ $match: match });
+        if (process.env.NODE_ENV !== 'production') {
+            console.info('RB debug: collection pipeline match', {
+                collection: collectionName,
+                alias: targetAlias || collectionName,
+                matchJson: JSON.stringify(match, null, 2)
+            });
+        }
+    }
+    // Projection mapping selected fields for this collection
+    var projection = { _id: 1, __rb_collection: targetAlias || collectionName };
+    (selectedFields || [])
+        .filter(function (f) { return isFieldForCollection(f, collectionName, targetAlias); })
+        .forEach(function (f) {
+        var mappedPath = stripAliasFromPath(f.fieldPath || '', targetAlias || f.lookup_as || '');
+        if (f.leafValueType === 'Average') {
+            projection[f.id] = buildArrayAwareAverageFieldExpr(mappedPath);
+        }
+        else if (f.leafValueType === 'Sum') {
+            projection[f.id] = buildArrayAwareNumericFieldExpr(mappedPath);
+        }
+        else if (f.leafValueType === 'Count') {
+            projection[f.id] = { $sum: 1 };
+        }
+        else if (f.leafValueType === 'Minimum') {
+            projection[f.id] = { $min: '$' + mappedPath };
+        }
+        else if (f.leafValueType === 'Maximum') {
+            projection[f.id] = { $max: '$' + mappedPath };
+        }
+        else {
+            projection[f.id] = '$' + mappedPath;
+        }
+    });
+    pipeline.push({ $project: projection });
+    return pipeline;
+}
+function isFieldForCollection(field, collectionName, alias) {
+    if (!field) {
+        return false;
+    }
+    // Root collection check
+    if (!alias) {
+        return field.collection_name === collectionName && (!field.lookup_collection || field.lookup_collection === '');
+    }
+    // Joined collection check
+    return field.lookup_collection === collectionName || (field.lookup_as && field.lookup_as.replace(/\.\$/g, '') === alias);
+}
+function mapFilterPaths(filter, alias, isRoot) {
+    if (!filter || typeof filter !== 'object') {
+        return null;
+    }
+    if (Array.isArray(filter)) {
+        return filter.map(function (f) { return mapFilterPaths(f, alias, isRoot); });
+    }
+    if (filter.$or) {
+        var mapped = filter.$or.map(function (f) { return mapFilterPaths(f, alias, isRoot); }).filter(Boolean);
+        return mapped.length ? { $or: mapped } : null;
+    }
+    if (filter.$and) {
+        var mapped = filter.$and.map(function (f) { return mapFilterPaths(f, alias, isRoot); }).filter(Boolean);
+        return mapped.length ? { $and: mapped } : null;
+    }
+    var out = {};
+    Object.keys(filter).forEach(function (key) {
+        var cleanKey = key.replace(/\.\$/g, '');
+        if (!alias) {
+            // root collection: ignore keys that start with a lookup alias
+            if (cleanKey.includes('(Lookup')) {
+                return;
+            }
+            if (lookupAliasMatches(cleanKey, alias)) {
+                return;
+            }
+            out[cleanKey] = filter[key];
+        }
+        else {
+            if (cleanKey.startsWith(alias + '.')) {
+                out[cleanKey.substring(alias.length + 1)] = filter[key];
+            }
+        }
+    });
+    return Object.keys(out).length ? out : null;
+}
+function lookupAliasMatches(path, alias) {
+    if (!path || !alias) {
+        return false;
+    }
+    return path.startsWith(alias + '.') || path === alias;
+}
+function buildLayoutSortSpec(sortSpec, selectedFields) {
+    if (sortSpec === void 0) { sortSpec = {}; }
+    if (selectedFields === void 0) { selectedFields = []; }
+    var outSort = __assign({}, sortSpec);
+    var addFields = {};
+    Object.keys(sortSpec || {}).forEach(function (key) {
+        if (!key.startsWith('layout_col_')) {
+            return;
+        }
+        var normalized = key.replace(/^layout_col_/, '');
+        var parts = normalized.split('_');
+        var idx = parseInt(parts[parts.length - 1], 10);
+        if (isNaN(idx)) {
+            return;
+        }
+        var layoutFields = (selectedFields || []).filter(function (f) { return typeof (f === null || f === void 0 ? void 0 : f.layoutColumnIndex) !== 'undefined' && f.layoutColumnIndex === idx; }).map(function (f) { return f.id; }).filter(Boolean);
+        if (!layoutFields.length) {
+            return;
+        }
+        // Build nested $ifNull chain to coalesce across layout column targets
+        var coalesce = '';
+        for (var i = layoutFields.length - 1; i >= 0; i--) {
+            var fieldPath = '$' + layoutFields[i];
+            if (i === layoutFields.length - 1) {
+                coalesce = fieldPath;
+            }
+            else {
+                coalesce = { $ifNull: [fieldPath, coalesce] };
+            }
+        }
+        var sortKey = 'sort_' + key;
+        addFields[sortKey] = coalesce;
+        delete outSort[key];
+        outSort[sortKey] = sortSpec[key];
+    });
+    return { sortSpec: outSort, addFields: addFields };
+}
+function remapFiltersToIds(filters, selectedFields) {
+    if (filters === void 0) { filters = []; }
+    if (selectedFields === void 0) { selectedFields = []; }
+    var byPath = new Map();
+    var layoutMap = new Map();
+    (selectedFields || []).forEach(function (f) {
+        if ((f === null || f === void 0 ? void 0 : f.fieldPath) && (f === null || f === void 0 ? void 0 : f.id)) {
+            byPath.set(f.fieldPath.replace(/\.\$/g, ''), f.id);
+        }
+        if (typeof (f === null || f === void 0 ? void 0 : f.layoutColumnIndex) !== 'undefined') {
+            var arr = layoutMap.get(f.layoutColumnIndex) || [];
+            arr.push(f.id);
+            layoutMap.set(f.layoutColumnIndex, arr);
+        }
+    });
+    var remapObj = function (obj) {
+        if (!obj || typeof obj !== 'object') {
+            return obj;
+        }
+        if (Array.isArray(obj)) {
+            return obj.map(remapObj);
+        }
+        if (obj.$or) {
+            var mapped = obj.$or.map(remapObj).filter(Boolean);
+            return mapped.length ? { $or: mapped } : null;
+        }
+        if (obj.$and) {
+            var mapped = obj.$and.map(remapObj).filter(Boolean);
+            return mapped.length ? { $and: mapped } : null;
+        }
+        var out = {};
+        Object.keys(obj).forEach(function (key) {
+            var cleanKey = key.replace(/\.\$/g, '');
+            if (cleanKey.startsWith('layout_col_')) {
+                // map to all field ids in that layout column index
+                var normalized = cleanKey.replace(/^layout_col_/, '');
+                var parts = normalized.split('_');
+                var idx = parseInt(parts[parts.length - 1], 10);
+                var targets = layoutMap.get(idx) || [];
+                if (targets.length) {
+                    var mappedVal_1 = remapObj(obj[key]);
+                    out.$or = targets.map(function (id) {
+                        var _a;
+                        return (_a = {}, _a[id] = mappedVal_1, _a);
+                    });
+                    return;
+                }
+            }
+            var mappedKey = byPath.get(cleanKey) || cleanKey;
+            out[mappedKey] = remapObj(obj[key]);
+        });
+        return Object.keys(out).length ? out : null;
+    };
+    return (filters || []).map(remapObj).filter(Boolean);
+}
+function expandLayoutColumnFilters(filters, selectedFields) {
+    if (filters === void 0) { filters = []; }
+    if (selectedFields === void 0) { selectedFields = []; }
+    var layoutCache = {};
+    var resolveLayoutPaths = function (layoutKey) {
+        if (layoutCache[layoutKey]) {
+            return layoutCache[layoutKey];
+        }
+        var paths = [];
+        var normalized = (layoutKey || '').replace(/^layout_col_/, '');
+        var parts = normalized.split('_');
+        var idx = parseInt(parts[parts.length - 1], 10);
+        if (!isNaN(idx)) {
+            paths = (selectedFields || [])
+                .filter(function (f) { return f && (f.layoutColumnIndex === idx || (f.id || '').includes("f_layout_".concat(idx, "_"))); })
+                .map(function (f) { return f.fieldPath ? f.fieldPath.replace(/\.\$/g, '') : ''; })
+                .filter(function (p) { return !!p; });
+        }
+        layoutCache[layoutKey] = paths;
+        return paths;
+    };
+    var expandFilterObject = function (obj) {
+        if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+            return obj;
+        }
+        if (obj.$or) {
+            return { $or: obj.$or.map(expandFilterObject) };
+        }
+        if (obj.$and) {
+            return { $and: obj.$and.map(expandFilterObject) };
+        }
+        var expanded = {};
+        var replaced = false;
+        Object.keys(obj).forEach(function (key) {
+            var val = obj[key];
+            if (key.startsWith('layout_col_')) {
+                var paths = resolveLayoutPaths(key);
+                if (paths.length) {
+                    replaced = true;
+                    expanded.$or = paths.map(function (path) {
+                        var _a;
+                        return (_a = {}, _a[path] = val, _a);
+                    });
+                    // Use console to trace layout filter expansion without requiring a logger on ResolveIOServer
+                    console.info('RB layout filter expansion', { layoutKey: key, paths: paths });
+                }
+                else {
+                    console.warn('RB layout filter expansion failed', { layoutKey: key, selectedFields: selectedFields });
+                }
+            }
+            else {
+                expanded[key] = val;
+            }
+        });
+        return replaced ? expanded : obj;
+    };
+    return (filters || []).map(expandFilterObject);
+}
+function executeReportBuilderAi(payload, context) {
+    return __awaiter(this, void 0, void 0, function () {
+        var input, prompt, isSuperAdmin, guardrailsEnabled, guardrail, reportTypeResolution, reportType, collectionRoot, collectionJoins, idDateField, dateInterval, collections, fieldLimit, resolvedFields, usedFallbackFields, derivedFields, trimmedFields, arraySummary, systemPrompt, userPrompt, codexModel, codexClient, runOptions, responseText, usage, parsed, allowMongoRead, mongoPayload, mongoReadResult, error_1, message, mongoContext, usage2, sanitizeContext, patch, summaryNotes, idClient;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    input = payload || {};
+                    prompt = normalizeOptionalString(input.prompt);
+                    if (!prompt) {
+                        throw new Error('Prompt is required.');
+                    }
+                    return [4 /*yield*/, resolveIsSuperAdmin(context === null || context === void 0 ? void 0 : context.id_user)];
+                case 1:
+                    isSuperAdmin = _a.sent();
+                    guardrailsEnabled = input.guardrails !== false && !isSuperAdmin;
+                    if (guardrailsEnabled) {
+                        guardrail = evaluateReportBuilderGuardrails(prompt);
+                        if (guardrail === null || guardrail === void 0 ? void 0 : guardrail.blocked) {
+                            return [2 /*return*/, guardrail];
+                        }
+                    }
+                    reportTypeResolution = resolveReportTypeForPrompt(input.report_type, prompt);
+                    reportType = reportTypeResolution.reportType;
+                    collectionRoot = normalizeOptionalString(input.collection_root);
+                    collectionJoins = Array.isArray(input.collection_joins) ? input.collection_joins : [];
+                    idDateField = normalizeOptionalString(input.id_date_field);
+                    dateInterval = normalizeDateInterval(input.date_interval) || reportTypeResolution.inferredDateInterval;
+                    collections = sanitizeCollections(input.available_collections || []);
+                    fieldLimit = normalizeFieldLimit(input.field_limit);
+                    resolvedFields = sanitizeFields(input.available_fields || []);
+                    usedFallbackFields = false;
+                    if (!resolvedFields.length && collections.length) {
+                        derivedFields = deriveFieldsFromCollections(collections);
+                        resolvedFields = sanitizeFields(derivedFields);
+                        usedFallbackFields = resolvedFields.length > 0;
+                    }
+                    trimmedFields = trimFieldsForPrompt(resolvedFields, fieldLimit, usedFallbackFields);
+                    arraySummary = buildArrayFieldSummary(trimmedFields.fields);
+                    systemPrompt = buildReportBuilderSystemPrompt(reportType);
+                    userPrompt = buildReportBuilderUserPrompt({
+                        prompt: prompt,
+                        reportType: reportType,
+                        reportName: normalizeOptionalString(input.report_name),
+                        collectionRoot: collectionRoot,
+                        collectionJoins: collectionJoins,
+                        idDateField: idDateField,
+                        dateInterval: dateInterval,
+                        collections: collections,
+                        fields: trimmedFields.fields,
+                        fieldMeta: {
+                            truncated: trimmedFields.truncated,
+                            total: trimmedFields.total,
+                            used: trimmedFields.fields.length
+                        },
+                        arraySummary: arraySummary
+                    });
+                    codexModel = resolveReportBuilderCodexModel(input.config);
+                    codexClient = getReportBuilderCodexClient();
+                    runOptions = {
+                        timeoutMs: resolveReportBuilderCodexTimeoutMs(input.config),
+                        threadOptions: resolveReportBuilderCodexThreadOptions(input.config, codexModel)
+                    };
+                    return [4 /*yield*/, codexClient.run(buildReportBuilderCodexPrompt(systemPrompt, userPrompt), runOptions)];
+                case 2:
+                    responseText = _a.sent();
+                    usage = estimateUsage([
+                        { role: 'system', content: systemPrompt },
+                        { role: 'user', content: userPrompt }
+                    ], responseText, codexModel);
+                    parsed = safeJsonParse(responseText);
+                    allowMongoRead = input.allow_mongo_read === true;
+                    if (!(allowMongoRead && parsed && typeof parsed === 'object' && parsed.mongo_read)) return [3 /*break*/, 8];
+                    mongoPayload = resolveMongoReadPayload(parsed.mongo_read, input, collections);
+                    if (!mongoPayload) return [3 /*break*/, 8];
+                    mongoReadResult = null;
+                    _a.label = 3;
+                case 3:
+                    _a.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, (0, ai_terminal_1.executeAiAssistantMongoRead)(mongoPayload, context)];
+                case 4:
+                    mongoReadResult = _a.sent();
+                    return [3 /*break*/, 6];
+                case 5:
+                    error_1 = _a.sent();
+                    message = error_1 instanceof Error ? error_1.message : String(error_1 || 'Mongo read failed.');
+                    mongoReadResult = { error: message };
+                    return [3 /*break*/, 6];
+                case 6:
+                    mongoContext = buildMongoReadContext(mongoPayload, mongoReadResult);
+                    userPrompt = buildReportBuilderUserPrompt({
+                        prompt: prompt,
+                        reportType: reportType,
+                        reportName: normalizeOptionalString(input.report_name),
+                        collectionRoot: collectionRoot,
+                        collectionJoins: collectionJoins,
+                        idDateField: idDateField,
+                        dateInterval: dateInterval,
+                        collections: collections,
+                        fields: trimmedFields.fields,
+                        fieldMeta: {
+                            truncated: trimmedFields.truncated,
+                            total: trimmedFields.total,
+                            used: trimmedFields.fields.length
+                        },
+                        arraySummary: arraySummary,
+                        mongoReadResult: mongoContext
+                    });
+                    return [4 /*yield*/, codexClient.run(buildReportBuilderCodexPrompt(systemPrompt, userPrompt), runOptions)];
+                case 7:
+                    responseText = _a.sent();
+                    usage2 = estimateUsage([
+                        { role: 'system', content: systemPrompt },
+                        { role: 'user', content: userPrompt }
+                    ], responseText, codexModel);
+                    usage = {
+                        inputTokens: usage.inputTokens + usage2.inputTokens,
+                        outputTokens: usage.outputTokens + usage2.outputTokens,
+                        totalTokens: usage.totalTokens + usage2.totalTokens
+                    };
+                    parsed = safeJsonParse(responseText);
+                    _a.label = 8;
+                case 8:
+                    if (!parsed || typeof parsed !== 'object') {
+                        throw new Error('AI response was not valid JSON.');
+                    }
+                    sanitizeContext = buildSanitizerContext(collections, resolvedFields);
+                    patch = sanitizeReportBuilderPatch(parsed, sanitizeContext);
+                    patch.report_type = reportType;
+                    if (reportType === 'Dated' && !patch.date_interval && dateInterval) {
+                        patch.date_interval = dateInterval;
+                    }
+                    summaryNotes = buildPatchNotes(patch, {
+                        reportType: reportType,
+                        truncated: trimmedFields.truncated,
+                        totalFields: trimmedFields.total,
+                        usedFields: trimmedFields.fields.length,
+                        inferenceReason: reportTypeResolution.inferenceReason
+                    });
+                    return [4 /*yield*/, resolveClientId(input.id_client, context === null || context === void 0 ? void 0 : context.id_user)];
+                case 9:
+                    idClient = _a.sent();
+                    return [4 /*yield*/, (0, openai_usage_ledger_manager_1.recordOpenAIUsage)({
+                            id_client: idClient || '',
+                            model: codexModel || 'unknown',
+                            input_tokens: usage.inputTokens,
+                            output_tokens: usage.outputTokens,
+                            total_tokens: usage.totalTokens,
+                            category: 'report-builder-ai',
+                            id_request: ''
+                        })];
+                case 10:
+                    _a.sent();
+                    return [2 /*return*/, {
+                            patch: patch,
+                            notes: summaryNotes,
+                            usage: {
+                                input_tokens: usage.inputTokens,
+                                output_tokens: usage.outputTokens,
+                                total_tokens: usage.totalTokens
+                            },
+                            model: codexModel
+                        }];
+            }
+        });
+    });
+}
+function buildReportBuilderSystemPrompt(reportType) {
+    return [
+        'You are a report builder configuration assistant.',
+        'Return ONLY a JSON object (no markdown).',
+        'Schema keys:',
+        '- report_name (string)',
+        '- collection_root (string)',
+        '- collection_joins (array of { collection, alias })',
+        '- layout_columns (array of { header, field_path, collection, mode, text, leaf_value_type, leaf_format_type, show })',
+        '- groups_row (array of field_path strings)',
+        '- filters (array of { field_path, condition, value, high_value, boolean_value, is_rolling, rolling_interval })',
+        '- sort (array of { field_path, order })',
+        '- totals (array of { type, fields })',
+        '- links (array of { field_first, field_second })',
+        '- id_date_field (string)',
+        '- date_interval (Seconds|Minutes|Hours|Daily|Weekly|Monthly|Quarterly|Yearly)',
+        '- notes (string)',
+        'Use only provided collections and field_path values (they reflect the current models/collections).',
+        'Always set collection_root to the best matching collection from available_collections.',
+        'When available_fields spans multiple collections, choose collection_root first and then select fields whose collection_name matches collection_root or a join alias.',
+        'Prefer exact field_path values from available_fields; never invent field paths.',
+        'Translate the request into concrete layout_columns, groups_row, sort, totals, filters, and links whenever possible.',
+        'Every layout column must be complete: include a header plus at least one mapping with a valid field_path (or text mode with non-empty text). Do not return columns without mapped fields.',
+        'Unless the user explicitly asks for a different order, add sort entries for the primary grouping/identifier fields (groups_row or the first key layout_columns) using ascending order so results are alphabetical.',
+        'Always prioritize sort on popular business keys when available: name, company, item (fallback: title, label, customer). Keep ascending unless user asks otherwise.',
+        'If no popular key exists, add stable fallback sort using createdAt/date_created then _id.',
+        'Use filters with explicit boolean logic: $and for required constraints and $or for alternate matches.',
+        'Use custom fields when the request asks for derived metrics (ratios, percentages, margins, computed totals).',
+        'If the request specifies a time grain (daily/weekly/monthly/etc), set date_interval and id_date_field to the best matching date field.',
+        'Treat requests like "over the last X", "by month", "by quarter", and "by <time period>" as Dated report intent.',
+        'If you need sample records to confirm field choices, you may return JSON with {"mongo_read": { "collection": "<collection>", "query": {}, "options": {"limit": 5} }, "notes": "why you need data"} .',
+        'Only request mongo_read when necessary and only use collections from available_collections.',
+        'When mongo_read_result is present in the user context, use it to finalize the patch and do not request another read.',
+        'Use field_type to guide filters/totals (numeric fields for totals, date fields for date_interval, boolean fields for boolean_value).',
+        'If field_summary.truncated is true, only use provided fields and note missing needs in notes.',
+        'If you need joined data, add collection_joins with an alias and use the alias in field_path.',
+        'When fields require related records, use lookup paths and joins rather than guessing flat field names.',
+        'array_summary lists array roots and candidate key_fields for linking arrays.',
+        'If you select fields from multiple array roots, add links that align arrays using shared identifiers (_id or id_<x> style keys).',
+        'Avoid mixing unrelated array roots without links; prefer a single array root or non-array fields to prevent duplicate rows.',
+        'Return a single valid JSON object with double quotes and no trailing commas.',
+        'Omit keys you cannot confidently fill.',
+        'Conditions allowed: eq, ne, lt, lte, gt, gte, bw, nnull, null, regex.',
+        "Report type: ".concat(reportType || 'List', ". Ensure groups_row is set for Group/Dated reports."),
+        'If unsure, leave a section empty instead of guessing.'
+    ].join('\n');
+}
+function buildReportBuilderUserPrompt(input) {
+    var context = {
+        report_type: input.reportType || 'List',
+        current: {
+            report_name: input.reportName || '',
+            collection_root: input.collectionRoot || '',
+            collection_joins: input.collectionJoins || [],
+            id_date_field: input.idDateField || '',
+            date_interval: input.dateInterval || ''
+        },
+        available_collections: input.collections || [],
+        available_fields: input.fields || [],
+        field_summary: input.fieldMeta || undefined,
+        array_summary: input.arraySummary || [],
+        mongo_read_result: input.mongoReadResult || undefined,
+        request: input.prompt
+    };
+    return JSON.stringify(context);
+}
+function resolveReportBuilderCodexTimeoutMs(config) {
+    var serverConfig = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+    var raw = normalizeOptionalNumber((config === null || config === void 0 ? void 0 : config.timeout_ms)
+        || serverConfig['REPORT_BUILDER_CODEX_TIMEOUT_MS']
+        || process.env.REPORT_BUILDER_CODEX_TIMEOUT_MS);
+    if (raw && raw > 0) {
+        return (0, common_1.round)(raw);
+    }
+    return DEFAULT_REPORT_BUILDER_CODEX_TIMEOUT_MS;
+}
+function resolveReportBuilderCodexModel(config) {
+    var serverConfig = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+    var overrideModel = normalizeOptionalString(config === null || config === void 0 ? void 0 : config.model);
+    var raw = overrideModel
+        || normalizeOptionalString(serverConfig['REPORT_BUILDER_CODEX_MODEL'] || process.env.REPORT_BUILDER_CODEX_MODEL)
+        || normalizeOptionalString(serverConfig['AI_DASHBOARD_CODEX_MODEL'] || process.env.AI_DASHBOARD_CODEX_MODEL)
+        || normalizeOptionalString(serverConfig['AI_TERMINAL_CODEX_MODEL'] || process.env.AI_TERMINAL_CODEX_MODEL)
+        || normalizeOptionalString(serverConfig['AI_ASSISTANT_CODEX_MODEL'] || process.env.AI_ASSISTANT_CODEX_MODEL);
+    return raw || DEFAULT_REPORT_BUILDER_CODEX_MODEL;
+}
+function resolveReportBuilderCodexFallbackModels(model) {
+    var serverConfig = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+    var primary = normalizeOptionalString(model || resolveReportBuilderCodexModel());
+    var models = [];
+    var push = function (value) {
+        var normalized = normalizeOptionalString(value);
+        if (!normalized || normalized === primary || models.includes(normalized)) {
+            return;
+        }
+        models.push(normalized);
+    };
+    var parseList = function (value) { return normalizeOptionalString(value)
+        .split(',')
+        .map(function (entry) { return normalizeOptionalString(entry); })
+        .filter(Boolean)
+        .forEach(push); };
+    parseList(serverConfig['REPORT_BUILDER_CODEX_FALLBACK_MODELS'] || process.env.REPORT_BUILDER_CODEX_FALLBACK_MODELS);
+    push(serverConfig['REPORT_BUILDER_CODEX_FALLBACK_MODEL'] || process.env.REPORT_BUILDER_CODEX_FALLBACK_MODEL);
+    parseList(serverConfig['AI_DASHBOARD_CODEX_FALLBACK_MODELS'] || process.env.AI_DASHBOARD_CODEX_FALLBACK_MODELS);
+    push(serverConfig['AI_DASHBOARD_CODEX_FALLBACK_MODEL'] || process.env.AI_DASHBOARD_CODEX_FALLBACK_MODEL);
+    parseList(serverConfig['AI_TERMINAL_CODEX_FALLBACK_MODELS'] || process.env.AI_TERMINAL_CODEX_FALLBACK_MODELS);
+    push(serverConfig['AI_TERMINAL_CODEX_FALLBACK_MODEL'] || process.env.AI_TERMINAL_CODEX_FALLBACK_MODEL);
+    parseList(serverConfig['AI_ASSISTANT_CODEX_FALLBACK_MODELS'] || process.env.AI_ASSISTANT_CODEX_FALLBACK_MODELS);
+    push(serverConfig['AI_ASSISTANT_CODEX_FALLBACK_MODEL'] || process.env.AI_ASSISTANT_CODEX_FALLBACK_MODEL);
+    if (!models.length) {
+        push(DEFAULT_REPORT_BUILDER_CODEX_FALLBACK_MODEL);
+    }
+    return models;
+}
+function resolveReportBuilderCodexSettings() {
+    var serverConfig = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+    var apiKey = (serverConfig['OPENAI_API_KEY'] || process.env.OPENAI_API_KEY || '').trim();
+    if (!apiKey) {
+        throw new Error('AI API key missing. Add an AI API key to server config.');
+    }
+    var model = resolveReportBuilderCodexModel();
+    var fallbackModels = resolveReportBuilderCodexFallbackModels(model);
+    return __assign(__assign({ apiKey: apiKey, baseUrl: (serverConfig['OPENAI_BASE_URL'] || process.env.OPENAI_BASE_URL || '').trim() || undefined, model: model }, (fallbackModels.length ? { fallbackModel: fallbackModels[0], fallbackModels: fallbackModels } : {})), { maxRetries: normalizeOptionalNumber(serverConfig['OPENAI_MAX_RETRIES'] || process.env.OPENAI_MAX_RETRIES), retryDelayMs: normalizeOptionalNumber(serverConfig['OPENAI_RETRY_DELAY_MS'] || process.env.OPENAI_RETRY_DELAY_MS) });
+}
+function resolveReportBuilderCodexThreadOptions(config, model) {
+    var serverConfig = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+    var effort = normalizeReasoningEffort((config === null || config === void 0 ? void 0 : config.reasoning_effort)
+        || serverConfig['REPORT_BUILDER_CODEX_REASONING_EFFORT']
+        || process.env.REPORT_BUILDER_CODEX_REASONING_EFFORT) || 'low';
+    return __assign(__assign({}, (model ? { model: model } : {})), { sandboxMode: 'read-only', skipGitRepoCheck: true, modelReasoningEffort: effort, networkAccessEnabled: false, webSearchMode: 'disabled', webSearchEnabled: false, approvalPolicy: 'never' });
+}
+function getReportBuilderCodexClient() {
+    if (!reportBuilderCodexClient) {
+        reportBuilderCodexClient = new codex_client_1.CodexClient(resolveReportBuilderCodexSettings());
+    }
+    return reportBuilderCodexClient;
+}
+function buildReportBuilderCodexPrompt(systemPrompt, userPrompt) {
+    return "System:\n".concat(systemPrompt, "\n\nUser:\n").concat(userPrompt).trim();
+}
+function resolveReportTypeForPrompt(inputType, prompt) {
+    var requestedType = normalizeReportType(inputType);
+    var inferredInterval = inferDateIntervalFromPrompt(prompt);
+    if (!isDatedPrompt(prompt)) {
+        return {
+            reportType: requestedType,
+            inferenceReason: '',
+            inferredDateInterval: inferredInterval
+        };
+    }
+    var reason = requestedType !== 'Dated'
+        ? 'Auto-inferred Dated report from time-period language in the request.'
+        : '';
+    return {
+        reportType: 'Dated',
+        inferenceReason: reason,
+        inferredDateInterval: inferredInterval
+    };
+}
+function isDatedPrompt(prompt) {
+    var text = normalizeOptionalString(prompt).toLowerCase();
+    if (!text) {
+        return false;
+    }
+    var patterns = [
+        /\b(by|per)\s+(day|week|month|quarter|year|hour|minute|second)s?\b/i,
+        /\b(daily|weekly|monthly|quarterly|yearly)\b/i,
+        /\b(last|past|previous|recent)\s+(?:\d+|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve)\s+(day|week|month|quarter|year|hour|minute|second)s?\b/i,
+        /\bover\s+the\s+last\s+(?:\d+|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve)\s+(day|week|month|quarter|year|hour|minute|second)s?\b/i,
+        /\b(month|quarter|year)\s+over\s+(month|quarter|year)\b/i,
+        /\b(over\s+time|time\s*series|trend(?:ing|s)?)\b/i,
+        /\bby\s+(?:a\s+)?(?:time|date)\s+period\b/i,
+        /\bby\s+period\b/i
+    ];
+    return patterns.some(function (pattern) { return pattern.test(text); });
+}
+function inferDateIntervalFromPrompt(prompt) {
+    var text = normalizeOptionalString(prompt).toLowerCase();
+    if (!text) {
+        return '';
+    }
+    var mapping = [
+        { interval: 'Quarterly', pattern: /\b(quarter|quarters|quarterly|qoq)\b/i },
+        { interval: 'Monthly', pattern: /\b(month|months|monthly|mom)\b/i },
+        { interval: 'Weekly', pattern: /\b(week|weeks|weekly|wow)\b/i },
+        { interval: 'Daily', pattern: /\b(day|days|daily)\b/i },
+        { interval: 'Yearly', pattern: /\b(year|years|yearly|yoy)\b/i },
+        { interval: 'Hours', pattern: /\b(hour|hours|hourly)\b/i },
+        { interval: 'Minutes', pattern: /\b(minute|minutes)\b/i },
+        { interval: 'Seconds', pattern: /\b(second|seconds)\b/i }
+    ];
+    var matched = mapping.find(function (entry) { return entry.pattern.test(text); });
+    return (matched === null || matched === void 0 ? void 0 : matched.interval) || '';
+}
+function normalizeReportType(value) {
+    var normalized = normalizeOptionalString(value);
+    if (normalized.toLowerCase() === 'group') {
+        return 'Group';
+    }
+    if (normalized.toLowerCase() === 'dated') {
+        return 'Dated';
+    }
+    return normalized ? (0, common_1.toTitleCase)(normalized) : 'List';
+}
+function normalizeOptionalString(value) {
+    var raw = typeof value === 'string' ? value.trim() : '';
+    return raw || '';
+}
+function normalizeOptionalNumber(value) {
+    var parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function normalizeReasoningEffort(value) {
+    var normalized = normalizeOptionalString(value).toLowerCase();
+    var allowed = new Set(['minimal', 'low', 'medium', 'high', 'xhigh']);
+    return allowed.has(normalized) ? normalized : undefined;
+}
+function normalizeFieldLimit(value) {
+    var parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        return 600;
+    }
+    return Math.max(50, Math.min((0, common_1.round)(parsed), 2000));
+}
+function estimateUsage(messages, responseText, model) {
+    var inputTokens = (0, tokenizer_1.countChatTokens)(messages, model);
+    var outputTokens = (0, tokenizer_1.countTokens)(responseText || '', model);
+    return {
+        inputTokens: inputTokens,
+        outputTokens: outputTokens,
+        totalTokens: inputTokens + outputTokens
+    };
+}
+function sanitizeCollections(raw) {
+    var out = [];
+    var seen = new Set();
+    (raw || []).forEach(function (entry) {
+        var collection = normalizeOptionalString(entry === null || entry === void 0 ? void 0 : entry.collection);
+        if (!collection) {
+            return;
+        }
+        var key = collection.toLowerCase();
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        out.push({
+            collection: collection,
+            name: normalizeOptionalString(entry === null || entry === void 0 ? void 0 : entry.name) || (0, common_1.toTitleCase)(collection.replace(/[-_]/g, ' '))
+        });
+    });
+    return out;
+}
+function sanitizeFields(raw) {
+    var out = [];
+    var seen = new Set();
+    (raw || []).forEach(function (entry) {
+        var fieldPath = normalizeOptionalString((entry === null || entry === void 0 ? void 0 : entry.field_path) || (entry === null || entry === void 0 ? void 0 : entry.fieldPath));
+        if (!fieldPath) {
+            return;
+        }
+        var key = fieldPath.toLowerCase();
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        out.push({
+            field_path: fieldPath,
+            field_path_name: normalizeOptionalString((entry === null || entry === void 0 ? void 0 : entry.field_path_name) || (entry === null || entry === void 0 ? void 0 : entry.fieldPathName) || (entry === null || entry === void 0 ? void 0 : entry.field_name)) || fieldPath,
+            field_type: normalizeOptionalString((entry === null || entry === void 0 ? void 0 : entry.field_type) || (entry === null || entry === void 0 ? void 0 : entry.fieldType) || (entry === null || entry === void 0 ? void 0 : entry.field_type_name) || (entry === null || entry === void 0 ? void 0 : entry.fieldTypeName)) || 'String',
+            collection_name: normalizeOptionalString((entry === null || entry === void 0 ? void 0 : entry.collection_name) || (entry === null || entry === void 0 ? void 0 : entry.collectionName) || (entry === null || entry === void 0 ? void 0 : entry.collection)) || ''
+        });
+    });
+    return out;
+}
+function resolveCollectionNameFromList(value, collections) {
+    var e_1, _a;
+    var key = normalizeKey(value);
+    if (!key) {
+        return '';
+    }
+    try {
+        for (var _b = __values(collections || []), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var col = _c.value;
+            if (normalizeKey(col.collection) === key || normalizeKey(col.name) === key) {
+                return col.collection;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return '';
+}
+function resolveMongoReadPayload(raw, input, collections) {
+    if (!raw || typeof raw !== 'object') {
+        return null;
+    }
+    var collection = resolveCollectionNameFromList(raw.collection || raw.collection_name || raw.collectionName, collections);
+    if (!collection) {
+        return null;
+    }
+    var query = raw.query && typeof raw.query === 'object' && !Array.isArray(raw.query) ? raw.query : {};
+    var optionsRaw = raw.options && typeof raw.options === 'object' ? raw.options : {};
+    var limitRaw = normalizeOptionalNumber(optionsRaw.limit);
+    var skipRaw = normalizeOptionalNumber(optionsRaw.skip);
+    var permissionView = normalizeOptionalString(input.permission_view || input.permissionView) || '/report-builder';
+    var request = {
+        collection: collection,
+        database: normalizeOptionalString(raw.database) || undefined,
+        query: query,
+        options: {
+            projection: optionsRaw.projection && typeof optionsRaw.projection === 'object' ? optionsRaw.projection : undefined,
+            sort: optionsRaw.sort && typeof optionsRaw.sort === 'object' ? optionsRaw.sort : undefined,
+            limit: limitRaw ? Math.min(Math.max((0, common_1.round)(limitRaw), 1), 10) : 5,
+            skip: skipRaw ? Math.max((0, common_1.round)(skipRaw), 0) : undefined,
+            includeTotal: optionsRaw.includeTotal === true
+        },
+        permissionView: permissionView || undefined,
+        id_client: normalizeOptionalString(input.id_client) || undefined,
+        mongo: input.mongo
+    };
+    return request;
+}
+function buildMongoReadContext(request, response) {
+    var documents = Array.isArray(response === null || response === void 0 ? void 0 : response.documents) ? response.documents : [];
+    var total = typeof (response === null || response === void 0 ? void 0 : response.total) === 'number' ? response.total : null;
+    var sample = summarizeMongoDocuments(documents);
+    return {
+        request: {
+            collection: request.collection,
+            query: request.query || {},
+            options: request.options || {}
+        },
+        result: {
+            total: total,
+            sample: sample,
+            fields: extractMongoSampleFields(sample)
+        }
+    };
+}
+function summarizeMongoDocuments(documents) {
+    var maxDocs = 5;
+    return (documents || []).slice(0, maxDocs).map(function (doc) { return pruneMongoValue(doc, 0); });
+}
+function pruneMongoValue(value, depth) {
+    var maxDepth = 3;
+    var maxKeys = 30;
+    var maxArray = 8;
+    var maxString = 200;
+    if (depth >= maxDepth) {
+        return '[Truncated]';
+    }
+    if (Array.isArray(value)) {
+        return value.slice(0, maxArray).map(function (item) { return pruneMongoValue(item, depth + 1); });
+    }
+    if (value && typeof value === 'object') {
+        var keys = Object.keys(value);
+        var trimmedKeys = keys.slice(0, maxKeys);
+        var result_1 = {};
+        trimmedKeys.forEach(function (key) {
+            result_1[key] = pruneMongoValue(value[key], depth + 1);
+        });
+        if (keys.length > trimmedKeys.length) {
+            result_1.__truncated__ = true;
+        }
+        return result_1;
+    }
+    if (typeof value === 'string' && value.length > maxString) {
+        return value.slice(0, maxString) + '...';
+    }
+    return value;
+}
+function extractMongoSampleFields(samples) {
+    var fields = new Set();
+    (samples || []).forEach(function (sample) {
+        if (!sample || typeof sample !== 'object') {
+            return;
+        }
+        Object.keys(sample).forEach(function (key) { return fields.add(key); });
+    });
+    return Array.from(fields);
+}
+function collectTreeLeaves(items, res) {
+    (items || []).forEach(function (item) {
+        var _a;
+        if (item === null || item === void 0 ? void 0 : item.isLeaf) {
+            res.push(item);
+            return;
+        }
+        if ((_a = item === null || item === void 0 ? void 0 : item.children) === null || _a === void 0 ? void 0 : _a.length) {
+            collectTreeLeaves(item.children, res);
+        }
+    });
+}
+function deriveFieldsFromCollections(collections) {
+    var fields = [];
+    var seen = new Set();
+    (collections || []).forEach(function (col) {
+        var collectionName = normalizeOptionalString(col === null || col === void 0 ? void 0 : col.collection);
+        if (!collectionName) {
+            return;
+        }
+        var tree;
+        try {
+            tree = buildCollectionTree(collectionName);
+        }
+        catch (error) {
+            var message = error instanceof Error ? error.message : String(error || 'Unknown error');
+            console.warn('RB AI field derivation failed', { collection: collectionName, error: message });
+            return;
+        }
+        var leaves = [];
+        collectTreeLeaves((tree === null || tree === void 0 ? void 0 : tree.children) || [], leaves);
+        leaves.forEach(function (leaf) {
+            var fieldPath = normalizeOptionalString(leaf === null || leaf === void 0 ? void 0 : leaf.fieldPath);
+            if (!fieldPath) {
+                return;
+            }
+            var key = fieldPath.toLowerCase();
+            if (seen.has(key)) {
+                return;
+            }
+            seen.add(key);
+            fields.push({
+                field_path: fieldPath,
+                field_path_name: normalizeOptionalString(leaf === null || leaf === void 0 ? void 0 : leaf.fieldPathName) || fieldPath,
+                field_type: normalizeOptionalString(leaf === null || leaf === void 0 ? void 0 : leaf.fieldType) || 'String',
+                collection_name: normalizeOptionalString((leaf === null || leaf === void 0 ? void 0 : leaf.collection_name) || (leaf === null || leaf === void 0 ? void 0 : leaf.collection)) || collectionName
+            });
+        });
+    });
+    return fields;
+}
+function trimFieldsForPrompt(fields, limit, balanceByCollection) {
+    var e_2, _a;
+    if (balanceByCollection === void 0) { balanceByCollection = false; }
+    if (!fields || !fields.length) {
+        return { fields: [], truncated: false, total: 0 };
+    }
+    if (fields.length <= limit) {
+        return { fields: fields, truncated: false, total: fields.length };
+    }
+    if (balanceByCollection) {
+        var buckets_1 = new Map();
+        var order_1 = [];
+        fields.forEach(function (field) {
+            var _a;
+            var key = normalizeOptionalString(field === null || field === void 0 ? void 0 : field.collection_name) || 'unknown';
+            if (!buckets_1.has(key)) {
+                buckets_1.set(key, []);
+                order_1.push(key);
+            }
+            (_a = buckets_1.get(key)) === null || _a === void 0 ? void 0 : _a.push(field);
+        });
+        if (buckets_1.size > 1) {
+            var trackers = order_1.map(function (key) { return ({
+                key: key,
+                list: buckets_1.get(key) || [],
+                index: 0
+            }); });
+            var trimmed_1 = [];
+            var added = true;
+            while (trimmed_1.length < limit && added) {
+                added = false;
+                try {
+                    for (var trackers_1 = (e_2 = void 0, __values(trackers)), trackers_1_1 = trackers_1.next(); !trackers_1_1.done; trackers_1_1 = trackers_1.next()) {
+                        var tracker = trackers_1_1.value;
+                        if (trimmed_1.length >= limit) {
+                            break;
+                        }
+                        if (tracker.index < tracker.list.length) {
+                            trimmed_1.push(tracker.list[tracker.index]);
+                            tracker.index += 1;
+                            added = true;
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (trackers_1_1 && !trackers_1_1.done && (_a = trackers_1.return)) _a.call(trackers_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            return { fields: trimmed_1, truncated: true, total: fields.length };
+        }
+    }
+    var trimmed = fields.slice(0, limit);
+    return { fields: trimmed, truncated: true, total: fields.length };
+}
+function buildArrayFieldSummary(fields) {
+    var roots = new Map();
+    (fields || []).forEach(function (field) {
+        var fieldPath = normalizeOptionalString(field === null || field === void 0 ? void 0 : field.field_path);
+        if (!fieldPath || !fieldPath.includes('.$')) {
+            return;
+        }
+        var root = resolveArrayRoot(fieldPath);
+        if (!root) {
+            return;
+        }
+        var entry = roots.get(root);
+        if (!entry) {
+            entry = { root_path: root, key_fields: [], sample_fields: [] };
+            roots.set(root, entry);
+        }
+        if (!entry.sample_fields.includes(fieldPath) && entry.sample_fields.length < 8) {
+            entry.sample_fields.push(fieldPath);
+        }
+        if (isLinkCandidateFieldPath(fieldPath) && !entry.key_fields.includes(fieldPath) && entry.key_fields.length < 8) {
+            entry.key_fields.push(fieldPath);
+        }
+    });
+    return Array.from(roots.values());
+}
+function buildSanitizerContext(collections, fields) {
+    var collectionIndex = new Map();
+    var fieldIndex = new Map();
+    var fieldNameIndex = new Map();
+    collections.forEach(function (col) {
+        var key = normalizeKey(col.collection);
+        if (key) {
+            collectionIndex.set(key, col);
+        }
+        var nameKey = normalizeKey(col.name);
+        if (nameKey) {
+            collectionIndex.set(nameKey, col);
+        }
+    });
+    fields.forEach(function (field) {
+        var pathKey = normalizePathKey(field.field_path);
+        if (pathKey) {
+            fieldIndex.set(pathKey, field);
+        }
+        var nameKey = normalizeKey(field.field_path_name);
+        if (nameKey && !fieldNameIndex.has(nameKey)) {
+            fieldNameIndex.set(nameKey, field.field_path);
+        }
+    });
+    return { collectionIndex: collectionIndex, fieldIndex: fieldIndex, fieldNameIndex: fieldNameIndex };
+}
+function sanitizeReportBuilderPatch(raw, ctx) {
+    var patch = {};
+    if (!raw || typeof raw !== 'object') {
+        return patch;
+    }
+    var reportName = normalizeOptionalString(raw.report_name || raw.reportName || raw.title);
+    if (reportName) {
+        patch.report_name = reportName.slice(0, 120);
+    }
+    var collectionRoot = resolveCollectionName(raw.collection_root || raw.collectionRoot, ctx);
+    if (collectionRoot) {
+        patch.collection_root = collectionRoot;
+    }
+    var joinsRaw = Array.isArray(raw.collection_joins || raw.joins) ? (raw.collection_joins || raw.joins) : [];
+    var joins = [];
+    joinsRaw.forEach(function (join) {
+        var collection = resolveCollectionName((join === null || join === void 0 ? void 0 : join.collection) || (join === null || join === void 0 ? void 0 : join.name), ctx);
+        if (!collection) {
+            return;
+        }
+        var alias = sanitizeAlias(join === null || join === void 0 ? void 0 : join.alias);
+        joins.push(__assign({ collection: collection }, (alias ? { alias: alias } : {})));
+    });
+    if (joins.length) {
+        patch.collection_joins = joins;
+    }
+    var layoutColumnsRaw = Array.isArray(raw.layout_columns || raw.columns || raw.layout) ? (raw.layout_columns || raw.columns || raw.layout) : [];
+    var layoutColumns = [];
+    layoutColumnsRaw.forEach(function (col) {
+        if (!col || typeof col !== 'object') {
+            return;
+        }
+        var header = normalizeOptionalString(col.header || col.title || col.name);
+        var fieldPath = resolveFieldPath(col.field_path || col.fieldPath || col.field || col.field_name || col.fieldName || col.path, ctx);
+        if (!fieldPath && header) {
+            fieldPath = resolveFieldPath(header, ctx);
+        }
+        var mappingsRaw = Array.isArray(col.mappings) ? col.mappings : [];
+        var mappings = [];
+        mappingsRaw.forEach(function (map) {
+            var mappedField = resolveFieldPath((map === null || map === void 0 ? void 0 : map.field_path) || (map === null || map === void 0 ? void 0 : map.fieldPath) || (map === null || map === void 0 ? void 0 : map.field) || (map === null || map === void 0 ? void 0 : map.field_name) || (map === null || map === void 0 ? void 0 : map.fieldName) || (map === null || map === void 0 ? void 0 : map.path) || (map === null || map === void 0 ? void 0 : map.name), ctx);
+            var mode = normalizeLayoutMode(map === null || map === void 0 ? void 0 : map.mode);
+            var text = normalizeOptionalString(map === null || map === void 0 ? void 0 : map.text);
+            var collection = resolveCollectionName(map === null || map === void 0 ? void 0 : map.collection, ctx);
+            if (mode === 'text') {
+                if (text) {
+                    mappings.push({
+                        mode: mode,
+                        text: text,
+                        collection: collection
+                    });
+                }
+            }
+            else if (mappedField) {
+                mappings.push({
+                    mode: mode,
+                    field_path: mappedField,
+                    collection: collection,
+                    leaf_value_type: normalizeOptionalString((map === null || map === void 0 ? void 0 : map.leaf_value_type) || (map === null || map === void 0 ? void 0 : map.leafValueType)),
+                    leaf_format_type: normalizeOptionalString((map === null || map === void 0 ? void 0 : map.leaf_format_type) || (map === null || map === void 0 ? void 0 : map.leafFormatType)),
+                    show: typeof (map === null || map === void 0 ? void 0 : map.show) === 'boolean' ? map.show : undefined
+                });
+            }
+        });
+        if (!mappings.length) {
+            if (fieldPath) {
+                mappings.push({ field_path: fieldPath, mode: normalizeLayoutMode(col.mode) });
+            }
+            else {
+                var text = normalizeOptionalString(col.text);
+                var mode = normalizeLayoutMode(col.mode);
+                if ((mode === 'text' || text) && text) {
+                    mappings.push({
+                        mode: 'text',
+                        text: text,
+                        collection: resolveCollectionName(col.collection, ctx)
+                    });
+                }
+            }
+        }
+        if (!fieldPath) {
+            var firstMapped = mappings.find(function (mapping) { return !!(mapping === null || mapping === void 0 ? void 0 : mapping.field_path); });
+            if (firstMapped === null || firstMapped === void 0 ? void 0 : firstMapped.field_path) {
+                fieldPath = firstMapped.field_path;
+            }
+        }
+        if (!header && fieldPath) {
+            var meta = ctx.fieldIndex.get(normalizePathKey(fieldPath));
+            header = normalizeOptionalString(meta === null || meta === void 0 ? void 0 : meta.field_path_name);
+        }
+        if (!mappings.length) {
+            return;
+        }
+        layoutColumns.push({
+            header: header || '',
+            field_path: fieldPath || '',
+            collection: resolveCollectionName(col.collection, ctx),
+            mode: normalizeLayoutMode(col.mode),
+            text: normalizeOptionalString(col.text),
+            mappings: mappings
+        });
+    });
+    if (!layoutColumns.length && Array.isArray(raw.selected_fields)) {
+        (raw.selected_fields || []).forEach(function (field) {
+            var fieldPath = resolveFieldPath(field, ctx);
+            if (!fieldPath) {
+                return;
+            }
+            layoutColumns.push({
+                header: '',
+                field_path: fieldPath,
+                mappings: [{ field_path: fieldPath }]
+            });
+        });
+    }
+    if (layoutColumns.length) {
+        patch.layout_columns = layoutColumns;
+    }
+    var groupsRowRaw = Array.isArray(raw.groups_row) ? raw.groups_row : [];
+    var groupsRow = groupsRowRaw.map(function (entry) { return resolveFieldPath(entry, ctx); }).filter(Boolean);
+    if (groupsRow.length) {
+        patch.groups_row = groupsRow;
+    }
+    var filtersRaw = Array.isArray(raw.filters) ? raw.filters : [];
+    var filters = [];
+    filtersRaw.forEach(function (filter) {
+        var fieldPath = resolveFieldPath((filter === null || filter === void 0 ? void 0 : filter.field_path) || (filter === null || filter === void 0 ? void 0 : filter.fieldPath), ctx);
+        if (!fieldPath) {
+            return;
+        }
+        var fieldMeta = ctx.fieldIndex.get(normalizePathKey(fieldPath));
+        var condition = normalizeFilterCondition(filter === null || filter === void 0 ? void 0 : filter.condition);
+        if (!condition) {
+            return;
+        }
+        var value = normalizeFilterValue(filter === null || filter === void 0 ? void 0 : filter.value, fieldMeta === null || fieldMeta === void 0 ? void 0 : fieldMeta.field_type);
+        var highValue = normalizeFilterValue(filter === null || filter === void 0 ? void 0 : filter.high_value, fieldMeta === null || fieldMeta === void 0 ? void 0 : fieldMeta.field_type);
+        var booleanValue = normalizeBooleanValue(filter === null || filter === void 0 ? void 0 : filter.boolean_value);
+        filters.push({
+            field_path: fieldPath,
+            condition: condition,
+            value: value,
+            high_value: highValue,
+            boolean_value: booleanValue,
+            is_rolling: typeof (filter === null || filter === void 0 ? void 0 : filter.is_rolling) === 'boolean' ? filter.is_rolling : undefined,
+            rolling_interval: normalizeOptionalString(filter === null || filter === void 0 ? void 0 : filter.rolling_interval)
+        });
+    });
+    if (filters.length) {
+        patch.filters = filters;
+    }
+    var sortRaw = Array.isArray(raw.sort) ? raw.sort : [];
+    var sort = [];
+    sortRaw.forEach(function (entry) {
+        var fieldPath = resolveFieldPath((entry === null || entry === void 0 ? void 0 : entry.field_path) || (entry === null || entry === void 0 ? void 0 : entry.fieldPath), ctx);
+        if (!fieldPath) {
+            return;
+        }
+        sort.push({
+            field_path: fieldPath,
+            order: normalizeSortOrder(entry === null || entry === void 0 ? void 0 : entry.order)
+        });
+    });
+    if (sort.length) {
+        patch.sort = sort;
+    }
+    else {
+        var defaultSortFields = buildDefaultSortFields(groupsRow, layoutColumns);
+        if (defaultSortFields.length) {
+            patch.sort = defaultSortFields.map(function (field_path) { return ({ field_path: field_path, order: 'asc' }); });
+        }
+    }
+    var totalsRaw = Array.isArray(raw.totals) ? raw.totals : [];
+    var totals = [];
+    totalsRaw.forEach(function (total) {
+        var type = normalizeTotalType(total === null || total === void 0 ? void 0 : total.type);
+        var fields = Array.isArray(total === null || total === void 0 ? void 0 : total.fields) ? total.fields : [];
+        var mappedFields = fields.map(function (field) { return resolveFieldPath(field, ctx); }).filter(Boolean);
+        if (!type || !mappedFields.length) {
+            return;
+        }
+        totals.push({ type: type, fields: mappedFields });
+    });
+    if (totals.length) {
+        patch.totals = totals;
+    }
+    var linksRaw = Array.isArray(raw.links) ? raw.links : [];
+    var links = [];
+    linksRaw.forEach(function (link) {
+        var first = resolveFieldPath((link === null || link === void 0 ? void 0 : link.field_first) || (link === null || link === void 0 ? void 0 : link.fieldFirst), ctx);
+        var second = resolveFieldPath((link === null || link === void 0 ? void 0 : link.field_second) || (link === null || link === void 0 ? void 0 : link.fieldSecond), ctx);
+        if (!first || !second) {
+            return;
+        }
+        links.push({ field_first: first, field_second: second });
+    });
+    if (links.length) {
+        patch.links = links;
+    }
+    var dateField = resolveFieldPath(raw.id_date_field || raw.date_field || raw.dateField, ctx);
+    if (dateField) {
+        patch.id_date_field = dateField;
+    }
+    var dateInterval = normalizeDateInterval(raw.date_interval || raw.dateInterval);
+    if (dateInterval) {
+        patch.date_interval = dateInterval;
+    }
+    var notes = normalizeOptionalString(raw.notes || raw.summary || raw.message);
+    if (notes) {
+        patch.notes = notes.slice(0, 400);
+    }
+    return patch;
+}
+function buildDefaultSortFields(groupsRow, layoutColumns) {
+    var fields = [];
+    var addField = function (fieldPath) {
+        var normalized = normalizeOptionalString(fieldPath);
+        if (normalized && !fields.includes(normalized)) {
+            fields.push(normalized);
+        }
+    };
+    (groupsRow || []).forEach(addField);
+    if (fields.length) {
+        return fields;
+    }
+    (layoutColumns || []).forEach(function (col) {
+        var e_3, _a;
+        if (!col || typeof col !== 'object') {
+            return;
+        }
+        var fieldPath = '';
+        var mappings = Array.isArray(col.mappings) ? col.mappings : [];
+        try {
+            for (var mappings_1 = __values(mappings), mappings_1_1 = mappings_1.next(); !mappings_1_1.done; mappings_1_1 = mappings_1.next()) {
+                var mapping = mappings_1_1.value;
+                if (mapping === null || mapping === void 0 ? void 0 : mapping.field_path) {
+                    fieldPath = mapping.field_path;
+                    break;
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (mappings_1_1 && !mappings_1_1.done && (_a = mappings_1.return)) _a.call(mappings_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        if (!fieldPath && col.field_path) {
+            fieldPath = col.field_path;
+        }
+        addField(fieldPath);
+    });
+    return fields;
+}
+function buildPatchNotes(patch, meta) {
+    var columns = Array.isArray(patch === null || patch === void 0 ? void 0 : patch.layout_columns) ? patch.layout_columns.length : 0;
+    var groups = Array.isArray(patch === null || patch === void 0 ? void 0 : patch.groups_row) ? patch.groups_row.length : 0;
+    var filters = Array.isArray(patch === null || patch === void 0 ? void 0 : patch.filters) ? patch.filters.length : 0;
+    var joins = Array.isArray(patch === null || patch === void 0 ? void 0 : patch.collection_joins) ? patch.collection_joins.length : 0;
+    var parts = [
+        "AI suggested ".concat(columns, " column").concat(columns === 1 ? '' : 's'),
+        groups ? "".concat(groups, " group").concat(groups === 1 ? '' : 's') : '',
+        filters ? "".concat(filters, " filter").concat(filters === 1 ? '' : 's') : '',
+        joins ? "".concat(joins, " join").concat(joins === 1 ? '' : 's') : ''
+    ].filter(Boolean);
+    var note = parts.length ? parts.join(', ') + '.' : 'AI suggestions ready.';
+    if (patch === null || patch === void 0 ? void 0 : patch.notes) {
+        note += " ".concat(patch.notes);
+    }
+    if (meta.inferenceReason) {
+        note += " ".concat(meta.inferenceReason);
+    }
+    if (meta.truncated) {
+        note += " Field list trimmed to ".concat(meta.usedFields, " of ").concat(meta.totalFields, " available fields.");
+    }
+    return note;
+}
+function normalizeLayoutMode(value) {
+    var normalized = normalizeOptionalString(value).toLowerCase();
+    return normalized === 'text' ? 'text' : 'variable';
+}
+function normalizeFilterCondition(value) {
+    var allowed = new Set(['eq', 'ne', 'lt', 'lte', 'gt', 'gte', 'bw', 'nnull', 'null', 'regex']);
+    var normalized = normalizeOptionalString(value).toLowerCase();
+    return allowed.has(normalized) ? normalized : '';
+}
+function normalizeSortOrder(value) {
+    var normalized = normalizeOptionalString(value).toLowerCase();
+    return normalized === 'dsc' || normalized === 'desc' ? 'dsc' : 'asc';
+}
+function normalizeTotalType(value) {
+    var normalized = normalizeOptionalString(value).toLowerCase();
+    if (normalized === 'avg' || normalized === 'sum') {
+        return normalized;
+    }
+    return '';
+}
+function normalizeDateInterval(value) {
+    var normalized = normalizeOptionalString(value);
+    if (!normalized) {
+        return '';
+    }
+    var map = {
+        seconds: 'Seconds',
+        minutes: 'Minutes',
+        hours: 'Hours',
+        daily: 'Daily',
+        weekly: 'Weekly',
+        monthly: 'Monthly',
+        quarterly: 'Quarterly',
+        yearly: 'Yearly'
+    };
+    var key = normalized.toLowerCase();
+    return map[key] || '';
+}
+function normalizeFilterValue(value, fieldType) {
+    if (fieldType === 'Number') {
+        var num = Number(value);
+        return Number.isFinite(num) ? num : value;
+    }
+    if (fieldType === 'Boolean') {
+        if (value === true || value === false) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            return value.toLowerCase() === 'true';
+        }
+        return value;
+    }
+    if (fieldType === 'Date') {
+        if (value instanceof Date) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            var parsed = new Date(value);
+            return isNaN(parsed.getTime()) ? value : parsed.toISOString();
+        }
+    }
+    return value;
+}
+function normalizeBooleanValue(value) {
+    if (value === true || value === false) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        if (value.toLowerCase() === 'true') {
+            return true;
+        }
+        if (value.toLowerCase() === 'false') {
+            return false;
+        }
+    }
+    return undefined;
+}
+function resolveCollectionName(value, ctx) {
+    var key = normalizeKey(value);
+    if (!key) {
+        return '';
+    }
+    var found = ctx.collectionIndex.get(key);
+    return found ? found.collection : '';
+}
+function resolveFieldPath(value, ctx) {
+    var _a;
+    var pathKey = normalizePathKey(value);
+    if (pathKey && ctx.fieldIndex.has(pathKey)) {
+        return ((_a = ctx.fieldIndex.get(pathKey)) === null || _a === void 0 ? void 0 : _a.field_path) || '';
+    }
+    var nameKey = normalizeKey(value);
+    if (nameKey && ctx.fieldNameIndex.has(nameKey)) {
+        return ctx.fieldNameIndex.get(nameKey) || '';
+    }
+    return '';
+}
+function sanitizeAlias(value) {
+    var alias = normalizeOptionalString(value);
+    if (!alias) {
+        return '';
+    }
+    return alias.replace(/[^\w\- ]/g, '').trim().slice(0, 40);
+}
+function normalizeKey(value) {
+    return normalizeOptionalString(value).toLowerCase().replace(/[^a-z0-9]+/g, '');
+}
+function normalizePathKey(value) {
+    return normalizeOptionalString(value).toLowerCase();
+}
+function resolveArrayRoot(path) {
+    var raw = normalizeOptionalString(path);
+    if (!raw) {
+        return '';
+    }
+    var idx = raw.indexOf('.$');
+    if (idx === -1) {
+        return '';
+    }
+    return raw.slice(0, idx);
+}
+function isLinkCandidateFieldPath(path) {
+    var normalized = normalizeOptionalString(path).toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    var last = (normalized.split('.').pop() || '').replace(/\$/g, '');
+    if (!last) {
+        return false;
+    }
+    if (last === 'id' || last === '_id') {
+        return true;
+    }
+    if (last.endsWith('_id') || last.endsWith('_uuid') || last.endsWith('_guid')) {
+        return true;
+    }
+    if (last.startsWith('id_')) {
+        return true;
+    }
+    return false;
+}
+function safeJsonParse(value) {
+    if (!value) {
+        return null;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch (_a) {
+        var match = value.match(/\{[\s\S]*\}/);
+        if (!match) {
+            return null;
+        }
+        try {
+            return JSON.parse(match[0]);
+        }
+        catch (_b) {
+            return null;
+        }
+    }
+}
+function evaluateReportBuilderGuardrails(message) {
+    var e_4, _a;
+    var normalized = String(message || '').toLowerCase();
+    var patterns = [
+        { pattern: /\b(source\s*code|full\s*code|entire\s*code|repo\s*dump|repository|git\s*clone)\b/i, reason: 'Code access is restricted.' },
+        { pattern: /\b(credentials?|passwords?|secrets?|tokens?)\b/i, reason: 'Credentials and secrets are restricted.' },
+        { pattern: /\b(delete|drop|truncate)\s+(database|db|schema|table)\b/i, reason: 'Database operations are restricted.' },
+        { pattern: /\b(shell|terminal|ssh|sudo|rm\s+-rf|chmod|chown)\b/i, reason: 'Server operations are restricted.' },
+        { pattern: /\b(exploit|bypass|malware|phishing|ransomware|ddos|sql\s*injection)\b/i, reason: 'Security abuse is restricted.' },
+        { pattern: /\b(credit\s*card|social\s*security|ssn|bank\s*account)\b/i, reason: 'Sensitive personal data is restricted.' }
+    ];
+    try {
+        for (var patterns_1 = __values(patterns), patterns_1_1 = patterns_1.next(); !patterns_1_1.done; patterns_1_1 = patterns_1.next()) {
+            var entry = patterns_1_1.value;
+            if (entry.pattern.test(normalized)) {
+                return {
+                    blocked: true,
+                    reason: entry.reason,
+                    response: 'I can’t help with that request because it could access restricted systems or data. Please describe the report you need (fields, filters, timeframe) and I can configure it safely.'
+                };
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (patterns_1_1 && !patterns_1_1.done && (_a = patterns_1.return)) _a.call(patterns_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return null;
+}
+function resolveIsSuperAdmin(id_user) {
+    return __awaiter(this, void 0, void 0, function () {
+        var user, _a;
+        var _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (!id_user) {
+                        return [2 /*return*/, false];
+                    }
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, user_collection_1.Users.findById(id_user)];
+                case 2:
+                    user = _c.sent();
+                    return [2 /*return*/, !!((_b = user === null || user === void 0 ? void 0 : user.roles) === null || _b === void 0 ? void 0 : _b.super_admin)];
+                case 3:
+                    _a = _c.sent();
+                    return [2 /*return*/, false];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+function resolveClientId(idClientInput, idUser) {
+    return __awaiter(this, void 0, void 0, function () {
+        var normalized, user, fromOther, _a;
+        var _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    normalized = normalizeOptionalString(idClientInput);
+                    if (normalized) {
+                        return [2 /*return*/, normalized];
+                    }
+                    if (!idUser) {
+                        return [2 /*return*/, ''];
+                    }
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, user_collection_1.Users.findById(idUser)];
+                case 2:
+                    user = _d.sent();
+                    fromOther = normalizeOptionalString(((_b = user === null || user === void 0 ? void 0 : user.other) === null || _b === void 0 ? void 0 : _b.id_client) || ((_c = user === null || user === void 0 ? void 0 : user.other) === null || _c === void 0 ? void 0 : _c.idClient));
+                    return [2 /*return*/, fromOther];
+                case 3:
+                    _a = _d.sent();
+                    return [2 /*return*/, ''];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+
+//# sourceMappingURL=report-builder.js.map