@intranefr/superbackend 1.4.3

package/src/models/WorkflowExecution.js

@@ -0,0 +1,12 @@
+const mongoose = require('mongoose');
+
+const workflowExecutionSchema = new mongoose.Schema({
+  workflowId: { type: mongoose.Schema.Types.ObjectId, ref: 'Workflow', required: true, index: true },
+  status: { type: String, enum: ['running', 'completed', 'failed'], default: 'running' },
+  context: { type: Object, default: {} },
+  log: { type: Array, default: [] },
+  executedAt: { type: Date, default: Date.now },
+  duration: Number
+});
+
+module.exports = mongoose.model('WorkflowExecution', workflowExecutionSchema);

package/src/routes/admin.routes.js

@@ -0,0 +1,26 @@
+const express = require('express');
+const router = express.Router();
+const adminController = require('../controllers/admin.controller');
+const { basicAuth } = require('../middleware/auth');
+
+// All admin routes protected by basic auth
+router.use(basicAuth);
+
+router.get('/users', adminController.getUsers);
+router.get('/users/:id', adminController.getUser);
+router.put('/users/:id/subscription', adminController.updateUserSubscription);
+router.patch('/users/:id', adminController.updateUserPassword);
+router.post('/users/:id/reconcile', adminController.reconcileUser);
+router.post('/generate-token', adminController.generateToken);
+
+// Coolify Headless Deploy
+router.post('/coolify-headless-deploy/provision', adminController.provisionCoolifyDeploy);
+
+// Webhook event routes
+router.get('/stripe-webhooks', adminController.getWebhookEvents);
+router.get('/stripe-webhooks/:id', adminController.getWebhookEvent);
+router.post('/stripe-webhooks/retry', adminController.retryFailedWebhookEvents);
+router.post('/stripe-webhooks/:id/retry', adminController.retrySingleWebhookEvent);
+router.get('/stripe-webhooks-stats', adminController.getWebhookStats);
+
+module.exports = router;

package/src/routes/adminAssets.routes.js

@@ -0,0 +1,28 @@
+const express = require('express');
+const router = express.Router();
+const multer = require('multer');
+const { basicAuth } = require('../middleware/auth');
+const adminAssetsController = require('../controllers/adminAssets.controller');
+const { auditMiddleware } = require('../services/auditLogger');
+
+const adminAssetsStorageRoutes = require('./adminAssetsStorage.routes');
+
+const upload = multer({
+  storage: multer.memoryStorage(),
+  limits: {
+    fileSize: parseInt(process.env.MULTER_FILE_SIZE_LIMIT || '1073741824', 10)
+  }
+});
+
+router.get('/info', basicAuth, adminAssetsController.getStorageInfo);
+router.use('/storage', basicAuth, adminAssetsStorageRoutes);
+router.get('/', basicAuth, adminAssetsController.list);
+router.get('/:id', basicAuth, adminAssetsController.get);
+router.post('/bulk/move-namespace', basicAuth, auditMiddleware('admin.assets.bulk.moveNamespace', { entityType: 'Asset' }), adminAssetsController.bulkMoveNamespace);
+router.post('/bulk/set-tags', basicAuth, auditMiddleware('admin.assets.bulk.setTags', { entityType: 'Asset' }), adminAssetsController.bulkSetTags);
+router.post('/upload', basicAuth, upload.single('file'), adminAssetsController.upload);
+router.post('/:id/replace', basicAuth, upload.single('file'), adminAssetsController.replace);
+router.patch('/:id', basicAuth, adminAssetsController.update);
+router.delete('/:id', basicAuth, adminAssetsController.delete);
+
+module.exports = router;

package/src/routes/adminAssetsStorage.routes.js

@@ -0,0 +1,13 @@
+const express = require('express');
+
+const router = express.Router();
+
+const adminAssetsStorageController = require('../controllers/adminAssetsStorage.controller');
+
+router.get('/', adminAssetsStorageController.getStorageStatus);
+router.put('/s3-config', adminAssetsStorageController.saveS3Config);
+router.post('/s3-check', adminAssetsStorageController.checkS3Connection);
+router.post('/sync', adminAssetsStorageController.sync);
+router.post('/switch', adminAssetsStorageController.switchBackend);
+
+module.exports = router;

