@intranefr/superbackend 1.5.0 → 1.5.2

package/src/controllers/adminPagesContextBlocksAi.controller.js

@@ -0,0 +1,54 @@
+const {
+  generateContextBlock,
+  proposeContextBlockEdit,
+} = require('../services/pagesContextBlocksAi.service');
+
+const { getBasicAuthActor } = require('../services/audit.service');
+
+function handleError(res, err) {
+  const code = err && err.code;
+  if (code === 'VALIDATION') return res.status(400).json({ error: err.message });
+  if (code === 'NOT_FOUND') return res.status(404).json({ error: err.message });
+  if (code === 'AI_INVALID') return res.status(500).json({ error: err.message });
+  return res.status(500).json({ error: err.message || 'Operation failed' });
+}
+
+exports.generate = async (req, res) => {
+  try {
+    const actor = getBasicAuthActor(req);
+    const { prompt, blockType, providerKey, model } = req.body || {};
+
+    const result = await generateContextBlock({
+      prompt,
+      blockType,
+      providerKey,
+      model,
+      actor,
+    });
+
+    return res.json(result);
+  } catch (err) {
+    console.error('[adminPagesContextBlocksAi] generate error', err);
+    return handleError(res, err);
+  }
+};
+
+exports.propose = async (req, res) => {
+  try {
+    const actor = getBasicAuthActor(req);
+    const { prompt, currentBlock, providerKey, model } = req.body || {};
+
+    const result = await proposeContextBlockEdit({
+      prompt,
+      currentBlock,
+      providerKey,
+      model,
+      actor,
+    });
+
+    return res.json(result);
+  } catch (err) {
+    console.error('[adminPagesContextBlocksAi] propose error', err);
+    return handleError(res, err);
+  }
+};

package/src/controllers/adminProxy.controller.js

