@resolveio/server-lib 20.14.3 → 20.14.5

package/methods/report-builder.js

@@ -95,6 +95,7 @@ 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.2-codex';
 var DEFAULT_REPORT_BUILDER_CODEX_TIMEOUT_MS = 60000;
 var reportBuilderCodexClient = null;
@@ -1663,7 +1664,7 @@ function expandLayoutColumnFilters(filters, selectedFields) {
 }
 function executeReportBuilderAi(payload, context) {
     return __awaiter(this, void 0, void 0, function () {
-        var input, prompt, isSuperAdmin, guardrailsEnabled, guardrail, reportType, collectionRoot, collectionJoins, collections, resolvedFields, fieldLimit, trimmedFields, arraySummary, systemPrompt, userPrompt, codexModel, codexClient, codexPrompt, runOptions, responseText, usage, parsed, sanitizeContext, patch, summaryNotes, idClient;
+        var input, prompt, isSuperAdmin, guardrailsEnabled, guardrail, reportType, collectionRoot, collectionJoins, 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:
@@ -1686,9 +1687,15 @@ function executeReportBuilderAi(payload, context) {
                     collectionRoot = normalizeOptionalString(input.collection_root);
                     collectionJoins = Array.isArray(input.collection_joins) ? input.collection_joins : [];
                     collections = sanitizeCollections(input.available_collections || []);
-                    resolvedFields = sanitizeFields(input.available_fields || []);
                     fieldLimit = normalizeFieldLimit(input.field_limit);
-                    trimmedFields = trimFieldsForPrompt(resolvedFields, fieldLimit);
+                    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({
@@ -1710,12 +1717,11 @@ function executeReportBuilderAi(payload, context) {
                     });
                     codexModel = resolveReportBuilderCodexModel(input.config);
                     codexClient = getReportBuilderCodexClient();
-                    codexPrompt = buildReportBuilderCodexPrompt(systemPrompt, userPrompt);
                     runOptions = {
                         timeoutMs: resolveReportBuilderCodexTimeoutMs(input.config),
                         threadOptions: resolveReportBuilderCodexThreadOptions(input.config, codexModel)
                     };
-                    return [4 /*yield*/, codexClient.run(codexPrompt, runOptions)];
+                    return [4 /*yield*/, codexClient.run(buildReportBuilderCodexPrompt(systemPrompt, userPrompt), runOptions)];
                 case 2:
                     responseText = _a.sent();
                     usage = estimateUsage([
@@ -1723,6 +1729,58 @@ function executeReportBuilderAi(payload, context) {
                         { 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: normalizeOptionalString(input.id_date_field),
+                        dateInterval: normalizeOptionalString(input.date_interval),
+                        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.');
                     }
@@ -1735,9 +1793,9 @@ function executeReportBuilderAi(payload, context) {
                         usedFields: trimmedFields.fields.length
                     });
                     return [4 /*yield*/, resolveClientId(input.id_client, context === null || context === void 0 ? void 0 : context.id_user)];
-                case 3:
+                case 9:
                     idClient = _a.sent();
-                    if (!idClient) return [3 /*break*/, 5];
+                    if (!idClient) return [3 /*break*/, 11];
                     return [4 /*yield*/, (0, openai_usage_ledger_manager_1.recordOpenAIUsage)({
                             id_client: idClient,
                             model: codexModel || 'unknown',
@@ -1747,10 +1805,10 @@ function executeReportBuilderAi(payload, context) {
                             category: 'report-builder-ai',
                             id_request: ''
                         })];
-                case 4:
+                case 10:
                     _a.sent();
-                    _a.label = 5;
-                case 5: return [2 /*return*/, {
+                    _a.label = 11;
+                case 11: return [2 /*return*/, {
                         patch: patch,
                         notes: summaryNotes,
                         usage: {
@@ -1783,7 +1841,13 @@ function buildReportBuilderSystemPrompt(reportType) {
         '- 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.',
+        'If the request specifies a time grain (daily/weekly/monthly/etc), set date_interval and id_date_field to the best matching date field.',
+        '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.',
@@ -1811,6 +1875,7 @@ function buildReportBuilderUserPrompt(input) {
         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);
@@ -1946,13 +2011,224 @@ function sanitizeFields(raw) {
     });
     return out;
 }
-function trimFieldsForPrompt(fields, limit) {
+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 };
 }
@@ -2368,7 +2644,7 @@ function safeJsonParse(value) {
     }
 }
 function evaluateReportBuilderGuardrails(message) {
-    var e_1, _a;
+    var e_3, _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.' },
@@ -2390,12 +2666,12 @@ function evaluateReportBuilderGuardrails(message) {
             }
         }
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
     finally {
         try {
             if (patterns_1_1 && !patterns_1_1.done && (_a = patterns_1.return)) _a.call(patterns_1);
         }
-        finally { if (e_1) throw e_1.error; }
+        finally { if (e_3) throw e_3.error; }
     }
     return null;
 }