package/src/routes/adminAudit.routes.js

@@ -0,0 +1,196 @@
+const express = require('express');
+const router = express.Router();
+const mongoose = require('mongoose');
+const AuditEvent = require('../models/AuditEvent');
+
+router.get('/', async (req, res) => {
+  try {
+    const {
+      actorType,
+      actorUserId,
+      action,
+      outcome,
+      targetType,
+      targetId,
+      q,
+      from,
+      to,
+      page = 1,
+      pageSize = 50,
+    } = req.query;
+
+    const filter = {};
+
+    if (actorType && ['user', 'admin_basic', 'system', 'anonymous'].includes(actorType)) {
+      filter.actorType = actorType;
+    }
+
+    if (actorUserId) {
+      if (!mongoose.Types.ObjectId.isValid(String(actorUserId))) {
+        return res.status(400).json({ error: 'Invalid actorUserId' });
+      }
+      filter.actorUserId = String(actorUserId);
+    }
+
+    if (action) {
+      filter.action = { $regex: action, $options: 'i' };
+    }
+
+    if (outcome && ['success', 'failure'].includes(outcome)) {
+      filter.outcome = outcome;
+    }
+
+    if (targetType) {
+      filter.targetType = String(targetType);
+    }
+
+    if (targetId) {
+      filter.targetId = String(targetId);
+    }
+
+    if (q) {
+      filter.$or = [
+        { action: { $regex: q, $options: 'i' } },
+        { entityType: { $regex: q, $options: 'i' } },
+        { targetType: { $regex: q, $options: 'i' } },
+        { 'context.path': { $regex: q, $options: 'i' } },
+      ];
+    }
+
+    const dateFilter = {};
+    if (from) {
+      const fromDate = new Date(from);
+      if (!isNaN(fromDate.getTime())) {
+        dateFilter.$gte = fromDate;
+      }
+    }
+    if (to) {
+      const toDate = new Date(to);
+      if (!isNaN(toDate.getTime())) {
+        dateFilter.$lte = toDate;
+      }
+    }
+    if (Object.keys(dateFilter).length > 0) {
+      filter.createdAt = dateFilter;
+    }
+
+    const skip = (Math.max(1, parseInt(page, 10)) - 1) * parseInt(pageSize, 10);
+    const limit = Math.min(100, Math.max(1, parseInt(pageSize, 10)));
+
+    const [events, total] = await Promise.all([
+      AuditEvent.find(filter)
+        .populate('actorUserId', 'email')
+        .sort({ createdAt: -1 })
+        .skip(skip)
+        .limit(limit)
+        .lean(),
+      AuditEvent.countDocuments(filter),
+    ]);
+
+    const normalizedEvents = (events || []).map((evt) => {
+      const normalizedActorType = evt.actorType === 'admin' ? 'admin_basic' : evt.actorType;
+      return {
+        ...evt,
+        actorType: normalizedActorType,
+        at: evt.createdAt,
+        details: evt.details || evt.meta,
+      };
+    });
+
+    res.json({
+      events: normalizedEvents,
+      total,
+      page: parseInt(page, 10),
+      pageSize: limit,
+      totalPages: Math.ceil(total / limit),
+    });
+  } catch (err) {
+    console.error('[AdminAudit] Failed to list audit events:', err);
+    res.status(500).json({ error: 'Failed to list audit events' });
+  }
+});
+
+router.get('/stats', async (req, res) => {
+  try {
+    const now = new Date();
+    const last24h = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    const last7d = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+
+    const last24hDateFilter = { createdAt: { $gte: last24h } };
+    const last7dDateFilter = { createdAt: { $gte: last7d } };
+
+    const [total, last24hCount, last7dCount, failures24h, byActorType, topActions] = await Promise.all([
+      AuditEvent.countDocuments({}),
+      AuditEvent.countDocuments(last24hDateFilter),
+      AuditEvent.countDocuments(last7dDateFilter),
+      AuditEvent.countDocuments({
+        ...last24hDateFilter,
+        outcome: 'failure',
+      }),
+      AuditEvent.aggregate([
+        { $match: last24hDateFilter },
+        { $group: { _id: '$actorType', count: { $sum: 1 } } },
+      ]),
+      AuditEvent.aggregate([
+        { $match: last24hDateFilter },
+        { $group: { _id: '$action', count: { $sum: 1 } } },
+        { $sort: { count: -1 } },
+        { $limit: 10 },
+      ]),
+    ]);
+
+    res.json({
+      total,
+      last24h: last24hCount,
+      last7d: last7dCount,
+      failures24h,
+      byActorType: byActorType.reduce((acc, a) => {
+        acc[a._id] = a.count;
+        return acc;
+      }, {}),
+      topActions: topActions.map((a) => ({ action: a._id, count: a.count })),
+    });
+  } catch (err) {
+    console.error('[AdminAudit] Failed to get stats:', err);
+    res.status(500).json({ error: 'Failed to get stats' });
+  }
+});
+
+router.get('/actions', async (req, res) => {
+  try {
+    const actions = await AuditEvent.distinct('action');
+    res.json({ actions: actions.sort() });
+  } catch (err) {
+    console.error('[AdminAudit] Failed to get actions:', err);
+    res.status(500).json({ error: 'Failed to get actions' });
+  }
+});
+
+router.get('/:id', async (req, res) => {
+  try {
+    if (!mongoose.Types.ObjectId.isValid(req.params.id)) {
+      return res.status(400).json({ error: 'Invalid id' });
+    }
+
+    const event = await AuditEvent.findById(req.params.id)
+      .populate('actorUserId', 'email')
+      .lean();
+    if (!event) {
+      return res.status(404).json({ error: 'Audit event not found' });
+    }
+
+    const normalizedEvent = {
+      ...event,
+      actorType: event.actorType === 'admin' ? 'admin_basic' : event.actorType,
+      at: event.createdAt,
+      details: event.details || event.meta,
+    };
+
+    res.json(normalizedEvent);
+  } catch (err) {
+    console.error('[AdminAudit] Failed to get audit event:', err);
+    res.status(500).json({ error: 'Failed to get audit event' });
+  }
+});
+
+module.exports = router;

