@resolveio/server-lib 22.0.21 → 22.0.23

package/methods/report-builder.js

@@ -1665,7 +1665,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, 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;
+        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:
@@ -1684,9 +1684,12 @@ function executeReportBuilderAi(payload, context) {
                             return [2 /*return*/, guardrail];
                         }
                     }
-                    reportType = normalizeReportType(input.report_type);
+                    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 || []);
@@ -1705,8 +1708,8 @@ function executeReportBuilderAi(payload, context) {
                         reportName: normalizeOptionalString(input.report_name),
                         collectionRoot: collectionRoot,
                         collectionJoins: collectionJoins,
-                        idDateField: normalizeOptionalString(input.id_date_field),
-                        dateInterval: normalizeOptionalString(input.date_interval),
+                        idDateField: idDateField,
+                        dateInterval: dateInterval,
                         collections: collections,
                         fields: trimmedFields.fields,
                         fieldMeta: {
@@ -1755,8 +1758,8 @@ function executeReportBuilderAi(payload, context) {
                         reportName: normalizeOptionalString(input.report_name),
                         collectionRoot: collectionRoot,
                         collectionJoins: collectionJoins,
-                        idDateField: normalizeOptionalString(input.id_date_field),
-                        dateInterval: normalizeOptionalString(input.date_interval),
+                        idDateField: idDateField,
+                        dateInterval: dateInterval,
                         collections: collections,
                         fields: trimmedFields.fields,
                         fieldMeta: {
@@ -1787,11 +1790,16 @@ function executeReportBuilderAi(payload, context) {
                     }
                     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
+                        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:
@@ -1852,6 +1860,7 @@ function buildReportBuilderSystemPrompt(reportType) {
         '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.',
@@ -1963,6 +1972,60 @@ function getReportBuilderCodexClient() {
 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') {
@@ -2586,6 +2649,9 @@ function buildPatchNotes(patch, meta) {
     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.");
     }