@intranefr/superbackend 1.5.0 → 1.5.2

package/src/controllers/blogPublic.controller.js

@@ -0,0 +1,89 @@
+const BlogPost = require('../models/BlogPost');
+const { parsePagination } = require('../services/blog.service');
+
+exports.listPublished = async (req, res) => {
+  try {
+    const { page, limit, skip } = parsePagination({
+      page: req.query.page,
+      limit: req.query.limit,
+      maxLimit: 100,
+      defaultLimit: 20,
+    });
+
+    const filter = { status: 'published' };
+
+    const tag = String(req.query.tag || '').trim();
+    if (tag) {
+      filter.tags = tag;
+    }
+
+    const category = String(req.query.category || '').trim();
+    if (category) {
+      filter.category = category;
+    }
+
+    const q = String(req.query.q || '').trim();
+    if (q) {
+      const re = new RegExp(q.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
+      filter.$or = [{ title: re }, { excerpt: re }];
+    }
+
+    const [items, total] = await Promise.all([
+      BlogPost.find(filter)
+        .sort({ publishedAt: -1, createdAt: -1 })
+        .select('title slug excerpt coverImageUrl category tags authorName publishedAt createdAt updatedAt')
+        .skip(skip)
+        .limit(limit)
+        .lean(),
+      BlogPost.countDocuments(filter),
+    ]);
+
+    res.json({
+      items,
+      pagination: {
+        page,
+        limit,
+        total,
+        pages: Math.ceil(total / limit),
+      },
+    });
+  } catch (error) {
+    console.error('Error listing blog posts:', error);
+    res.status(500).json({ error: 'Failed to list blog posts' });
+  }
+};
+
+exports.getPublishedBySlug = async (req, res) => {
+  try {
+    const slug = String(req.params.slug || '').trim();
+    if (!slug) return res.status(400).json({ error: 'slug is required' });
+
+    const post = await BlogPost.findOne({ slug, status: 'published' }).lean();
+    if (!post) return res.status(404).json({ error: 'Not found' });
+
+    res.json({
+      post: {
+        _id: post._id,
+        title: post.title,
+        slug: post.slug,
+        status: post.status,
+        excerpt: post.excerpt,
+        markdown: post.markdown,
+        html: post.html,
+        coverImageUrl: post.coverImageUrl,
+        category: post.category,
+        tags: post.tags,
+        authorName: post.authorName,
+        seoTitle: post.seoTitle,
+        seoDescription: post.seoDescription,
+        scheduledAt: post.scheduledAt,
+        publishedAt: post.publishedAt,
+        createdAt: post.createdAt,
+        updatedAt: post.updatedAt,
+      },
+    });
+  } catch (error) {
+    console.error('Error getting blog post:', error);
+    res.status(500).json({ error: 'Failed to get blog post' });
+  }
+};

package/src/controllers/experiments.controller.js

@@ -0,0 +1,85 @@
+const experimentsService = require('../services/experiments.service');
+
+function toSafeJsonError(error) {
+  const msg = error?.message || 'Operation failed';
+  const code = error?.code;
+  if (code === 'VALIDATION') return { status: 400, body: { error: msg } };
+  if (code === 'NOT_FOUND') return { status: 404, body: { error: msg } };
+  if (code === 'CONFLICT') return { status: 409, body: { error: msg } };
+  return { status: 500, body: { error: msg } };
+}
+
+exports.getAssignment = async (req, res) => {
+  try {
+    const orgId = req.headers['x-org-id'] || req.query.orgId || req.body?.orgId;
+    const subjectId = req.query.subjectId || req.body?.subjectId;
+
+    const context = req.body?.context && typeof req.body.context === 'object' ? req.body.context : {};
+
+    const { experiment, assignment } = await experimentsService.getOrCreateAssignment({
+      orgId,
+      experimentCode: req.params.code,
+      subjectId,
+      context,
+    });
+
+    const variant = (experiment.variants || []).find((v) => String(v?.key || '') === String(assignment.variantKey));
+    const config = await experimentsService.resolveVariantConfig(variant);
+
+    const { snapshot } = await experimentsService.getWinnerSnapshot({ orgId, experimentCode: req.params.code });
+
+    return res.json({
+      experimentCode: experiment.code,
+      variantKey: assignment.variantKey,
+      assignedAt: assignment.assignedAt,
+      config,
+      winner: {
+        winnerVariantKey: snapshot.winnerVariantKey,
+        decidedAt: snapshot.winnerDecidedAt,
+        reason: snapshot.winnerReason,
+        status: snapshot.status,
+      },
+    });
+  } catch (err) {
+    const safe = toSafeJsonError(err);
+    return res.status(safe.status).json(safe.body);
+  }
+};
+
+exports.postEvents = async (req, res) => {
+  try {
+    const orgId = req.headers['x-org-id'] || req.query.orgId || req.body?.orgId;
+    const subjectId = req.query.subjectId || req.body?.subjectId;
+
+    const payload = req.body || {};
+    const events = Array.isArray(payload.events) ? payload.events : [payload];
+
+    const result = await experimentsService.ingestEvents({
+      orgId,
+      experimentCode: req.params.code,
+      subjectId,
+      events,
+    });
+
+    return res.status(201).json(result);
+  } catch (err) {
+    const safe = toSafeJsonError(err);
+    return res.status(safe.status).json(safe.body);
+  }
+};
+
+exports.getWinner = async (req, res) => {
+  try {
+    const orgId = req.headers['x-org-id'] || req.query.orgId || req.body?.orgId;
+    const { snapshot } = await experimentsService.getWinnerSnapshot({ orgId, experimentCode: req.params.code });
+    return res.json({
+      status: snapshot.status,
+      winnerVariantKey: snapshot.winnerVariantKey,
+      decidedAt: snapshot.winnerDecidedAt,
+      reason: snapshot.winnerReason,
+    });
+  } catch (err) {
+    const safe = toSafeJsonError(err);
+    return res.status(safe.status).json(safe.body);
+  }
+};

package/src/controllers/fileManager.controller.js

@@ -0,0 +1,190 @@
+const fileManagerService = require('../services/fileManager.service');
+
+exports.listDrives = async (req, res) => {
+  try {
+    const orgId = req.query.orgId || req.headers['x-org-id'] || null;
+    const payload = await fileManagerService.listDrives({ userId: req.user._id, orgId });
+    return res.json(payload);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    console.error('Error listing file manager drives:', error);
+    return res.status(500).json({ error: 'Failed to list drives' });
+  }
+};
+
+exports.listFolder = async (req, res) => {
+  try {
+    const orgId = req.query.orgId || req.body?.orgId || req.headers['x-org-id'] || null;
+    const driveType = req.query.driveType || req.body?.driveType;
+    const driveId = req.query.driveId || req.body?.driveId;
+    const folderPath = req.query.folderPath || req.query.path || req.body?.folderPath || '/';
+    const payload = await fileManagerService.listFolder({
+      orgId,
+      driveType,
+      driveId,
+      parentPath: folderPath || '/',
+    });
+    return res.json(payload);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    console.error('Error listing file manager folder:', error);
+    return res.status(500).json({ error: 'Failed to list folder' });
+  }
+};
+
+exports.upload = async (req, res) => {
+  try {
+    if (!req.file && !req.files?.file) {
+      return res.status(400).json({ error: 'No file provided' });
+    }
+
+    const file = req.file || req.files.file;
+    const buffer = file.buffer || (file.data ? file.data : null);
+
+    if (!buffer) {
+      return res.status(400).json({ error: 'Unable to read file buffer' });
+    }
+
+    const contentType = file.mimetype;
+    const name = req.body?.name || file.originalname || file.name;
+
+    const overwriteRaw = req.body?.overwrite ?? req.query?.overwrite;
+    const overwrite = overwriteRaw === 'true' || overwriteRaw === true || overwriteRaw === '1';
+
+    const orgId = req.body?.orgId ?? req.query?.orgId;
+    const driveType = req.body?.driveType ?? req.query?.driveType;
+    const driveId = req.body?.driveId ?? req.query?.driveId;
+    const folderPath = req.body?.folderPath ?? req.query?.folderPath;
+
+    const payload = await fileManagerService.uploadFile({
+      userId: req.user._id,
+      orgId,
+      driveType,
+      driveId,
+      parentPath: folderPath || '/',
+      name,
+      buffer,
+      contentType,
+      overwrite,
+      requestedVisibility: req.body?.visibility,
+    });
+
+    return res.status(201).json(payload);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    if (code === 'CONFLICT') return res.status(409).json({ error: error.message, ...error.details });
+    if (code === 'UPLOAD_REJECTED') return res.status(400).json({ error: error.message, ...error.details });
+
+    console.error('Error uploading file manager file:', error);
+    return res.status(500).json({ error: 'Failed to upload file' });
+  }
+};
+
+exports.download = async (req, res) => {
+  try {
+    const orgId = req.query.orgId || req.headers['x-org-id'] || null;
+    const driveType = req.query.driveType;
+    const driveId = req.query.driveId;
+
+    const result = await fileManagerService.downloadFile({
+      orgId,
+      driveType,
+      driveId,
+      fileId: req.params.id,
+    });
+
+    res.set('Content-Type', result.contentType);
+    if (result.asset?.originalName) {
+      res.set('Content-Disposition', `inline; filename="${result.asset.originalName}"`);
+    }
+    res.send(result.body);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    if (code === 'NOT_FOUND') return res.status(404).json({ error: 'Not found' });
+
+    console.error('Error downloading file manager file:', error);
+    return res.status(500).json({ error: 'Failed to download file' });
+  }
+};
+
+exports.delete = async (req, res) => {
+  try {
+    const orgId = req.query.orgId || req.body?.orgId || req.headers['x-org-id'] || null;
+    const driveType = req.query.driveType || req.body?.driveType;
+    const driveId = req.query.driveId || req.body?.driveId;
+
+    const payload = await fileManagerService.deleteFile({
+      orgId,
+      driveType,
+      driveId,
+      fileId: req.params.id,
+    });
+
+    return res.json(payload);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    if (code === 'NOT_FOUND') return res.status(404).json({ error: 'Not found' });
+
+    console.error('Error deleting file manager file:', error);
+    return res.status(500).json({ error: 'Failed to delete file' });
+  }
+};
+
+exports.update = async (req, res) => {
+  try {
+    const orgId = req.body?.orgId || req.query.orgId || req.headers['x-org-id'] || null;
+    const driveType = req.body?.driveType || req.query.driveType;
+    const driveId = req.body?.driveId || req.query.driveId;
+
+    const payload = await fileManagerService.updateFile({
+      orgId,
+      driveType,
+      driveId,
+      fileId: req.params.id,
+      name: req.body?.name,
+      parentPath: req.body?.folderPath,
+    });
+
+    return res.json(payload);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    if (code === 'CONFLICT') return res.status(409).json({ error: error.message, ...error.details });
+    if (code === 'NOT_FOUND') return res.status(404).json({ error: 'Not found' });
+
+    console.error('Error updating file manager file:', error);
+    return res.status(500).json({ error: 'Failed to update file' });
+  }
+};
+
+exports.setShare = async (req, res) => {
+  try {
+    const orgId = req.body?.orgId || req.query.orgId || req.headers['x-org-id'] || null;
+    const driveType = req.body?.driveType || req.query.driveType;
+    const driveId = req.body?.driveId || req.query.driveId;
+    const enabled = req.body?.enabled === true || req.body?.enabled === 'true' || req.body?.enabled === '1';
+
+    const payload = await fileManagerService.setShare({
+      orgId,
+      driveType,
+      driveId,
+      fileId: req.params.id,
+      enabled,
+    });
+
+    return res.json(payload);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    if (code === 'NOT_FOUND') return res.status(404).json({ error: 'Not found' });
+    if (code === 'VISIBILITY_ENFORCED') return res.status(400).json({ error: error.message });
+
+    console.error('Error toggling file manager share:', error);
+    return res.status(500).json({ error: 'Failed to update share status' });
+  }
+};

package/src/controllers/fileManagerStoragePolicy.controller.js

@@ -0,0 +1,23 @@
+const fileManagerStoragePolicyService = require('../services/fileManagerStoragePolicy.service');
+
+exports.getStoragePolicy = async (req, res) => {
+  try {
+    const orgId = req.query.orgId || req.headers['x-org-id'] || null;
+    const driveType = req.query.driveType;
+    const driveId = req.query.driveId;
+
+    const payload = await fileManagerStoragePolicyService.getEffectivePolicy({
+      userId: req.user._id,
+      orgId,
+      driveType,
+      driveId,
+    });
+
+    return res.json(payload);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    console.error('Error getting file manager storage policy:', error);
+    return res.status(500).json({ error: 'Failed to get storage policy' });
+  }
+};

package/src/controllers/healthChecksPublic.controller.js

@@ -0,0 +1,196 @@
+const HealthCheck = require('../models/HealthCheck');
+const HealthIncident = require('../models/HealthIncident');
+const globalSettingsService = require('../services/globalSettings.service');
+
+const PUBLIC_STATUS_SETTING_KEY = 'healthChecks.publicStatusEnabled';
+
+function escapeHtml(unsafe) {
+  return String(unsafe || '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function renderHtml(payload) {
+  const status = payload.status || 'unknown';
+  const badgeClass = status === 'ok' ? 'badge-success' : status === 'degraded' ? 'badge-warning' : 'badge-error';
+
+  const checks = Array.isArray(payload.checks) ? payload.checks : [];
+
+  const bodyRows = checks.length > 0
+    ? checks
+        .map((c) => {
+          const cStatus = String(c.status || 'unknown');
+          const cBadgeClass = cStatus === 'healthy' ? 'badge-success' : cStatus === 'unhealthy' ? 'badge-error' : 'badge-ghost';
+
+          const incident = c.incident;
+          const incidentLabel = incident ? `${incident.status} (${incident.severity})` : '-';
+
+          return `
+        <tr>
+          <td class="font-medium">${escapeHtml(c.name)}</td>
+          <td><span class="badge ${cBadgeClass}">${escapeHtml(cStatus)}</span></td>
+          <td class="text-slate-500">${c.lastRunAt ? new Date(c.lastRunAt).toLocaleString() : '-'}</td>
+          <td class="text-slate-500">${c.lastLatencyMs != null ? escapeHtml(String(c.lastLatencyMs)) + ' ms' : '-'}</td>
+
+          <td class="text-xs">${escapeHtml(incidentLabel)}</td>
+        </tr>`;
+        })
+        .join('')
+    : '<tr><td colspan="5" class="text-slate-500 text-center">No checks found</td></tr>';
+
+  return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Health Checks Status</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <link href="https://cdn.jsdelivr.net/npm/daisyui@4.12.10/dist/full.min.css" rel="stylesheet" type="text/css" />
+  </head>
+  <body class="bg-slate-50">
+    <div class="max-w-5xl mx-auto px-6 py-8">
+      <div class="flex items-start justify-between gap-4">
+        <div>
+          <h1 class="text-2xl font-semibold text-slate-900">Health Checks</h1>
+          <div class="text-sm text-slate-500">Public status summary</div>
+        </div>
+        <div class="text-right">
+          <div class="text-sm text-slate-500">Overall</div>
+          <div class="badge ${badgeClass} badge-lg">${escapeHtml(status)}</div>
+          <div class="text-xs text-slate-500 mt-1">Updated: ${escapeHtml(payload.updatedAt || '')}</div>
+        </div>
+      </div>
+
+      <div class="mt-6 grid grid-cols-2 gap-3">
+        <div class="card bg-white border border-slate-200">
+          <div class="card-body py-4">
+            <div class="text-sm text-slate-500">Total checks</div>
+            <div class="text-xl font-semibold">${payload.totalChecks || 0}</div>
+          </div>
+        </div>
+        <div class="card bg-white border border-slate-200">
+          <div class="card-body py-4">
+            <div class="text-sm text-slate-500">Unhealthy</div>
+            <div class="text-xl font-semibold">${payload.unhealthyCount || 0}</div>
+          </div>
+        </div>
+      </div>
+
+      <div class="mt-6 card bg-white border border-slate-200">
+        <div class="card-body p-0">
+          <div class="overflow-x-auto">
+            <table class="table table-zebra w-full">
+              <thead>
+                <tr>
+                  <th>Name</th>
+                  <th>Status</th>
+                  <th>Last run</th>
+                  <th>Latency</th>
+                  <th>Incident</th>
+                </tr>
+              </thead>
+              <tbody>
+                ${bodyRows}
+              </tbody>
+            </table>
+          </div>
+        </div>
+      </div>
+
+      <div class="mt-4 text-xs text-slate-500">
+        Tip: add <code class="px-1 py-0.5 bg-slate-100 rounded">/json</code> to the URL for JSON format.
+      </div>
+    </div>
+  </body>
+</html>`;
+}
+
+async function computeStatusPayload() {
+  const checks = await HealthCheck.find({ enabled: true }).sort({ name: 1 }).lean();
+  const checkIds = checks.map((c) => String(c._id));
+
+  const incidents = await HealthIncident.find({
+    healthCheckId: { $in: checkIds },
+    status: { $in: ['open', 'acknowledged'] },
+  }).lean();
+
+
+  const incidentMap = {};
+  for (const incident of incidents) {
+    if (!incidentMap[incident.healthCheckId]) {
+      incidentMap[incident.healthCheckId] = incident;
+    }
+  }
+
+  const summaries = checks.map((check) => {
+    const incident = incidentMap[String(check._id)];
+    return {
+      id: String(check._id),
+      name: check.name,
+      status: incident ? incident.status : (check.lastStatus || 'unknown'),
+      lastRunAt: check.lastRunAt || null,
+      lastLatencyMs: check.lastLatencyMs || null,
+      incident: incident
+        ? {
+            id: String(incident._id),
+            status: incident.status,
+            severity: incident.severity,
+            openedAt: incident.openedAt,
+            lastSeenAt: incident.lastSeenAt,
+          }
+        : null,
+    };
+  });
+
+  const unhealthyCount = summaries.filter((s) => s.status === 'unhealthy' || s.incident).length;
+  const overallStatus = unhealthyCount > 0 ? 'degraded' : 'ok';
+
+  return {
+    ok: overallStatus === 'ok',
+    status: overallStatus,
+    updatedAt: new Date().toISOString(),
+    totalChecks: summaries.length,
+    unhealthyCount,
+    checks: summaries,
+  };
+}
+
+exports.getStatus = async (req, res) => {
+  try {
+    const raw = await globalSettingsService.getSettingValue(PUBLIC_STATUS_SETTING_KEY, 'false');
+    const enabled = String(raw) === 'true';
+
+    if (!enabled) {
+      return res.status(404).json({ error: 'Not found' });
+    }
+
+    const payload = await computeStatusPayload();
+    const html = renderHtml(payload);
+
+    res.setHeader('Content-Type', 'text/html; charset=utf-8');
+    return res.status(200).send(html);
+  } catch (error) {
+    console.error('Failed to compute health checks status:', error);
+    return res.status(500).json({ error: 'Failed to compute status' });
+  }
+};
+
+exports.getStatusJson = async (req, res) => {
+  try {
+    const raw = await globalSettingsService.getSettingValue(PUBLIC_STATUS_SETTING_KEY, 'false');
+    const enabled = String(raw) === 'true';
+
+    if (!enabled) {
+      return res.status(404).json({ error: 'Not found' });
+    }
+
+    const payload = await computeStatusPayload();
+    return res.json(payload);
+  } catch (error) {
+    console.error('Failed to compute health checks status json:', error);
+    return res.status(500).json({ error: 'Failed to compute status' });
+  }
+};

package/src/controllers/internalExperiments.controller.js

@@ -0,0 +1,17 @@
+const experimentsAggregation = require('../services/experimentsAggregation.service');
+const experimentsRetention = require('../services/experimentsRetention.service');
+
+exports.runAggregation = async (req, res) => {
+  const body = req.body || {};
+  const bucketMs = body.bucketMs;
+  const start = body.start;
+  const end = body.end;
+
+  const data = await experimentsAggregation.runAggregationAndWinner({ bucketMs, start, end });
+  return res.json(data);
+};
+
+exports.runRetention = async (_req, res) => {
+  const data = await experimentsRetention.runRetentionCleanup();
+  return res.json(data);
+};