@resolveio/server-lib 22.1.21 → 22.1.23

package/methods/mongo-explorer.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -75,6 +86,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadMongoExplorerMethods = loadMongoExplorerMethods;
 var simpl_schema_1 = require("simpl-schema");
 var user_collection_1 = require("../collections/user.collection");
+var openai_usage_ledger_manager_1 = require("../managers/openai-usage-ledger.manager");
 var resolveio_server_app_1 = require("../resolveio-server-app");
 var openai_client_1 = require("../services/openai-client");
 var common_1 = require("../util/common");
@@ -91,6 +103,14 @@ var DEFAULT_RISK_REVIEW_TIMEOUT_MS = 30000;
 var DEFAULT_RISK_REVIEW_MAX_TOKENS = 700;
 var DEFAULT_RISK_REVIEW_MODEL = 'gpt-5.3-codex';
 var SENSITIVE_REVIEW_FIELD_REGEX = /(password|secret|token|api[_-]?key|salt|hash|email|phone|address|ssn|services|roles)/i;
+var DEFAULT_AI_SUGGEST_TIMEOUT_MS = 60000;
+var DEFAULT_AI_SUGGEST_MAX_TOKENS = 1000;
+var DEFAULT_AI_SUGGEST_MODEL = 'gpt-5.3-codex';
+var DEFAULT_AI_SUGGEST_FALLBACK_MODEL = 'gpt-5.2-codex';
+var MAX_AI_SUGGEST_FIELDS = 700;
+var MAX_AI_SUGGEST_COLLECTIONS = 800;
+var MAX_AI_SUGGEST_RESULTS = 500;
+var RESTRICTED_AGGREGATE_STAGES = new Set(['$out', '$merge']);
 function parseMongoExplorerWriteUsers() {
     var raw = typeof process.env.MONGO_EXPLORER_WRITE_USERS === 'string' ? process.env.MONGO_EXPLORER_WRITE_USERS.trim() : '';
     if (!raw) {
@@ -848,8 +868,479 @@ function reviewOperationRisk(input) {
         });
     });
 }
