@intranefr/superbackend 1.4.4 → 1.5.1

package/src/controllers/adminUiComponents.controller.js

@@ -0,0 +1,315 @@
+const UiComponent = require('../models/UiComponent');
+const UiComponentProject = require('../models/UiComponentProject');
+const UiComponentProjectComponent = require('../models/UiComponentProjectComponent');
+
+const {
+  generateProjectApiKeyPlaintext,
+  hashKey,
+} = require('../services/uiComponentsCrypto.service');
+
+function randomLowerAlphaNum(len) {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+  let out = '';
+  for (let i = 0; i < len; i += 1) out += chars[Math.floor(Math.random() * chars.length)];
+  return out;
+}
+
+function generateProjectId() {
+  return `prj_${randomLowerAlphaNum(16)}`;
+}
+
+function parseBool(value, fallback) {
+  if (value === undefined) return fallback;
+  if (typeof value === 'boolean') return value;
+  const v = String(value).trim().toLowerCase();
+  if (v === 'true' || v === '1' || v === 'yes') return true;
+  if (v === 'false' || v === '0' || v === 'no') return false;
+  return fallback;
+}
+
+exports.listProjects = async (req, res) => {
+  try {
+    const items = await UiComponentProject.find({}).sort({ createdAt: -1 }).lean();
+    return res.json({ items });
+  } catch (error) {
+    console.error('UI Components listProjects error:', error);
+    return res.status(500).json({ error: 'Failed to list projects' });
+  }
+};
+
+exports.createProject = async (req, res) => {
+  try {
+    const name = String(req.body?.name || '').trim();
+    const projectIdIn = req.body?.projectId !== undefined ? String(req.body.projectId).trim() : '';
+    const isPublic = parseBool(req.body?.isPublic, true);
+
+    if (!name) return res.status(400).json({ error: 'name is required' });
+
+    const projectId = projectIdIn || generateProjectId();
+
+    const doc = await UiComponentProject.create({
+      projectId,
+      name,
+      isPublic,
+      apiKeyHash: null,
+      allowedOrigins: Array.isArray(req.body?.allowedOrigins) ? req.body.allowedOrigins : [],
+      isActive: true,
+    });
+
+    let apiKey = null;
+    if (!isPublic) {
+      apiKey = generateProjectApiKeyPlaintext();
+      doc.apiKeyHash = hashKey(apiKey);
+      await doc.save();
+    }
+
+    return res.status(201).json({ item: doc.toObject(), apiKey });
+  } catch (error) {
+    console.error('UI Components createProject error:', error);
+    if (error?.name === 'ValidationError') return res.status(400).json({ error: error.message });
+    if (error?.code === 11000) return res.status(409).json({ error: 'Project already exists' });
+    return res.status(500).json({ error: 'Failed to create project' });
+  }
+};
+
+exports.getProject = async (req, res) => {
+  try {
+    const { projectId } = req.params;
+    const item = await UiComponentProject.findOne({ projectId: String(projectId) }).lean();
+    if (!item) return res.status(404).json({ error: 'Project not found' });
+
+    const assigned = await UiComponentProjectComponent.find({ projectId: item.projectId }).lean();
+    return res.json({ item, assigned });
+  } catch (error) {
+    console.error('UI Components getProject error:', error);
+    return res.status(500).json({ error: 'Failed to load project' });
+  }
+};
+
+exports.updateProject = async (req, res) => {
+  try {
+    const { projectId } = req.params;
+    const doc = await UiComponentProject.findOne({ projectId: String(projectId) });
+    if (!doc) return res.status(404).json({ error: 'Project not found' });
+
+    if (req.body?.name !== undefined) {
+      const name = String(req.body.name || '').trim();
+      if (!name) return res.status(400).json({ error: 'name is required' });
+      doc.name = name;
+    }
+
+    if (req.body?.isPublic !== undefined) {
+      const nextPublic = parseBool(req.body.isPublic, doc.isPublic);
+      if (nextPublic !== doc.isPublic) {
+        doc.isPublic = nextPublic;
+        if (doc.isPublic) {
+          doc.apiKeyHash = null;
+        } else if (!doc.apiKeyHash) {
+          const apiKey = generateProjectApiKeyPlaintext();
+          doc.apiKeyHash = hashKey(apiKey);
+          await doc.save();
+          return res.json({ item: doc.toObject(), apiKey });
+        }
+      }
+    }
+
+    if (req.body?.allowedOrigins !== undefined) {
+      doc.allowedOrigins = Array.isArray(req.body.allowedOrigins) ? req.body.allowedOrigins : [];
+    }
+
+    if (req.body?.isActive !== undefined) {
+      doc.isActive = Boolean(req.body.isActive);
+    }
+
+    await doc.save();
+    return res.json({ item: doc.toObject(), apiKey: null });
+  } catch (error) {
+    console.error('UI Components updateProject error:', error);
+    if (error?.name === 'ValidationError') return res.status(400).json({ error: error.message });
+    return res.status(500).json({ error: 'Failed to update project' });
+  }
+};
+
+exports.rotateProjectKey = async (req, res) => {
+  try {
+    const { projectId } = req.params;
+    const doc = await UiComponentProject.findOne({ projectId: String(projectId) });
+    if (!doc) return res.status(404).json({ error: 'Project not found' });
+    if (doc.isPublic) return res.status(400).json({ error: 'Project is public' });
+
+    const apiKey = generateProjectApiKeyPlaintext();
+    doc.apiKeyHash = hashKey(apiKey);
+    await doc.save();
+
+    return res.json({ item: doc.toObject(), apiKey });
+  } catch (error) {
+    console.error('UI Components rotateProjectKey error:', error);
+    return res.status(500).json({ error: 'Failed to rotate key' });
+  }
+};
+
+exports.deleteProject = async (req, res) => {
+  try {
+    const { projectId } = req.params;
+    const doc = await UiComponentProject.findOne({ projectId: String(projectId) });
+    if (!doc) return res.status(404).json({ error: 'Project not found' });
+
+    await UiComponentProjectComponent.deleteMany({ projectId: doc.projectId });
+    await UiComponentProject.deleteOne({ _id: doc._id });
+    return res.json({ success: true });
+  } catch (error) {
+    console.error('UI Components deleteProject error:', error);
+    return res.status(500).json({ error: 'Failed to delete project' });
+  }
+};
+
+exports.listComponents = async (req, res) => {
+  try {
+    const items = await UiComponent.find({}).sort({ updatedAt: -1 }).lean();
+    return res.json({ items });
+  } catch (error) {
+    console.error('UI Components listComponents error:', error);
+    return res.status(500).json({ error: 'Failed to list components' });
+  }
+};
+
+exports.createComponent = async (req, res) => {
+  try {
+    const code = String(req.body?.code || '').trim().toLowerCase();
+    const name = String(req.body?.name || '').trim();
+    if (!code) return res.status(400).json({ error: 'code is required' });
+    if (!name) return res.status(400).json({ error: 'name is required' });
+
+    const doc = await UiComponent.create({
+      code,
+      name,
+      html: String(req.body?.html || ''),
+      js: String(req.body?.js || ''),
+      css: String(req.body?.css || ''),
+      api: req.body?.api !== undefined ? req.body.api : null,
+      usageMarkdown: String(req.body?.usageMarkdown || ''),
+      version: Number(req.body?.version || 1) || 1,
+      isActive: parseBool(req.body?.isActive, true),
+    });
+
+    return res.status(201).json({ item: doc.toObject() });
+  } catch (error) {
+    console.error('UI Components createComponent error:', error);
+    if (error?.name === 'ValidationError') return res.status(400).json({ error: error.message });
+    if (error?.code === 11000) return res.status(409).json({ error: 'Component already exists' });
+    return res.status(500).json({ error: 'Failed to create component' });
+  }
+};
+
+exports.getComponent = async (req, res) => {
+  try {
+    const { code } = req.params;
+    const item = await UiComponent.findOne({ code: String(code).toLowerCase() }).lean();
+    if (!item) return res.status(404).json({ error: 'Component not found' });
+    return res.json({ item });
+  } catch (error) {
+    console.error('UI Components getComponent error:', error);
+    return res.status(500).json({ error: 'Failed to load component' });
+  }
+};
+
+exports.updateComponent = async (req, res) => {
+  try {
+    const { code } = req.params;
+    const doc = await UiComponent.findOne({ code: String(code).toLowerCase() });
+    if (!doc) return res.status(404).json({ error: 'Component not found' });
+
+    if (req.body?.name !== undefined) {
+      const name = String(req.body.name || '').trim();
+      if (!name) return res.status(400).json({ error: 'name is required' });
+      doc.name = name;
+    }
+    if (req.body?.html !== undefined) doc.html = String(req.body.html || '');
+    if (req.body?.js !== undefined) doc.js = String(req.body.js || '');
+    if (req.body?.css !== undefined) doc.css = String(req.body.css || '');
+    if (req.body?.api !== undefined) doc.api = req.body.api;
+    if (req.body?.usageMarkdown !== undefined) doc.usageMarkdown = String(req.body.usageMarkdown || '');
+
+    if (req.body?.version !== undefined) {
+      const v = Number(req.body.version);
+      if (!Number.isFinite(v) || v < 1) return res.status(400).json({ error: 'version must be a positive number' });
+      doc.version = v;
+    } else {
+      doc.version = Number(doc.version || 1) + 1;
+    }
+
+    if (req.body?.isActive !== undefined) doc.isActive = Boolean(req.body.isActive);
+
+    await doc.save();
+    return res.json({ item: doc.toObject() });
+  } catch (error) {
+    console.error('UI Components updateComponent error:', error);
+    if (error?.name === 'ValidationError') return res.status(400).json({ error: error.message });
+    return res.status(500).json({ error: 'Failed to update component' });
+  }
+};
+
+exports.deleteComponent = async (req, res) => {
+  try {
+    const { code } = req.params;
+    const doc = await UiComponent.findOne({ code: String(code).toLowerCase() });
+    if (!doc) return res.status(404).json({ error: 'Component not found' });
+
+    await UiComponentProjectComponent.deleteMany({ componentCode: doc.code });
+    await UiComponent.deleteOne({ _id: doc._id });
+    return res.json({ success: true });
+  } catch (error) {
+    console.error('UI Components deleteComponent error:', error);
+    return res.status(500).json({ error: 'Failed to delete component' });
+  }
+};
+
+exports.setAssignment = async (req, res) => {
+  try {
+    const projectId = String(req.params.projectId || '').trim();
+    const code = String(req.params.code || '').trim().toLowerCase();
+    const enabled = parseBool(req.body?.enabled, true);
+
+    const project = await UiComponentProject.findOne({ projectId }).lean();
+    if (!project) return res.status(404).json({ error: 'Project not found' });
+
+    const component = await UiComponent.findOne({ code }).lean();
+    if (!component) return res.status(404).json({ error: 'Component not found' });
+
+    const doc = await UiComponentProjectComponent.findOneAndUpdate(
+      { projectId, componentCode: code },
+      { $set: { enabled } },
+      { upsert: true, new: true, setDefaultsOnInsert: true },
+    );
+
+    return res.json({ item: doc.toObject() });
+  } catch (error) {
+    console.error('UI Components setAssignment error:', error);
+    if (error?.code === 11000) return res.status(409).json({ error: 'Assignment already exists' });
+    return res.status(500).json({ error: 'Failed to set assignment' });
+  }
+};
+
+exports.deleteAssignment = async (req, res) => {
+  try {
+    const projectId = String(req.params.projectId || '').trim();
+    const code = String(req.params.code || '').trim().toLowerCase();
+
+    await UiComponentProjectComponent.deleteOne({ projectId, componentCode: code });
+    return res.json({ success: true });
+  } catch (error) {
+    console.error('UI Components deleteAssignment error:', error);
+    return res.status(500).json({ error: 'Failed to delete assignment' });
+  }
+};
+
+exports.listProjectAssignments = async (req, res) => {
+  try {
+    const projectId = String(req.params.projectId || '').trim();
+    const items = await UiComponentProjectComponent.find({ projectId }).lean();
+    return res.json({ items });
+  } catch (error) {
+    console.error('UI Components listProjectAssignments error:', error);
+    return res.status(500).json({ error: 'Failed to list assignments' });
+  }
+};