@@ -0,0 +1,113 @@
+const ProxyEntry = require('../models/ProxyEntry');
+const { listDiscoveries } = require('../services/proxy.service');
+
+function handleServiceError(res, error) {
+  const msg = error?.message || 'Operation failed';
+  const code = error?.code;
+
+  if (code === 'VALIDATION') return res.status(400).json({ error: msg });
+  if (code === 'NOT_FOUND') return res.status(404).json({ error: msg });
+  if (code === 'CONFLICT') return res.status(409).json({ error: msg });
+
+  return res.status(500).json({ error: msg });
+}
+
+exports.list = async (req, res) => {
+  try {
+    const [entries, discoveries] = await Promise.all([
+      ProxyEntry.find({}).sort({ updatedAt: -1 }).lean(),
+      listDiscoveries(),
+    ]);
+
+    return res.json({ items: entries || [], discoveries: discoveries || [] });
+  } catch (error) {
+    console.error('Error listing proxy entries:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.get = async (req, res) => {
+  try {
+    const id = String(req.params.id || '').trim();
+    const item = await ProxyEntry.findById(id).lean();
+    if (!item) return res.status(404).json({ error: 'Not found' });
+    return res.json({ item });
+  } catch (error) {
+    console.error('Error getting proxy entry:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.create = async (req, res) => {
+  try {
+    const body = req.body && typeof req.body === 'object' ? req.body : {};
+
+    const matchValue = String(body.match?.value || '').trim();
+    if (!matchValue) return res.status(400).json({ error: 'match.value is required' });
+
+    const doc = await ProxyEntry.create({
+      name: String(body.name || ''),
+      enabled: Boolean(body.enabled),
+      match: {
+        type: String(body.match?.type || 'contains'),
+        value: matchValue,
+        applyTo: String(body.match?.applyTo || 'host'),
+        flags: String(body.match?.flags || 'i'),
+      },
+      policy: body.policy || undefined,
+      rateLimit: body.rateLimit || undefined,
+      cache: body.cache || undefined,
+      headers: body.headers || undefined,
+      transform: body.transform || undefined,
+    });
+
+    return res.status(201).json({ item: doc.toObject() });
+  } catch (error) {
+    console.error('Error creating proxy entry:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.update = async (req, res) => {
+  try {
+    const id = String(req.params.id || '').trim();
+    const updates = req.body && typeof req.body === 'object' ? req.body : {};
+
+    const doc = await ProxyEntry.findById(id);
+    if (!doc) return res.status(404).json({ error: 'Not found' });
+
+    if (updates.name !== undefined) doc.name = String(updates.name || '');
+    if (updates.enabled !== undefined) doc.enabled = Boolean(updates.enabled);
+
+    if (updates.match && typeof updates.match === 'object') {
+      if (updates.match.type !== undefined) doc.match.type = String(updates.match.type || 'contains');
+      if (updates.match.value !== undefined) doc.match.value = String(updates.match.value || '').trim();
+      if (updates.match.applyTo !== undefined) doc.match.applyTo = String(updates.match.applyTo || 'host');
+      if (updates.match.flags !== undefined) doc.match.flags = String(updates.match.flags || 'i');
+    }
+
+    if (updates.policy !== undefined) doc.policy = updates.policy;
+    if (updates.rateLimit !== undefined) doc.rateLimit = updates.rateLimit;
+    if (updates.cache !== undefined) doc.cache = updates.cache;
+    if (updates.headers !== undefined) doc.headers = updates.headers;
+    if (updates.transform !== undefined) doc.transform = updates.transform;
+
+    await doc.save();
+    return res.json({ item: doc.toObject() });
+  } catch (error) {
+    console.error('Error updating proxy entry:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.delete = async (req, res) => {
+  try {
+    const id = String(req.params.id || '').trim();
+    const doc = await ProxyEntry.findByIdAndDelete(id).lean();
+    if (!doc) return res.status(404).json({ error: 'Not found' });
+    return res.json({ ok: true });
+  } catch (error) {
+    console.error('Error deleting proxy entry:', error);
+    return handleServiceError(res, error);
+  }
+};

package/src/controllers/adminRateLimits.controller.js

@@ -0,0 +1,138 @@
+const rateLimiter = require('../services/rateLimiter.service');
+
+function handleServiceError(res, error) {
+  const msg = error?.message || 'Operation failed';
+  const code = error?.code;
+
+  if (code === 'VALIDATION' || code === 'INVALID_JSON') {
+    return res.status(400).json({ error: msg });
+  }
+  if (code === 'NOT_FOUND') {
+    return res.status(404).json({ error: msg });
+  }
+
+  return res.status(500).json({ error: msg });
+}
+
+exports.list = async (req, res) => {
+  try {
+    const items = await rateLimiter.list();
+    return res.json({ items });
+  } catch (error) {
+    console.error('Error listing rate limits:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.getConfig = async (req, res) => {
+  try {
+    const { doc } = await rateLimiter.getRateLimitsConfigData();
+    return res.json({
+      config: {
+        id: String(doc._id),
+        slug: doc.slug,
+        alias: doc.alias,
+        title: doc.title,
+        cacheTtlSeconds: Number(doc.cacheTtlSeconds || 0) || 0,
+        jsonRaw: String(doc.jsonRaw || ''),
+        updatedAt: doc.updatedAt,
+      },
+    });
+  } catch (error) {
+    console.error('Error getting rate limits config:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.updateConfig = async (req, res) => {
+  try {
+    const jsonRaw = req.body?.jsonRaw;
+    if (jsonRaw === undefined || jsonRaw === null) {
+      return res.status(400).json({ error: 'jsonRaw is required' });
+    }
+
+    const doc = await rateLimiter.updateRawConfig({ jsonRaw });
+    return res.json({
+      config: {
+        id: String(doc._id),
+        slug: doc.slug,
+        alias: doc.alias,
+        title: doc.title,
+        cacheTtlSeconds: Number(doc.cacheTtlSeconds || 0) || 0,
+        jsonRaw: String(doc.jsonRaw || ''),
+        updatedAt: doc.updatedAt,
+      },
+    });
+  } catch (error) {
+    console.error('Error updating rate limits config:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.updateLimiter = async (req, res) => {
+  try {
+    const limiterId = String(req.params.id || '').trim();
+    if (!limiterId) return res.status(400).json({ error: 'id is required' });
+
+    let override = req.body?.override;
+    if (override === undefined) override = req.body;
+
+    if (!override || typeof override !== 'object' || Array.isArray(override)) {
+      return res.status(400).json({ error: 'override must be an object' });
+    }
+
+    const config = await rateLimiter.setLimiterOverride(limiterId, override);
+    return res.json({ config });
+  } catch (error) {
+    console.error('Error updating rate limit override:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.resetLimiter = async (req, res) => {
+  try {
+    const limiterId = String(req.params.id || '').trim();
+    if (!limiterId) return res.status(400).json({ error: 'id is required' });
+
+    const config = await rateLimiter.resetLimiterOverride(limiterId);
+    return res.json({ config });
+  } catch (error) {
+    console.error('Error resetting rate limit override:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.getMetrics = async (req, res) => {
+  try {
+    const start = req.query?.start;
+    const end = req.query?.end;
+
+    const data = await rateLimiter.queryMetrics({ start, end });
+    return res.json(data);
+  } catch (error) {
+    console.error('Error fetching rate limits metrics:', error);
+    return handleServiceError(res, error);
+  }
+};
+
+exports.bulkEnabled = async (req, res) => {
+  try {
+    const enabled = req.body?.enabled;
+    const all = Boolean(req.body?.all);
+    const ids = req.body?.ids;
+
+    if (enabled !== true && enabled !== false) {
+      return res.status(400).json({ error: 'enabled must be true or false' });
+    }
+
+    if (!all && !Array.isArray(ids)) {
+      return res.status(400).json({ error: 'Provide ids[] or set all=true' });
+    }
+
+    const config = await rateLimiter.bulkSetEnabled({ enabled, all, ids });
+    return res.json({ config });
+  } catch (error) {
+    console.error('Error bulk updating rate limits enabled state:', error);
+    return handleServiceError(res, error);
+  }
+};