+function normalizeAiAction(value) {
+    var normalized = normalizeOptionalString(value) || '';
+    return normalized.toLowerCase() === 'aggregate' ? 'aggregate' : 'find';
+}
+function sanitizeAiCollections(raw) {
+    var values = [];
+    var seen = new Set();
+    (raw || []).forEach(function (entry) {
+        var normalized = normalizeOptionalString((entry === null || entry === void 0 ? void 0 : entry.collection) || (entry === null || entry === void 0 ? void 0 : entry.name) || entry);
+        if (!normalized) {
+            return;
+        }
+        var key = normalized.toLowerCase();
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        values.push(normalized);
+    });
+    return values.slice(0, MAX_AI_SUGGEST_COLLECTIONS);
+}
+function sanitizeAiFields(raw, fallbackCollection) {
+    var fields = [];
+    var seen = new Set();
+    (raw || []).forEach(function (entry) {
+        var path = normalizeOptionalString((entry === null || entry === void 0 ? void 0 : entry.path) || (entry === null || entry === void 0 ? void 0 : entry.field_path) || (entry === null || entry === void 0 ? void 0 : entry.fieldPath));
+        if (!path) {
+            return;
+        }
+        var collection = normalizeOptionalString((entry === null || entry === void 0 ? void 0 : entry.collection) || (entry === null || entry === void 0 ? void 0 : entry.collection_name) || (entry === null || entry === void 0 ? void 0 : entry.collectionName)) || fallbackCollection || '';
+        var key = "".concat(collection.toLowerCase(), "::").concat(path.toLowerCase());
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        fields.push({
+            path: path,
+            label: normalizeOptionalString((entry === null || entry === void 0 ? void 0 : entry.label) || (entry === null || entry === void 0 ? void 0 : entry.field_path_name) || (entry === null || entry === void 0 ? void 0 : entry.fieldPathName)) || path,
+            type: normalizeOptionalString((entry === null || entry === void 0 ? void 0 : entry.type) || (entry === null || entry === void 0 ? void 0 : entry.field_type) || (entry === null || entry === void 0 ? void 0 : entry.fieldType)) || 'Any',
+            collection: collection
+        });
+    });
+    return fields.slice(0, MAX_AI_SUGGEST_FIELDS);
+}
+function deriveAiFieldsFromCollection(database, collection) {
+    if (!collection) {
+        return [];
+    }
+    var managerCollection = resolveCollectionHandle(database, collection).managerCollection;
+    if (!managerCollection) {
+        return [];
+    }
+    var schema = getSchemaDefinition(managerCollection);
+    return Object.keys(schema)
+        .sort(function (a, b) { return a.localeCompare(b); })
+        .slice(0, MAX_AI_SUGGEST_FIELDS)
+        .map(function (path) {
+        var definition = schema[path];
+        return {
+            path: path,
+            label: toLabel(path),
+            type: getSchemaTypeName(definition),
+            collection: collection
+        };
+    });
+}
+function resolveCollectionFromList(value, collections, fallback) {
+    if (fallback === void 0) { fallback = ''; }
+    var normalized = normalizeOptionalString(value);
+    if (normalized) {
+        var matched = (collections || []).find(function (entry) { return entry.toLowerCase() === normalized.toLowerCase(); });
+        if (matched) {
+            return matched;
+        }
+    }
+    if (fallback) {
+        return fallback;
+    }
+    return (collections === null || collections === void 0 ? void 0 : collections[0]) || '';
+}
+function normalizeAiResultLimit(value, fallback) {
+    if (fallback === void 0) { fallback = 100; }
+    var fallbackValue = Math.min(Math.max(fallback, 1), MAX_AI_SUGGEST_RESULTS);
+    var parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return fallbackValue;
+    }
+    return Math.min(Math.max((0, common_1.round)(parsed), 1), MAX_AI_SUGGEST_RESULTS);
+}
+function normalizeAiSkip(value) {
+    var parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        return 0;
+    }
+    return Math.max(0, (0, common_1.round)(parsed));
+}
+function normalizeAiObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+function hasObjectKeys(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+function parseAiPlanPayload(content) {
+    var normalized = String(content || '').trim();
+    if (!normalized.length) {
+        return {};
+    }
+    try {
+        return JSON.parse(normalized);
+    }
+    catch (_a) {
+        // Fall through and parse embedded JSON object.
+    }
+    var start = normalized.indexOf('{');
+    var end = normalized.lastIndexOf('}');
+    if (start !== -1 && end > start) {
+        try {
+            return JSON.parse(normalized.slice(start, end + 1));
+        }
+        catch (_b) {
+            return {};
+        }
+    }
+    return {};
+}
+function resolveMongoExplorerAiSettings() {
+    var _a, _b, _c, _d;
+    var serverConfig = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
+    var apiKey = normalizeOptionalString(serverConfig['OPENAI_API_KEY'] || process.env.OPENAI_API_KEY) || '';
+    var baseUrl = normalizeOptionalString(serverConfig['OPENAI_BASE_URL'] || process.env.OPENAI_BASE_URL);
+    var model = normalizeOptionalString(serverConfig['MONGO_EXPLORER_AI_MODEL']
+        || process.env.MONGO_EXPLORER_AI_MODEL
+        || serverConfig['AI_ASSISTANT_CODEX_MODEL']
+        || process.env.AI_ASSISTANT_CODEX_MODEL
+        || serverConfig['OPENAI_MODEL']
+        || process.env.OPENAI_MODEL) || DEFAULT_AI_SUGGEST_MODEL;
+    var fallbackModel = normalizeOptionalString(serverConfig['MONGO_EXPLORER_AI_FALLBACK_MODEL']
+        || process.env.MONGO_EXPLORER_AI_FALLBACK_MODEL
+        || serverConfig['AI_ASSISTANT_CODEX_FALLBACK_MODEL']
+        || process.env.AI_ASSISTANT_CODEX_FALLBACK_MODEL) || DEFAULT_AI_SUGGEST_FALLBACK_MODEL;
+    var timeoutMs = normalizePositiveNumber((_a = serverConfig['MONGO_EXPLORER_AI_TIMEOUT_MS']) !== null && _a !== void 0 ? _a : process.env.MONGO_EXPLORER_AI_TIMEOUT_MS, DEFAULT_AI_SUGGEST_TIMEOUT_MS);
+    var maxTokens = normalizePositiveNumber((_b = serverConfig['MONGO_EXPLORER_AI_MAX_TOKENS']) !== null && _b !== void 0 ? _b : process.env.MONGO_EXPLORER_AI_MAX_TOKENS, DEFAULT_AI_SUGGEST_MAX_TOKENS);
+    var maxRetries = normalizePositiveNumber((_c = serverConfig['OPENAI_MAX_RETRIES']) !== null && _c !== void 0 ? _c : process.env.OPENAI_MAX_RETRIES, 1);
+    var retryDelayMs = normalizePositiveNumber((_d = serverConfig['OPENAI_RETRY_DELAY_MS']) !== null && _d !== void 0 ? _d : process.env.OPENAI_RETRY_DELAY_MS, 750);
+    return {
+        apiKey: apiKey,
+        baseUrl: baseUrl,
+        model: model,
+        fallbackModel: fallbackModel,
+        timeoutMs: timeoutMs,
+        maxTokens: maxTokens,
+        maxRetries: maxRetries,
+        retryDelayMs: retryDelayMs
+    };
+}
+function buildMongoExplorerAiSystemPrompt() {
+    return [
+        'You are a MongoDB query planner for a read-only Mongo Explorer UI.',
+        'Return a single JSON object and nothing else.',
+        'Supported schema:',
+        '{',
+        '  "action": "find|aggregate",',
+        '  "collection": "string",',
+        '  "query": { ... },',
+        '  "pipeline": [{ ... }],',
+        '  "options": {',
+        '    "projection": { "field": 1 },',
+        '    "sort": { "field": -1 },',
+        '    "limit": 100,',
+        '    "skip": 0,',
+        '    "includeTotal": true,',
+        '    "allowDiskUse": true',
+        '  },',
+        '  "notes": "short summary"',
+        '}',
+        'Rules:',
+        '- Use only provided collection names and field paths.',
+        '- Read-only only. Never output write operations, update/delete commands, or aggregation stages $out/$merge.',
+        '- Prefer action=find for direct lookups and simple filters.',
+        '- Use action=aggregate for grouped totals, rankings, or trend buckets.',
+        '- Keep options.limit between 1 and 500.',
+        '- If request is ambiguous, use selected_collection and a conservative limit.'
+    ].join('\n');
+}
+function buildMongoExplorerAiUserPrompt(input) {
+    var payload = {
+        request: input.prompt,
+        selected_collection: input.selectedCollection || '',
+        max_results: input.maxResults,
+        available_collections: input.availableCollections || [],
+        available_fields: input.availableFields || []
+    };
+    return JSON.stringify(payload);
+}
+function sanitizeAggregatePipeline(rawPipeline, limit) {
+    var source = Array.isArray(rawPipeline) ? rawPipeline : [];
+    var sanitized = [];
+    var removedRestricted = false;
+    source.forEach(function (stage) {
+        if (!stage || typeof stage !== 'object' || Array.isArray(stage)) {
+            return;
+        }
+        var keys = Object.keys(stage);
+        if (!keys.length) {
+            return;
+        }
+        var stageName = keys[0];
+        if (RESTRICTED_AGGREGATE_STAGES.has(String(stageName).toLowerCase())) {
+            removedRestricted = true;
+            return;
+        }
+        if (stageName === '$limit') {
+            sanitized.push({ $limit: normalizeAiResultLimit(stage.$limit, limit) });
+            return;
+        }
+        sanitized.push(stage);
+    });
+    if (!sanitized.some(function (stage) { return Object.keys(stage || {})[0] === '$limit'; })) {
+        sanitized.push({ $limit: limit });
+    }
+    return {
+        pipeline: sanitized,
+        removedRestricted: removedRestricted
+    };
+}
+function sanitizeFindOptions(raw, fallbackLimit) {
+    var options = normalizeAiObject(raw);
+    return {
+        projection: hasObjectKeys(options.projection) ? options.projection : undefined,
+        sort: hasObjectKeys(options.sort) ? options.sort : undefined,
+        limit: normalizeAiResultLimit(options.limit, fallbackLimit),
+        skip: normalizeAiSkip(options.skip),
+        includeTotal: options.includeTotal === true
+    };
+}
+function buildMongoExplorerAiNotes(rawNotes, action, collection, rowCount, total, removedRestricted) {
+    var notes = [];
+    var base = normalizeOptionalString(rawNotes);
+    if (base) {
+        notes.push(base);
+    }
+    var actionLabel = action === 'aggregate' ? 'aggregate pipeline' : 'query';
+    if (typeof total === 'number' && total >= 0) {
+        notes.push("Applied ".concat(actionLabel, " on ").concat(collection, ". Loaded ").concat(rowCount, " of ").concat(total, " rows."));
+    }
+    else {
+        notes.push("Applied ".concat(actionLabel, " on ").concat(collection, ". Loaded ").concat(rowCount, " rows."));
+    }
+    if (removedRestricted) {
+        notes.push('Removed restricted write stages from the generated pipeline.');
+    }
+    return notes.join(' ').trim();
+}
+function resolveUsageClientId(idClientInput, idUser) {
+    return __awaiter(this, void 0, void 0, function () {
+        var normalized, user, _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();
+                    return [2 /*return*/, 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)) || ''];
+                case 3:
+                    _a = _d.sent();
+                    return [2 /*return*/, ''];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+function executeMongoExplorerAi(payload, context) {
+    return __awaiter(this, void 0, void 0, function () {
+        var input, prompt, database, db, availableCollections, listed, selectedCollection, availableFields, settings, maxResults, client, response, parsed, action, collection, plan, removedRestrictedStages, optionsRaw, aggregateLimit, pipelineResult, aggregateOptions, aggregateRows, rows, query, options, findOptions, rows, total, _a, usage, idClient;
+        var _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    input = payload || {};
+                    prompt = normalizeOptionalString(input.prompt);
+                    if (!prompt) {
+                        throw new Error('Prompt is required.');
+                    }
+                    database = resolveDatabaseName(input.database);
+                    db = resolveDatabase(database);
+                    availableCollections = sanitizeAiCollections(input.available_collections || []);
+                    if (!!availableCollections.length) return [3 /*break*/, 2];
+                    return [4 /*yield*/, db.listCollections().toArray()];
+                case 1:
+                    listed = _c.sent();
+                    availableCollections = listed
+                        .map(function (collection) { return normalizeOptionalString(collection === null || collection === void 0 ? void 0 : collection.name); })
+                        .filter(function (collection) { return !!collection; })
+                        .slice(0, MAX_AI_SUGGEST_COLLECTIONS);
+                    _c.label = 2;
+                case 2:
+                    if (!availableCollections.length) {
+                        throw new Error('Mongo Explorer AI assistant: no collections available.');
+                    }
+                    selectedCollection = resolveCollectionFromList(input.selected_collection, availableCollections, availableCollections[0]);
+                    availableFields = sanitizeAiFields(input.available_fields || [], selectedCollection);
+                    if (!availableFields.length && selectedCollection) {
+                        availableFields = deriveAiFieldsFromCollection(database, selectedCollection);
+                    }
+                    settings = resolveMongoExplorerAiSettings();
+                    if (!settings.apiKey) {
+                        throw new Error('OpenAI API key missing. Add OPENAI_API_KEY to server config.');
+                    }
+                    maxResults = normalizeAiResultLimit(input.max_results, 100);
+                    client = new openai_client_1.OpenAIClient({
+                        apiKey: settings.apiKey,
+                        baseUrl: settings.baseUrl,
+                        model: settings.model,
+                        fallbackModel: settings.fallbackModel,
+                        temperature: 0.1,
+                        maxTokens: (0, common_1.round)(settings.maxTokens),
+                        maxRetries: (0, common_1.round)(settings.maxRetries),
+                        retryDelayMs: (0, common_1.round)(settings.retryDelayMs),
+                        responseFormat: 'json'
+                    });
+                    return [4 /*yield*/, client.chat([
+                            { role: 'system', content: buildMongoExplorerAiSystemPrompt() },
+                            {
+                                role: 'user',
+                                content: buildMongoExplorerAiUserPrompt({
+                                    prompt: prompt,
+                                    selectedCollection: selectedCollection,
+                                    availableCollections: availableCollections,
+                                    availableFields: availableFields,
+                                    maxResults: maxResults
+                                })
+                            }
+                        ], {
+                            timeoutMs: (0, common_1.round)(settings.timeoutMs),
+                            responseFormat: 'json'
+                        })];
+                case 3:
+                    response = _c.sent();
+                    parsed = parseAiPlanPayload(response.content);
+                    action = normalizeAiAction((parsed === null || parsed === void 0 ? void 0 : parsed.action) || (Array.isArray(parsed === null || parsed === void 0 ? void 0 : parsed.pipeline) ? 'aggregate' : 'find'));
+                    collection = resolveCollectionFromList((parsed === null || parsed === void 0 ? void 0 : parsed.collection) || (parsed === null || parsed === void 0 ? void 0 : parsed.collection_name), availableCollections, selectedCollection || availableCollections[0]);
+                    if (!collection) {
+                        throw new Error('Mongo Explorer AI assistant could not resolve a collection.');
+                    }
+                    plan = {
+                        action: action,
+                        collection: collection,
+                        options: {}
+                    };
+                    removedRestrictedStages = false;
+                    if (!(action === 'aggregate')) return [3 /*break*/, 5];
+                    optionsRaw = normalizeAiObject(parsed === null || parsed === void 0 ? void 0 : parsed.options);
+                    aggregateLimit = normalizeAiResultLimit((_b = optionsRaw.limit) !== null && _b !== void 0 ? _b : parsed === null || parsed === void 0 ? void 0 : parsed.limit, maxResults);
+                    pipelineResult = sanitizeAggregatePipeline(parsed === null || parsed === void 0 ? void 0 : parsed.pipeline, aggregateLimit);
+                    removedRestrictedStages = pipelineResult.removedRestricted;
+                    aggregateOptions = {
+                        allowDiskUse: optionsRaw.allowDiskUse === true
+                    };
+                    return [4 /*yield*/, db.collection(collection).aggregate(pipelineResult.pipeline, aggregateOptions).toArray()];
+                case 4:
+                    aggregateRows = _c.sent();
+                    rows = (aggregateRows || []).slice(0, aggregateLimit);
+                    plan = {
+                        action: action,
+                        collection: collection,
+                        pipeline: pipelineResult.pipeline,
+                        options: {
+                            allowDiskUse: aggregateOptions.allowDiskUse,
+                            limit: aggregateLimit
+                        },
+                        documents: rows,
+                        total: null
+                    };
+                    return [3 /*break*/, 10];
+                case 5:
+                    query = normalizeAiObject(parsed === null || parsed === void 0 ? void 0 : parsed.query);
+                    options = sanitizeFindOptions(parsed === null || parsed === void 0 ? void 0 : parsed.options, maxResults);
+                    findOptions = {
+                        limit: options.limit,
+                        skip: options.skip
+                    };
+                    if (options.projection) {
+                        findOptions.projection = options.projection;
+                    }
+                    if (options.sort) {
+                        findOptions.sort = options.sort;
+                    }
+                    return [4 /*yield*/, db.collection(collection).find(query, findOptions).toArray()];
+                case 6:
+                    rows = _c.sent();
+                    if (!options.includeTotal) return [3 /*break*/, 8];
+                    return [4 /*yield*/, db.collection(collection).countDocuments(query)];
+                case 7:
+                    _a = _c.sent();
+                    return [3 /*break*/, 9];
+                case 8:
+                    _a = null;
+                    _c.label = 9;
+                case 9:
+                    total = _a;
+                    plan = {
+                        action: action,
+                        collection: collection,
+                        query: query,
+                        options: __assign(__assign(__assign({}, (options.projection ? { projection: options.projection } : {})), (options.sort ? { sort: options.sort } : {})), { limit: options.limit, skip: options.skip, includeTotal: options.includeTotal }),
+                        documents: rows,
+                        total: total
+                    };
+                    _c.label = 10;
+                case 10:
+                    plan.notes = buildMongoExplorerAiNotes(parsed === null || parsed === void 0 ? void 0 : parsed.notes, plan.action, plan.collection, Array.isArray(plan.documents) ? plan.documents.length : 0, typeof plan.total === 'number' ? plan.total : null, removedRestrictedStages);
+                    usage = response.usage || { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+                    return [4 /*yield*/, resolveUsageClientId(input.id_client, context === null || context === void 0 ? void 0 : context.id_user)];
+                case 11:
+                    idClient = _c.sent();
+                    if (!(idClient && usage.totalTokens)) return [3 /*break*/, 13];
+                    return [4 /*yield*/, (0, openai_usage_ledger_manager_1.recordOpenAIUsage)({
+                            id_client: idClient,
+                            model: response.model || settings.model || 'unknown',
+                            input_tokens: usage.inputTokens || 0,
+                            output_tokens: usage.outputTokens || 0,
+                            total_tokens: usage.totalTokens || 0,
+                            category: 'mongo-explorer-ai',
+                            id_request: response.requestId || ''
+                        })];
+                case 12:
+                    _c.sent();
+                    _c.label = 13;
+                case 13: return [2 /*return*/, {
+                        notes: plan.notes,
+                        plan: plan,
+                        model: response.model || settings.model,
+                        usage: {
+                            input_tokens: usage.inputTokens || 0,
+                            output_tokens: usage.outputTokens || 0,
+                            total_tokens: usage.totalTokens || 0
+                        }
+                    }];
+            }
+        });
+    });
+}
 function loadMongoExplorerMethods(methodManager) {
     methodManager.methods({
+        mongoExplorerAiSuggest: {
+            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) {
+                        return [2 /*return*/, executeMongoExplorerAi(payload || {}, this)];
+                    });
+                });
+            }
+        },
         mongoExplorerListCollections: {
             check: new simpl_schema_1.default({
                 database: {