@resolveio/server-lib 20.13.12 → 20.14.0

package/methods/report-builder.js

@@ -71,17 +71,50 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     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 openai_client_1 = require("../services/openai-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");
 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: {
@@ -1625,5 +1658,713 @@ function expandLayoutColumnFilters(filters, selectedFields) {
     };
     return (filters || []).map(expandFilterObject);
 }
+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, systemPrompt, userPrompt, openaiSettings, client, responseFormat, response, usage, parsed, sanitizeContext, patch, summaryNotes, idClient;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.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 = _b.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];
+                        }
+                    }
+                    reportType = normalizeReportType(input.report_type);
+                    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);
+                    systemPrompt = buildReportBuilderSystemPrompt(reportType);
+                    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
+                    });
+                    openaiSettings = resolveReportBuilderOpenAISettings(input.config);
+                    client = new openai_client_1.OpenAIClient(openaiSettings);
+                    responseFormat = normalizeOpenAIResponseFormat((_a = input.config) === null || _a === void 0 ? void 0 : _a.response_format) || 'json';
+                    return [4 /*yield*/, client.chat([
+                            { role: 'system', content: systemPrompt },
+                            { role: 'user', content: userPrompt }
+                        ], { timeoutMs: 60000, responseFormat: responseFormat })];
+                case 2:
+                    response = _b.sent();
+                    usage = response.usage || estimateUsage([
+                        { role: 'system', content: systemPrompt },
+                        { role: 'user', content: userPrompt }
+                    ], response.content, response.model || openaiSettings.model);
+                    parsed = safeJsonParse(response.content);
+                    if (!parsed || typeof parsed !== 'object') {
+                        throw new Error('AI response was not valid JSON.');
+                    }
+                    sanitizeContext = buildSanitizerContext(collections, resolvedFields);
+                    patch = sanitizeReportBuilderPatch(parsed, sanitizeContext);
+                    summaryNotes = buildPatchNotes(patch, {
+                        reportType: reportType,
+                        truncated: trimmedFields.truncated,
+                        totalFields: trimmedFields.total,
+                        usedFields: trimmedFields.fields.length
+                    });
+                    return [4 /*yield*/, resolveClientId(input.id_client, context === null || context === void 0 ? void 0 : context.id_user)];
+                case 3:
+                    idClient = _b.sent();
+                    if (!idClient) return [3 /*break*/, 5];
+                    return [4 /*yield*/, (0, openai_usage_ledger_manager_1.recordOpenAIUsage)({
+                            id_client: idClient,
+                            model: response.model || openaiSettings.model || 'unknown',
+                            input_tokens: usage.inputTokens,
+                            output_tokens: usage.outputTokens,
+                            total_tokens: usage.totalTokens,
+                            category: 'report-builder-ai',
+                            id_request: response.requestId || ''
+                        })];
+                case 4:
+                    _b.sent();
+                    _b.label = 5;
+                case 5: return [2 /*return*/, {
+                        patch: patch,
+                        notes: summaryNotes,
+                        usage: {
+                            input_tokens: usage.inputTokens,
+                            output_tokens: usage.outputTokens,
+                            total_tokens: usage.totalTokens
+                        },
+                        model: response.model || openaiSettings.model
+                    }];
+            }
+        });
+    });
+}
+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.',
+        '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 || [],
+        request: input.prompt
+    };
+    return JSON.stringify(context);
+}
+function resolveReportBuilderOpenAISettings(config) {
+    var _a;
+    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('OpenAI API key missing. Add OPENAI_API_KEY to server config.');
+    }
+    var overrideModel = normalizeOptionalString(config === null || config === void 0 ? void 0 : config.model);
+    var model = overrideModel
+        || normalizeOptionalString(serverConfig['REPORT_BUILDER_OPENAI_MODEL'] || process.env.REPORT_BUILDER_OPENAI_MODEL)
+        || normalizeOptionalString(serverConfig['OPENAI_MODEL'] || process.env.OPENAI_MODEL)
+        || 'gpt-5.1';
+    return {
+        apiKey: apiKey,
+        baseUrl: (serverConfig['OPENAI_BASE_URL'] || process.env.OPENAI_BASE_URL || '').trim() || undefined,
+        model: model,
+        temperature: (_a = normalizeOptionalNumber(config === null || config === void 0 ? void 0 : config.temperature)) !== null && _a !== void 0 ? _a : 0.2,
+        maxTokens: normalizeOptionalNumber(config === null || config === void 0 ? void 0 : config.max_tokens),
+        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 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 normalizeOpenAIResponseFormat(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        var normalized = value.trim().toLowerCase();
+        if (!normalized) {
+            return undefined;
+        }
+        if (normalized === 'text' || normalized === 'json' || normalized === 'json_object') {
+            return normalized;
+        }
+        return { type: normalized };
+    }
+    if (typeof value === 'object') {
+        var typeValue = normalizeOptionalString(value.type);
+        if (!typeValue) {
+            return undefined;
+        }
+        return __assign(__assign({}, value), { type: typeValue });
+    }
+    return 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 trimFieldsForPrompt(fields, limit) {
+    if (!fields || !fields.length) {
+        return { fields: [], truncated: false, total: 0 };
+    }
+    if (fields.length <= limit) {
+        return { fields: fields, truncated: false, total: fields.length };
+    }
+    var trimmed = fields.slice(0, limit);
+    return { fields: trimmed, truncated: true, total: fields.length };
+}
+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, 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), 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') {
+                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 && fieldPath) {
+            mappings.push({ field_path: fieldPath, mode: normalizeLayoutMode(col.mode) });
+        }
+        if (!header && !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;
+    }
+    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 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.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 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_1, _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_1_1) { e_1 = { error: e_1_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; }
+    }
+    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