package/src/routes/adminEjsVirtual.routes.js

@@ -0,0 +1,17 @@
+const express = require('express');
+const router = express.Router();
+const { basicAuth } = require('../middleware/auth');
+const controller = require('../controllers/adminEjsVirtual.controller');
+
+router.use(basicAuth);
+
+router.get('/files', controller.list);
+router.get('/file', controller.getFile);
+router.put('/file', controller.saveFile);
+router.post('/file/revert', controller.revertToDefault);
+router.get('/history', controller.listHistory);
+router.post('/rollback', controller.rollback);
+router.post('/vibe', controller.vibe);
+router.post('/cache/clear', controller.clearCache);
+
+module.exports = router;

package/src/routes/adminErrors.routes.js

@@ -0,0 +1,164 @@
+const express = require('express');
+const router = express.Router();
+const ErrorAggregate = require('../models/ErrorAggregate');
+
+router.get('/', async (req, res) => {
+  try {
+    const {
+      source,
+      severity,
+      status,
+      q,
+      sort = 'lastSeenAt',
+      order = 'desc',
+      page = 1,
+      pageSize = 20,
+      since,
+    } = req.query;
+
+    const filter = {};
+
+    if (source && ['frontend', 'backend'].includes(source)) {
+      filter.source = source;
+    }
+    if (severity && ['fatal', 'error', 'warn', 'info'].includes(severity)) {
+      filter.severity = severity;
+    }
+    if (status && ['open', 'ignored', 'resolved'].includes(status)) {
+      filter.status = status;
+    }
+    if (q) {
+      filter.$or = [
+        { messageTemplate: { $regex: q, $options: 'i' } },
+        { errorName: { $regex: q, $options: 'i' } },
+      ];
+    }
+    if (since) {
+      const sinceDate = new Date(since);
+      if (!isNaN(sinceDate.getTime())) {
+        filter.lastSeenAt = { $gte: sinceDate };
+      }
+    }
+
+    const sortField = ['lastSeenAt', 'countTotal', 'firstSeenAt', 'errorName'].includes(sort) ? sort : 'lastSeenAt';
+    const sortOrder = order === 'asc' ? 1 : -1;
+
+    const skip = (Math.max(1, parseInt(page, 10)) - 1) * parseInt(pageSize, 10);
+    const limit = Math.min(100, Math.max(1, parseInt(pageSize, 10)));
+
+    const [errors, total] = await Promise.all([
+      ErrorAggregate.find(filter)
+        .select('-samples')
+        .sort({ [sortField]: sortOrder })
+        .skip(skip)
+        .limit(limit)
+        .lean(),
+      ErrorAggregate.countDocuments(filter),
+    ]);
+
+    res.json({
+      errors,
+      total,
+      page: parseInt(page, 10),
+      pageSize: limit,
+      totalPages: Math.ceil(total / limit),
+    });
+  } catch (err) {
+    console.error('[AdminErrors] Failed to list errors:', err);
+    res.status(500).json({ error: 'Failed to list errors' });
+  }
+});
+
+router.get('/stats', async (req, res) => {
+  try {
+    const now = new Date();
+    const last24h = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    const last7d = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+
+    const [total, open, last24hCount, last7dCount, bySource, bySeverity] = await Promise.all([
+      ErrorAggregate.countDocuments({}),
+      ErrorAggregate.countDocuments({ status: 'open' }),
+      ErrorAggregate.countDocuments({ lastSeenAt: { $gte: last24h } }),
+      ErrorAggregate.countDocuments({ lastSeenAt: { $gte: last7d } }),
+      ErrorAggregate.aggregate([
+        { $group: { _id: '$source', count: { $sum: 1 }, totalOccurrences: { $sum: '$countTotal' } } },
+      ]),
+      ErrorAggregate.aggregate([
+        { $group: { _id: '$severity', count: { $sum: 1 }, totalOccurrences: { $sum: '$countTotal' } } },
+      ]),
+    ]);
+
+    res.json({
+      total,
+      open,
+      last24h: last24hCount,
+      last7d: last7dCount,
+      bySource: bySource.reduce((acc, s) => {
+        acc[s._id] = { count: s.count, totalOccurrences: s.totalOccurrences };
+        return acc;
+      }, {}),
+      bySeverity: bySeverity.reduce((acc, s) => {
+        acc[s._id] = { count: s.count, totalOccurrences: s.totalOccurrences };
+        return acc;
+      }, {}),
+    });
+  } catch (err) {
+    console.error('[AdminErrors] Failed to get stats:', err);
+    res.status(500).json({ error: 'Failed to get stats' });
+  }
+});
+
+router.get('/:id', async (req, res) => {
+  try {
+    const error = await ErrorAggregate.findById(req.params.id).lean();
+    if (!error) {
+      return res.status(404).json({ error: 'Error not found' });
+    }
+    res.json(error);
+  } catch (err) {
+    console.error('[AdminErrors] Failed to get error:', err);
+    res.status(500).json({ error: 'Failed to get error' });
+  }
+});
+
+router.put('/:id/status', async (req, res) => {
+  try {
+    const { status } = req.body;
+    if (!['open', 'ignored', 'resolved'].includes(status)) {
+      return res.status(400).json({ error: 'Invalid status' });
+    }
+
+    const update = { status };
+    if (status === 'resolved') {
+      update.resolvedAt = new Date();
+    } else {
+      update.resolvedAt = null;
+    }
+
+    const error = await ErrorAggregate.findByIdAndUpdate(req.params.id, { $set: update }, { new: true }).lean();
+
+    if (!error) {
+      return res.status(404).json({ error: 'Error not found' });
+    }
+
+    res.json(error);
+  } catch (err) {
+    console.error('[AdminErrors] Failed to update error status:', err);
+    res.status(500).json({ error: 'Failed to update error status' });
+  }
+});
+
+router.delete('/:id', async (req, res) => {
+  try {
+    const result = await ErrorAggregate.findByIdAndDelete(req.params.id);
+    if (!result) {
+      return res.status(404).json({ error: 'Error not found' });
+    }
+    res.json({ message: 'Error deleted' });
+  } catch (err) {
+    console.error('[AdminErrors] Failed to delete error:', err);
+    res.status(500).json({ error: 'Failed to delete error' });
+  }
+});
+
+module.exports = router;

