@intranefr/superbackend 1.4.3

package/src/controllers/adminLlm.controller.js

@@ -0,0 +1,273 @@
+const GlobalSetting = require("../models/GlobalSetting");
+const AuditEvent = require("../models/AuditEvent");
+const llmService = require("../services/llm.service");
+const { encryptString } = require("../utils/encryption");
+
+const PROVIDERS_KEY = "llm.providers";
+const PROMPTS_KEY = "llm.prompts";
+
+async function getJsonSetting(key, defaultValue) {
+  const doc = await GlobalSetting.findOne({ key }).lean();
+  if (!doc || !doc.value) return defaultValue;
+  try {
+    const parsed = JSON.parse(doc.value);
+    return parsed || defaultValue;
+  } catch (e) {
+    return defaultValue;
+  }
+}
+
+async function setJsonSetting(key, value) {
+  const descriptions = {
+    [PROVIDERS_KEY]: "LLM providers configuration (JSON)",
+    [PROMPTS_KEY]: "LLM prompts configuration (JSON)",
+  };
+  const description = descriptions[key] || `LLM setting ${key}`;
+  const stringValue = JSON.stringify(value || {});
+  const existing = await GlobalSetting.findOne({ key });
+  if (existing) {
+    existing.value = stringValue;
+    existing.type = "json";
+    if (!existing.description) {
+      existing.description = description;
+    }
+    await existing.save();
+    return existing;
+  }
+  const created = new GlobalSetting({
+    key,
+    value: stringValue,
+    type: "json",
+    description,
+  });
+  await created.save();
+  return created;
+}
+
+async function getConfig(req, res) {
+  try {
+    const providers = await getJsonSetting(PROVIDERS_KEY, {});
+    const prompts = await getJsonSetting(PROMPTS_KEY, {});
+    const safeProviders = {};
+    if (providers && typeof providers === "object") {
+      for (const [key, value] of Object.entries(providers)) {
+        if (!value || typeof value !== "object") continue;
+        const { apiKey, ...rest } = value;
+        safeProviders[key] = rest;
+      }
+    }
+    res.json({ providers: safeProviders, prompts });
+  } catch (error) {
+    console.error("[adminLlm] getConfig error", error);
+    res.status(500).json({ error: "Failed to load LLM configuration" });
+  }
+}
+
+async function saveConfig(req, res) {
+  try {
+    const body = req.body || {};
+    const providers = body.providers && typeof body.providers === "object" ? body.providers : {};
+    const prompts = body.prompts && typeof body.prompts === "object" ? body.prompts : {};
+
+    const storedProviders = {};
+    for (const [key, value] of Object.entries(providers)) {
+      if (!value || typeof value !== "object") continue;
+      const clone = { ...value };
+      const rawApiKey = typeof clone.apiKey === "string" ? clone.apiKey.trim() : "";
+      delete clone.apiKey;
+      storedProviders[key] = clone;
+
+      if (rawApiKey) {
+        const encrypted = encryptString(rawApiKey);
+        const settingKey = `llm.provider.${key}.apiKey`;
+        let doc = await GlobalSetting.findOne({ key: settingKey });
+        if (!doc) {
+          doc = new GlobalSetting({
+            key: settingKey,
+            description: `Encrypted API key for LLM provider ${key}`,
+            type: "encrypted",
+            value: JSON.stringify(encrypted),
+          });
+        } else {
+          if (!doc.description) {
+            doc.description = `Encrypted API key for LLM provider ${key}`;
+          }
+          doc.type = "encrypted";
+          doc.value = JSON.stringify(encrypted);
+        }
+        await doc.save();
+      }
+    }
+
+    await setJsonSetting(PROVIDERS_KEY, storedProviders);
+    await setJsonSetting(PROMPTS_KEY, prompts);
+
+    res.json({ success: true });
+  } catch (error) {
+    console.error("[adminLlm] saveConfig error", error);
+    res.status(500).json({ error: "Failed to save LLM configuration" });
+  }
+}
+
+async function testPrompt(req, res) {
+  try {
+    const promptKey = String(req.params.key || "");
+    const { variables, options } = req.body || {};
+
+    const result = await llmService.testPrompt(
+      { key: promptKey },
+      variables || {},
+      options || {},
+    );
+
+    res.json({ result });
+  } catch (error) {
+    console.error("[adminLlm] testPrompt error", error);
+    res.status(500).json({ error: error.message || "Failed to test prompt" });
+  }
+}
+
+async function listAudit(req, res) {
+  try {
+    const page = Math.max(parseInt(req.query.page, 10) || 1, 1);
+    const pageSize = Math.min(Math.max(parseInt(req.query.pageSize, 10) || 20, 1), 200);
+    const promptKey = String(req.query.promptKey || "").trim();
+    const providerKey = String(req.query.providerKey || "").trim();
+    const status = String(req.query.status || "").trim();
+
+    const query = { action: "llm.completion" };
+
+    if (status === "success" || status === "failure") {
+      query.outcome = status;
+    }
+
+    if (promptKey) {
+      query["meta.promptKey"] = promptKey;
+    }
+
+    if (providerKey) {
+      query["meta.providerKey"] = providerKey;
+    }
+
+    const total = await AuditEvent.countDocuments(query);
+    const items = await AuditEvent.find(query)
+      .sort({ createdAt: -1 })
+      .skip((page - 1) * pageSize)
+      .limit(pageSize)
+      .lean();
+
+    res.json({
+      page,
+      pageSize,
+      total,
+      items,
+    });
+  } catch (error) {
+    console.error("[adminLlm] listAudit error", error);
+    res.status(500).json({ error: "Failed to load LLM audit entries" });
+  }
+}
+
+function computeCostFromPricing({ prompt_tokens, completion_tokens }, modelPricing) {
+  if (!modelPricing || typeof modelPricing !== "object") return null;
+
+  const promptTokens = Number(prompt_tokens);
+  const completionTokens = Number(completion_tokens);
+  if (!Number.isFinite(promptTokens) && !Number.isFinite(completionTokens)) return null;
+
+  const inRate = Number(modelPricing.costPerMillionIn);
+  const outRate = Number(modelPricing.costPerMillionOut);
+  if (!Number.isFinite(inRate) && !Number.isFinite(outRate)) return null;
+
+  const costIn = Number.isFinite(promptTokens) && Number.isFinite(inRate)
+    ? (promptTokens / 1_000_000) * inRate
+    : 0;
+  const costOut = Number.isFinite(completionTokens) && Number.isFinite(outRate)
+    ? (completionTokens / 1_000_000) * outRate
+    : 0;
+
+  const total = costIn + costOut;
+  return Number.isFinite(total) ? total : null;
+}
+
+async function listCosts(req, res) {
+  try {
+    const page = Math.max(parseInt(req.query.page, 10) || 1, 1);
+    const pageSize = Math.min(Math.max(parseInt(req.query.pageSize, 10) || 20, 1), 200);
+    const promptKey = String(req.query.promptKey || "").trim();
+    const providerKey = String(req.query.providerKey || "").trim();
+    const model = String(req.query.model || "").trim();
+
+    const query = { action: "llm.completion", outcome: "success" };
+    if (promptKey) query["meta.promptKey"] = promptKey;
+    if (providerKey) query["meta.providerKey"] = providerKey;
+    if (model) query["meta.model"] = model;
+
+    const providers = await getJsonSetting(PROVIDERS_KEY, {});
+
+    const total = await AuditEvent.countDocuments(query);
+    const items = await AuditEvent.find(query)
+      .sort({ createdAt: -1 })
+      .skip((page - 1) * pageSize)
+      .limit(pageSize)
+      .lean();
+
+    const normalizedItems = (items || []).map((ev) => {
+      const meta = ev.meta || {};
+      const usage = meta.usage && typeof meta.usage === "object" ? { ...meta.usage } : null;
+
+      const promptTokens = usage ? usage.prompt_tokens : null;
+      const completionTokens = usage ? usage.completion_tokens : null;
+      const totalTokens = usage ? usage.total_tokens : null;
+      const existingCost = usage ? usage.cost : undefined;
+
+      let cost = existingCost;
+      let costSource = usage ? usage.cost_source : undefined;
+
+      if ((cost === undefined || cost === null) && usage) {
+        const p = providers && typeof providers === "object" ? providers[meta.providerKey] : null;
+        const modelPricing = p && typeof p === "object" && p.modelPricing && typeof p.modelPricing === "object"
+          ? p.modelPricing[meta.model]
+          : null;
+        const computed = modelPricing
+          ? computeCostFromPricing(usage, modelPricing)
+          : null;
+        if (computed !== null) {
+          cost = computed;
+          costSource = costSource || "computed_current";
+        }
+      }
+
+      return {
+        id: ev._id,
+        createdAt: ev.createdAt,
+        promptKey: meta.promptKey,
+        providerKey: meta.providerKey,
+        model: meta.model,
+        prompt_tokens: promptTokens,
+        completion_tokens: completionTokens,
+        total_tokens: totalTokens,
+        cost,
+        cost_source: costSource,
+      };
+    });
+
+    res.json({
+      page,
+      pageSize,
+      total,
+      items: normalizedItems,
+    });
+  } catch (error) {
+    console.error("[adminLlm] listCosts error", error);
+    res.status(500).json({ error: "Failed to load LLM cost entries" });
+  }
+}
+
+module.exports = {
+  getConfig,
+  saveConfig,
+  testPrompt,
+  listAudit,
+  listCosts,
+};