package/src/controllers/adminUiComponentsAi.controller.js

@@ -0,0 +1,34 @@
+const { proposeComponentEdit } = require('../services/uiComponentsAi.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.propose = async (req, res) => {
+  try {
+    const actor = getBasicAuthActor(req);
+    const { code } = req.params;
+
+    const { prompt, providerKey, model, targets, mode } = req.body || {};
+
+    const result = await proposeComponentEdit({
+      code,
+      prompt,
+      providerKey,
+      model,
+      targets,
+      mode,
+      actor,
+    });
+
+    return res.json(result);
+  } catch (err) {
+    console.error('[adminUiComponentsAi] propose error', err);
+    return handleError(res, err);
+  }
+};

package/src/controllers/blogAdmin.controller.js

@@ -0,0 +1,279 @@
+const BlogPost = require('../models/BlogPost');
+const {
+  extractExcerptFromMarkdown,
+  generateUniqueBlogSlug,
+  normalizeTags,
+  slugify,
+  parsePagination,
+} = require('../services/blog.service');
+
+function normalizeStringField(value) {
+  if (value === undefined) return undefined;
+  return String(value || '').trim();
+}
+
+exports.list = async (req, res) => {
+  try {
+    const { page, limit, skip } = parsePagination({
+      page: req.query.page,
+      limit: req.query.limit,
+      maxLimit: 200,
+      defaultLimit: 50,
+    });
+
+    const filter = {};
+
+    const status = String(req.query.status || '').trim();
+    if (status) filter.status = status;
+
+    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 }, { slug: re }];
+    }
+
+    const statsBaseFilter = { ...filter };
+    delete statsBaseFilter.status;
+
+    const [items, total, statsTotal, statsDraft, statsScheduled, statsPublished, statsArchived] = await Promise.all([
+      BlogPost.find(filter)
+        .sort({ updatedAt: -1, createdAt: -1 })
+        .select('title slug status excerpt category tags authorName publishedAt scheduledAt updatedAt createdAt')
+        .skip(skip)
+        .limit(limit)
+        .lean(),
+      BlogPost.countDocuments(filter),
+      BlogPost.countDocuments(statsBaseFilter),
+      BlogPost.countDocuments({ ...statsBaseFilter, status: 'draft' }),
+      BlogPost.countDocuments({ ...statsBaseFilter, status: 'scheduled' }),
+      BlogPost.countDocuments({ ...statsBaseFilter, status: 'published' }),
+      BlogPost.countDocuments({ ...statsBaseFilter, status: 'archived' }),
+    ]);
+
+    res.json({
+      items,
+      pagination: { page, limit, total, pages: Math.ceil(total / limit) },
+      stats: {
+        total: statsTotal,
+        draft: statsDraft,
+        scheduled: statsScheduled,
+        published: statsPublished,
+        archived: statsArchived,
+      },
+    });
+  } catch (error) {
+    console.error('Error listing admin blog posts:', error);
+    res.status(500).json({ error: 'Failed to list blog posts' });
+  }
+};
+
+exports.suggestions = async (req, res) => {
+  try {
+    const [categories, authorNames, tagsAgg] = await Promise.all([
+      BlogPost.distinct('category', { category: { $ne: '' } }),
+      BlogPost.distinct('authorName', { authorName: { $ne: '' } }),
+      BlogPost.aggregate([
+        { $unwind: '$tags' },
+        { $match: { tags: { $ne: '' } } },
+        { $group: { _id: '$tags' } },
+        { $project: { _id: 0, tag: '$_id' } },
+      ]),
+    ]);
+
+    const tags = (tagsAgg || []).map((t) => String(t.tag || '')).filter(Boolean);
+
+    res.json({
+      categories: (categories || []).map((x) => String(x || '')).filter(Boolean).sort(),
+      tags: tags.sort(),
+      authorNames: (authorNames || []).map((x) => String(x || '')).filter(Boolean).sort(),
+    });
+  } catch (error) {
+    console.error('Error building blog suggestions:', error);
+    res.status(500).json({ error: 'Failed to load suggestions' });
+  }
+};
+
+exports.create = async (req, res) => {
+  try {
+    const payload = req.body || {};
+    const title = normalizeStringField(payload.title);
+    if (!title) return res.status(400).json({ error: 'title is required' });
+
+    const markdown = String(payload.markdown || '');
+    if (!markdown.trim()) return res.status(400).json({ error: 'markdown is required' });
+
+    const html = String(payload.html || payload.markdown || '');
+    const excerpt =
+      normalizeStringField(payload.excerpt) || extractExcerptFromMarkdown(markdown);
+
+    const desiredSlug = normalizeStringField(payload.slug);
+    const slug = desiredSlug ? slugify(desiredSlug) : await generateUniqueBlogSlug(title);
+
+    const post = await BlogPost.create({
+      title,
+      slug,
+      status: 'draft',
+      excerpt,
+      markdown,
+      html,
+      coverImageUrl: normalizeStringField(payload.coverImageUrl) || '',
+      category: normalizeStringField(payload.category) || '',
+      tags: normalizeTags(payload.tags),
+      authorName: normalizeStringField(payload.authorName) || '',
+      seoTitle: normalizeStringField(payload.seoTitle) || '',
+      seoDescription: normalizeStringField(payload.seoDescription) || '',
+      scheduledAt: null,
+      publishedAt: null,
+    });
+
+    res.status(201).json({ item: post.toObject() });
+  } catch (error) {
+    console.error('Error creating blog post:', error);
+    res.status(500).json({ error: 'Failed to create blog post' });
+  }
+};
+
+exports.get = async (req, res) => {
+  try {
+    const post = await BlogPost.findById(req.params.id).lean();
+    if (!post) return res.status(404).json({ error: 'Not found' });
+    res.json({ item: post });
+  } catch (error) {
+    console.error('Error getting blog post:', error);
+    res.status(500).json({ error: 'Failed to get blog post' });
+  }
+};
+
+exports.update = async (req, res) => {
+  try {
+    const post = await BlogPost.findById(req.params.id);
+    if (!post) return res.status(404).json({ error: 'Not found' });
+
+    const payload = req.body || {};
+
+    if (payload.title !== undefined) post.title = normalizeStringField(payload.title) || '';
+    if (!post.title) return res.status(400).json({ error: 'title is required' });
+
+    if (payload.slug !== undefined) {
+      const desired = slugify(payload.slug);
+      post.slug = desired || (await generateUniqueBlogSlug(post.title, { excludeId: post._id }));
+    }
+    if (!post.slug) {
+      post.slug = await generateUniqueBlogSlug(post.title, { excludeId: post._id });
+    }
+
+    if (payload.markdown !== undefined) post.markdown = String(payload.markdown || '');
+    if (payload.html !== undefined) post.html = String(payload.html || '');
+
+    if (payload.excerpt !== undefined) {
+      post.excerpt = normalizeStringField(payload.excerpt) || '';
+    }
+    if (!post.excerpt) {
+      post.excerpt = extractExcerptFromMarkdown(post.markdown);
+    }
+
+    if (payload.coverImageUrl !== undefined) post.coverImageUrl = normalizeStringField(payload.coverImageUrl) || '';
+    if (payload.category !== undefined) post.category = normalizeStringField(payload.category) || '';
+    if (payload.authorName !== undefined) post.authorName = normalizeStringField(payload.authorName) || '';
+    if (payload.seoTitle !== undefined) post.seoTitle = normalizeStringField(payload.seoTitle) || '';
+    if (payload.seoDescription !== undefined) post.seoDescription = normalizeStringField(payload.seoDescription) || '';
+    if (payload.tags !== undefined) post.tags = normalizeTags(payload.tags);
+
+    await post.save();
+
+    res.json({ item: post.toObject() });
+  } catch (error) {
+    console.error('Error updating blog post:', error);
+    res.status(500).json({ error: 'Failed to update blog post' });
+  }
+};
+
+exports.publish = async (req, res) => {
+  try {
+    const post = await BlogPost.findById(req.params.id);
+    if (!post) return res.status(404).json({ error: 'Not found' });
+
+    post.status = 'published';
+    post.scheduledAt = null;
+    if (!post.publishedAt) post.publishedAt = new Date();
+    await post.save();
+
+    res.json({ item: post.toObject() });
+  } catch (error) {
+    console.error('Error publishing blog post:', error);
+    res.status(500).json({ error: 'Failed to publish blog post' });
+  }
+};
+
+exports.unpublish = async (req, res) => {
+  try {
+    const post = await BlogPost.findById(req.params.id);
+    if (!post) return res.status(404).json({ error: 'Not found' });
+
+    post.status = 'draft';
+    post.scheduledAt = null;
+    await post.save();
+
+    res.json({ item: post.toObject() });
+  } catch (error) {
+    console.error('Error unpublishing blog post:', error);
+    res.status(500).json({ error: 'Failed to unpublish blog post' });
+  }
+};
+
+exports.schedule = async (req, res) => {
+  try {
+    const post = await BlogPost.findById(req.params.id);
+    if (!post) return res.status(404).json({ error: 'Not found' });
+
+    const scheduledAtRaw = req.body?.scheduledAt;
+    const scheduledAt = scheduledAtRaw ? new Date(scheduledAtRaw) : null;
+    if (!scheduledAt || Number.isNaN(scheduledAt.getTime())) {
+      return res.status(400).json({ error: 'scheduledAt is required and must be a valid date' });
+    }
+
+    post.status = 'scheduled';
+    post.scheduledAt = scheduledAt;
+    await post.save();
+
+    res.json({ item: post.toObject() });
+  } catch (error) {
+    console.error('Error scheduling blog post:', error);
+    res.status(500).json({ error: 'Failed to schedule blog post' });
+  }
+};
+
+exports.archive = async (req, res) => {
+  try {
+    const post = await BlogPost.findById(req.params.id);
+    if (!post) return res.status(404).json({ error: 'Not found' });
+
+    post.status = 'archived';
+    post.scheduledAt = null;
+    await post.save();
+
+    res.json({ item: post.toObject() });
+  } catch (error) {
+    console.error('Error archiving blog post:', error);
+    res.status(500).json({ error: 'Failed to archive blog post' });
+  }
+};
+
+exports.remove = async (req, res) => {
+  try {
+    const post = await BlogPost.findById(req.params.id);
+    if (!post) return res.status(404).json({ error: 'Not found' });
+
+    await BlogPost.deleteOne({ _id: post._id });
+    res.json({ deleted: true });
+  } catch (error) {
+    console.error('Error deleting blog post:', error);
+    res.status(500).json({ error: 'Failed to delete blog post' });
+  }
+};