package/src/routes/adminFeatureFlags.routes.js

@@ -0,0 +1,12 @@
+const express = require('express');
+const router = express.Router();
+const { basicAuth } = require('../middleware/auth');
+const adminFeatureFlagsController = require('../controllers/adminFeatureFlags.controller');
+
+router.get('/', basicAuth, adminFeatureFlagsController.listFlags);
+router.get('/:key', basicAuth, adminFeatureFlagsController.getFlag);
+router.post('/', basicAuth, adminFeatureFlagsController.createFlag);
+router.put('/:key', basicAuth, adminFeatureFlagsController.updateFlag);
+router.delete('/:key', basicAuth, adminFeatureFlagsController.deleteFlag);
+
+module.exports = router;

package/src/routes/adminHeadless.routes.js

@@ -0,0 +1,38 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const adminHeadlessController = require('../controllers/adminHeadless.controller');
+
+router.use(basicAuth);
+
+// Models
+router.get('/models', adminHeadlessController.listModels);
+router.get('/models/:codeIdentifier', adminHeadlessController.getModel);
+router.post('/models', adminHeadlessController.createModel);
+router.put('/models/:codeIdentifier', adminHeadlessController.updateModel);
+router.delete('/models/:codeIdentifier', adminHeadlessController.deleteModel);
+
+// Advanced JSON / bulk helpers
+router.post('/models/validate', adminHeadlessController.validateModelDefinition);
+router.post('/models/apply', adminHeadlessController.applyModelProposal);
+
+// AI model builder
+router.post('/ai/model-builder/chat', adminHeadlessController.aiModelBuilderChat);
+
+// Admin collections CRUD (UI)
+router.get('/collections/:modelCode', adminHeadlessController.listCollectionItems);
+router.post('/collections/:modelCode', adminHeadlessController.createCollectionItem);
+router.put('/collections/:modelCode/:id', adminHeadlessController.updateCollectionItem);
+router.delete('/collections/:modelCode/:id', adminHeadlessController.deleteCollectionItem);
+
+router.post('/collections-api-test', adminHeadlessController.executeCollectionsApiTest);
+
+// API tokens
+router.get('/tokens', adminHeadlessController.listTokens);
+router.get('/tokens/:id', adminHeadlessController.getToken);
+router.post('/tokens', adminHeadlessController.createToken);
+router.put('/tokens/:id', adminHeadlessController.updateToken);
+router.delete('/tokens/:id', adminHeadlessController.deleteToken);
+
+module.exports = router;