package/src/controllers/adminMigration.controller.js

@@ -0,0 +1,257 @@
+const migrationService = require('../services/migration.service');
+
+function getModelRegistry() {
+  return globalThis?.saasbackend?.models || null;
+}
+
+function getModelByName(modelName) {
+  const registry = getModelRegistry();
+  if (!registry) return null;
+  return registry[String(modelName || '')] || null;
+}
+
+function describeSchema(model) {
+  const schemaPaths = model?.schema?.paths || {};
+  const fields = [];
+
+  for (const [key, pathDef] of Object.entries(schemaPaths)) {
+    if (key === '__v') continue;
+    const instance = pathDef?.instance || null;
+    const enumValues = Array.isArray(pathDef?.enumValues) && pathDef.enumValues.length > 0
+      ? pathDef.enumValues
+      : (Array.isArray(pathDef?.options?.enum) && pathDef.options.enum.length > 0 ? pathDef.options.enum : null);
+    const isRequired = Array.isArray(pathDef?.validators)
+      ? pathDef.validators.some((v) => v && v.type === 'required')
+      : false;
+
+    fields.push({
+      key,
+      type: instance,
+      required: isRequired,
+      enumValues,
+    });
+  }
+
+  fields.sort((a, b) => a.key.localeCompare(b.key));
+  return {
+    modelName: model?.modelName,
+    fields,
+  };
+}
+
+function safeJsonParse(value, fallback) {
+  try {
+    return JSON.parse(value);
+  } catch (_) {
+    return fallback;
+  }
+}
+
+exports.listEnvironments = async (req, res) => {
+  try {
+    const { envKey, include } = req.query || {};
+    if (envKey && include === 'full') {
+      const env = await migrationService.getEnvironmentConfig(envKey);
+      if (!env) return res.status(404).json({ error: 'Environment not found' });
+      return res.json({ environment: env, environments: [env] });
+    }
+
+    const environments = await migrationService.listEnvironments();
+    res.json({ environments });
+  } catch (e) {
+    res.status(500).json({ error: e?.message ? String(e.message) : 'Failed to list environments' });
+  }
+};
+
+exports.listModels = async (req, res) => {
+  try {
+    const registry = getModelRegistry();
+    if (!registry) {
+      return res.status(500).json({ error: 'saasbackend models registry is not available' });
+    }
+    const models = Object.keys(registry).sort();
+    res.json({ models });
+  } catch (e) {
+    res.status(500).json({ error: e?.message ? String(e.message) : 'Failed to list models' });
+  }
+};
+
+exports.getModelSchema = async (req, res) => {
+  try {
+    const modelName = String(req.params.modelName || '').trim();
+    if (!modelName) return res.status(400).json({ error: 'modelName is required' });
+    const model = getModelByName(modelName);
+    if (!model) return res.status(404).json({ error: `Unknown model '${modelName}'` });
+    res.json({ schema: describeSchema(model) });
+  } catch (e) {
+    res.status(500).json({ error: e?.message ? String(e.message) : 'Failed to load schema' });
+  }
+};
+
+exports.preview = async (req, res) => {
+  try {
+    const { modelName, query, page, limit, sort, search } = req.body || {};
+    const safeModelName = String(modelName || '').trim();
+    if (!safeModelName) return res.status(400).json({ error: 'modelName is required' });
+
+    const model = getModelByName(safeModelName);
+    if (!model) {
+      const registry = getModelRegistry();
+      return res.status(400).json({
+        error: `Unknown model '${safeModelName}'`,
+        availableModels: registry ? Object.keys(registry).sort() : [],
+      });
+    }
+
+    const safePage = Math.max(1, parseInt(page, 10) || 1);
+    const safeLimit = Math.min(100, Math.max(1, parseInt(limit, 10) || 20));
+    const skip = (safePage - 1) * safeLimit;
+
+    const filter = query && typeof query === 'object' ? query : {};
+    const trimmedSearch = String(search || '').trim();
+
+    if (trimmedSearch) {
+      const schemaInfo = describeSchema(model);
+      const stringFields = schemaInfo.fields
+        .filter((f) => f && (String(f.type || '').toLowerCase() === 'string'))
+        .map((f) => f.key)
+        .slice(0, 6);
+      if (stringFields.length) {
+        filter.$or = stringFields.map((k) => ({ [k]: { $regex: trimmedSearch, $options: 'i' } }));
+      }
+    }
+
+    const sortObj = (() => {
+      if (!sort) return { createdAt: -1 };
+      if (typeof sort === 'object') return sort;
+      const parsed = safeJsonParse(String(sort), null);
+      return parsed && typeof parsed === 'object' ? parsed : { createdAt: -1 };
+    })();
+
+    const [items, total] = await Promise.all([
+      model.find(filter).sort(sortObj).skip(skip).limit(safeLimit).lean(),
+      model.countDocuments(filter),
+    ]);
+
+    res.json({
+      ok: true,
+      modelName: safeModelName,
+      page: safePage,
+      limit: safeLimit,
+      total,
+      pages: Math.ceil(total / safeLimit) || 1,
+      items,
+    });
+  } catch (e) {
+    res.status(500).json({ error: e?.message ? String(e.message) : 'Preview failed' });
+  }
+};
+
+exports.upsertEnvironment = async (req, res) => {
+  try {
+    const { envKey, name, connectionString, description, assetsTarget } = req.body || {};
+    const saved = await migrationService.upsertEnvironment(envKey, {
+      name,
+      connectionString,
+      description,
+      assetsTarget,
+    });
+    res.json({ environment: saved });
+  } catch (e) {
+    res.status(e.status || 500).json({ error: e?.message ? String(e.message) : 'Failed to save environment' });
+  }
+};
+
+exports.getEnvironment = async (req, res) => {
+  try {
+    const { envKey } = req.params || {};
+    if (!envKey) return res.status(400).json({ error: 'envKey is required' });
+    const env = await migrationService.getEnvironmentConfig(envKey);
+    if (!env) return res.status(404).json({ error: 'Environment not found' });
+    res.json({ environment: env });
+  } catch (e) {
+    res.status(e.status || 500).json({ error: e?.message ? String(e.message) : 'Failed to load environment' });
+  }
+};
+
+exports.testAssetsTarget = async (req, res) => {
+  try {
+    const { envKey } = req.body || {};
+    if (!envKey) return res.status(400).json({ error: 'envKey is required' });
+    const result = await migrationService.testAssetsTarget({ targetEnvKey: envKey });
+    res.json(result);
+  } catch (e) {
+    res.status(e.status || 400).json({ error: e?.message ? String(e.message) : 'Assets test failed' });
+  }
+};
+
+exports.testAssetsCopyKey = async (req, res) => {
+  try {
+    const { envKey, key, dryRun } = req.body || {};
+    if (!envKey) return res.status(400).json({ error: 'envKey is required' });
+    if (!key) return res.status(400).json({ error: 'key is required' });
+    const result = await migrationService.testAssetsCopyKey({
+      targetEnvKey: envKey,
+      key,
+      dryRun: !!dryRun,
+    });
+    res.json(result);
+  } catch (e) {
+    res.status(e.status || 400).json({ error: e?.message ? String(e.message) : 'Assets copy test failed' });
+  }
+};
+
+exports.deleteEnvironment = async (req, res) => {
+  try {
+    const { envKey } = req.params;
+    const result = await migrationService.deleteEnvironment(envKey);
+    res.json(result);
+  } catch (e) {
+    res.status(e.status || 500).json({ error: e?.message ? String(e.message) : 'Failed to delete environment' });
+  }
+};
+
+exports.testConnection = async (req, res) => {
+  try {
+    const { envKey } = req.body || {};
+    if (!envKey) return res.status(400).json({ error: 'envKey is required' });
+    const result = await migrationService.testConnection(envKey);
+    res.json(result);
+  } catch (e) {
+    res.status(400).json({ error: e?.message ? String(e.message) : 'Connection test failed' });
+  }
+};
+
+exports.runMigration = async (req, res) => {
+  try {
+    const { envKey, modelName, query, dryRun } = req.body || {};
+    if (!envKey) return res.status(400).json({ error: 'envKey is required' });
+    if (!modelName) return res.status(400).json({ error: 'modelName is required' });
+
+    const registry = getModelRegistry();
+    if (!registry) {
+      return res.status(500).json({ error: 'saasbackend models registry is not available' });
+    }
+
+    const sourceModel = registry[modelName] || null;
+
+    if (!sourceModel) {
+      return res.status(400).json({
+        error: `Unknown model '${modelName}'`,
+        availableModels: Object.keys(registry).sort(),
+      });
+    }
+
+    const result = await migrationService.migrateModel({
+      sourceModel,
+      targetEnvKey: envKey,
+      modelName,
+      query,
+      dryRun: !!dryRun,
+    });
+
+    res.json(result);
+  } catch (e) {
+    res.status(e.status || 500).json({ error: e?.message ? String(e.message) : 'Migration failed' });
+  }
+};