package/src/routes/adminI18n.routes.js

@@ -0,0 +1,22 @@
+const express = require('express');
+const router = express.Router();
+const { basicAuth } = require('../middleware/auth');
+
+const adminI18nController = require('../controllers/adminI18n.controller');
+
+router.use(basicAuth);
+
+router.get('/locales', adminI18nController.listLocales);
+router.post('/locales', adminI18nController.createLocale);
+router.put('/locales/:code', adminI18nController.updateLocale);
+
+router.get('/entries', adminI18nController.listEntries);
+router.post('/entries', adminI18nController.createEntry);
+router.put('/entries/:id', adminI18nController.updateEntry);
+router.delete('/entries/:id', adminI18nController.deleteEntry);
+
+router.post('/ai/preview', adminI18nController.aiPreview);
+router.post('/ai/apply', adminI18nController.aiApply);
+router.post('/ai/translate-text', adminI18nController.aiTranslateText);
+
+module.exports = router;

package/src/routes/adminJsonConfigs.routes.js

@@ -0,0 +1,15 @@
+const express = require('express');
+const router = express.Router();
+const { basicAuth } = require('../middleware/auth');
+
+const adminJsonConfigsController = require('../controllers/adminJsonConfigs.controller');
+
+router.get('/', basicAuth, adminJsonConfigsController.list);
+router.get('/:id', basicAuth, adminJsonConfigsController.get);
+router.post('/', basicAuth, adminJsonConfigsController.create);
+router.put('/:id', basicAuth, adminJsonConfigsController.update);
+router.post('/:id/regenerate-slug', basicAuth, adminJsonConfigsController.regenerateSlug);
+router.post('/:id/clear-cache', basicAuth, adminJsonConfigsController.clearCache);
+router.delete('/:id', basicAuth, adminJsonConfigsController.remove);
+
+module.exports = router;

package/src/routes/adminLlm.routes.js

@@ -0,0 +1,12 @@
+const express = require("express");
+const router = express.Router();
+const { basicAuth } = require("../middleware/auth");
+const adminLlmController = require("../controllers/adminLlm.controller");
+
+router.get("/config", basicAuth, adminLlmController.getConfig);
+router.post("/config", basicAuth, adminLlmController.saveConfig);
+router.post("/prompts/:key/test", basicAuth, adminLlmController.testPrompt);
+router.get("/audit", basicAuth, adminLlmController.listAudit);
+router.get("/costs", basicAuth, adminLlmController.listCosts);
+
+module.exports = router;

package/src/routes/adminMigration.routes.js

@@ -0,0 +1,81 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const { auditMiddleware } = require('../services/auditLogger');
+
+const adminMigrationController = require('../controllers/adminMigration.controller');
+
+router.get(
+  '/environments',
+  basicAuth,
+  adminMigrationController.listEnvironments,
+);
+
+router.get(
+  '/environments/:envKey',
+  basicAuth,
+  adminMigrationController.getEnvironment,
+);
+
+router.get(
+  '/models',
+  basicAuth,
+  adminMigrationController.listModels,
+);
+
+router.get(
+  '/models/:modelName/schema',
+  basicAuth,
+  adminMigrationController.getModelSchema,
+);
+
+router.post(
+  '/preview',
+  basicAuth,
+  adminMigrationController.preview,
+);
+
+router.post(
+  '/environments',
+  basicAuth,
+  auditMiddleware('admin.migration.environments.upsert', { entityType: 'GlobalSetting' }),
+  adminMigrationController.upsertEnvironment,
+);
+
+router.delete(
+  '/environments/:envKey',
+  basicAuth,
+  auditMiddleware('admin.migration.environments.delete', { entityType: 'GlobalSetting' }),
+  adminMigrationController.deleteEnvironment,
+);
+
+router.post(
+  '/test-connection',
+  basicAuth,
+  auditMiddleware('admin.migration.test_connection', { entityType: 'Migration' }),
+  adminMigrationController.testConnection,
+);
+
+router.post(
+  '/test-assets',
+  basicAuth,
+  auditMiddleware('admin.migration.test_assets', { entityType: 'Migration' }),
+  adminMigrationController.testAssetsTarget,
+);
+
+router.post(
+  '/test-assets-copy',
+  basicAuth,
+  auditMiddleware('admin.migration.test_assets_copy', { entityType: 'Migration' }),
+  adminMigrationController.testAssetsCopyKey,
+);
+
+router.post(
+  '/run',
+  basicAuth,
+  auditMiddleware('admin.migration.run', { entityType: 'Migration' }),
+  adminMigrationController.runMigration,
+);
+
+module.exports = router;

package/src/routes/adminSeoConfig.routes.js

@@ -0,0 +1,20 @@
+const express = require('express');
+const router = express.Router();
+
+const { basicAuth } = require('../middleware/auth');
+const adminSeoConfigController = require('../controllers/adminSeoConfig.controller');
+
+router.get('/', basicAuth, adminSeoConfigController.get);
+router.put('/', basicAuth, adminSeoConfigController.update);
+
+// SEO Config helpers
+router.get('/ai/views', basicAuth, adminSeoConfigController.seoConfigAiListViews);
+router.post('/ai/generate-entry', basicAuth, adminSeoConfigController.seoConfigAiGenerateEntry);
+router.post('/ai/improve-entry', basicAuth, adminSeoConfigController.seoConfigAiImproveEntry);
+router.post('/pages/apply-entry', basicAuth, adminSeoConfigController.seoConfigApplyEntry);
+
+router.put('/og/svg', basicAuth, adminSeoConfigController.updateOgSvg);
+router.post('/og/generate-png', basicAuth, adminSeoConfigController.generateOgPng);
+router.post('/ai/edit-svg', basicAuth, adminSeoConfigController.aiEditSvg);
+
+module.exports = router;