@intranefr/superbackend 1.4.3

package/src/controllers/adminAssetsStorage.controller.js

@@ -0,0 +1,260 @@
+const GlobalSetting = require('../models/GlobalSetting');
+const Asset = require('../models/Asset');
+const { encryptString } = require('../utils/encryption');
+const globalSettingsService = require('../services/globalSettings.service');
+const objectStorage = require('../services/objectStorage.service');
+
+const STORAGE_BACKEND_SETTING_KEY = 'STORAGE_BACKEND';
+const STORAGE_S3_CONFIG_SETTING_KEY = 'STORAGE_S3_CONFIG';
+
+const maskS3Config = (cfg) => {
+  if (!cfg) return null;
+  return {
+    endpoint: cfg.endpoint,
+    region: cfg.region,
+    bucket: cfg.bucket,
+    forcePathStyle: Boolean(cfg.forcePathStyle),
+    accessKeyId: cfg.accessKeyId ? '********' : '',
+    secretAccessKey: cfg.secretAccessKey ? '********' : '',
+  };
+};
+
+const upsertSetting = async ({ key, value, type, description }) => {
+  const existing = await GlobalSetting.findOne({ key });
+  if (existing) {
+    existing.type = type;
+    existing.description = description;
+    existing.public = false;
+    existing.value = value;
+    await existing.save();
+    return existing.toObject();
+  }
+
+  const created = await GlobalSetting.create({
+    key,
+    value,
+    type,
+    description,
+    public: false,
+  });
+  return created.toObject();
+};
+
+exports.getStorageStatus = async (req, res) => {
+  try {
+    const [activeBackend, s3Config] = await Promise.all([
+      objectStorage.getActiveBackend(),
+      objectStorage.getS3Config(),
+    ]);
+
+    res.json({
+      activeBackend,
+      s3: {
+        configured: Boolean(s3Config),
+        config: s3Config ? maskS3Config(s3Config) : null,
+      },
+    });
+  } catch (error) {
+    console.error('Error getting storage status:', error);
+    res.status(500).json({ error: 'Failed to get storage status' });
+  }
+};
+
+exports.saveS3Config = async (req, res) => {
+  try {
+    const normalizeBlank = (v) => {
+      const s = v === undefined || v === null ? '' : String(v);
+      const trimmed = s.trim();
+      return trimmed ? trimmed : undefined;
+    };
+
+    const existing = await objectStorage.getS3Config();
+
+    const candidate = {
+      endpoint: normalizeBlank(req.body?.endpoint) ?? existing?.endpoint,
+      region: normalizeBlank(req.body?.region) ?? existing?.region,
+      bucket: normalizeBlank(req.body?.bucket) ?? existing?.bucket,
+      accessKeyId: normalizeBlank(req.body?.accessKeyId) ?? existing?.accessKeyId,
+      secretAccessKey: normalizeBlank(req.body?.secretAccessKey) ?? existing?.secretAccessKey,
+      forcePathStyle: req.body?.forcePathStyle ?? existing?.forcePathStyle,
+    };
+
+    const validated = objectStorage.validateS3Config(candidate);
+    if (!validated) {
+      return res.status(400).json({ error: 'Invalid S3 config. Required: endpoint, accessKeyId, secretAccessKey, bucket.' });
+    }
+
+    const encryptedPayload = encryptString(JSON.stringify(validated));
+    await upsertSetting({
+      key: STORAGE_S3_CONFIG_SETTING_KEY,
+      type: 'encrypted',
+      value: JSON.stringify(encryptedPayload),
+      description: 'S3 storage configuration (encrypted)'
+    });
+
+    globalSettingsService.clearSettingsCache();
+    objectStorage.clearStorageConfigCache();
+
+    res.json({
+      ok: true,
+      s3: {
+        configured: true,
+        config: maskS3Config(validated),
+      },
+    });
+  } catch (error) {
+    console.error('Error saving S3 config:', error);
+    res.status(500).json({ error: 'Failed to save S3 config' });
+  }
+};
+
+exports.checkS3Connection = async (req, res) => {
+  try {
+    const result = await objectStorage.checkS3Connection();
+    res.json({ ok: true, result });
+  } catch (error) {
+    console.error('Error checking S3 connection:', error);
+    res.status(400).json({ ok: false, error: error.message || 'S3 check failed', code: error.code || 'S3_CHECK_FAILED' });
+  }
+};
+
+const normalizeDirection = (dir) => {
+  const v = String(dir || '').trim().toLowerCase();
+  if (v === 'fs-to-s3' || v === 's3-to-fs') return v;
+  return null;
+};
+
+exports.sync = async (req, res) => {
+  try {
+    const direction = normalizeDirection(req.body?.direction);
+    if (!direction) {
+      return res.status(400).json({ error: 'Invalid direction. Use fs-to-s3 or s3-to-fs.' });
+    }
+
+    const limit = Math.min(500, Math.max(1, Number(req.body?.limit) || 100));
+    const cursor = req.body?.cursor ? String(req.body.cursor) : null;
+
+    const sourceBackend = direction === 'fs-to-s3' ? 'fs' : 's3';
+    const destBackend = direction === 'fs-to-s3' ? 's3' : 'fs';
+
+    const s3Cfg = await objectStorage.getS3Config();
+    if ((sourceBackend === 's3' || destBackend === 's3') && !s3Cfg) {
+      return res.status(400).json({ error: 'S3 is not configured' });
+    }
+
+    const expectedSourceProvider = sourceBackend;
+    const expectedSourceBucket = sourceBackend === 's3' ? s3Cfg.bucket : 'fs';
+
+    const filter = { status: 'uploaded' };
+    if (cursor) {
+      filter._id = { $gt: cursor };
+    }
+
+    const assets = await Asset.find(filter)
+      .sort({ _id: 1 })
+      .limit(limit)
+      .lean();
+
+    const stats = {
+      direction,
+      sourceBackend,
+      destBackend,
+      scanned: 0,
+      copied: 0,
+      skippedMissingSource: 0,
+      skippedAlreadySynced: 0,
+      skippedDifferentBytes: 0,
+      aborted: false,
+      abortReason: null,
+      nextCursor: null,
+    };
+
+    for (const asset of assets) {
+      stats.scanned += 1;
+      stats.nextCursor = String(asset._id);
+
+      if (asset.provider === expectedSourceProvider && asset.bucket !== expectedSourceBucket) {
+        // Asset claims it is in the source backend, but points to a different bucket.
+        // This is a dangerous mismatch, so abort.
+        stats.aborted = true;
+        stats.abortReason = {
+          reason: 'asset provider/bucket mismatch',
+          assetId: String(asset._id),
+          key: asset.key,
+          actual: { provider: asset.provider, bucket: asset.bucket },
+          expected: { provider: expectedSourceProvider, bucket: expectedSourceBucket },
+        };
+        return res.status(409).json({ error: 'Sync aborted: provider/bucket mismatch', details: stats.abortReason, stats });
+      }
+
+      const sourceExists = await objectStorage.objectExists({ key: asset.key, backend: sourceBackend });
+      if (!sourceExists) {
+        stats.skippedMissingSource += 1;
+        continue;
+      }
+
+      const destExists = await objectStorage.objectExists({ key: asset.key, backend: destBackend });
+      if (destExists) {
+        const cmp = await objectStorage.compareObjectBytes({ key: asset.key, sourceBackend, destBackend });
+        if (!cmp.comparable) {
+          stats.skippedDifferentBytes += 1;
+          continue;
+        }
+        if (cmp.same) {
+          stats.skippedAlreadySynced += 1;
+        } else {
+          stats.skippedDifferentBytes += 1;
+        }
+        continue;
+      }
+
+      const obj = await objectStorage.getObject({ key: asset.key, backend: sourceBackend });
+      if (!obj || !obj.body) {
+        stats.skippedMissingSource += 1;
+        continue;
+      }
+
+      await objectStorage.putObject({
+        key: asset.key,
+        body: obj.body,
+        contentType: asset.contentType,
+        backend: destBackend,
+      });
+
+      stats.copied += 1;
+    }
+
+    res.json({ ok: true, stats });
+  } catch (error) {
+    console.error('Error syncing storage:', error);
+    res.status(500).json({ error: 'Failed to sync storage', details: error.message });
+  }
+};
+
+exports.switchBackend = async (req, res) => {
+  try {
+    const backend = String(req.body?.backend || '').trim().toLowerCase();
+    if (backend !== 'fs' && backend !== 's3') {
+      return res.status(400).json({ error: 'Invalid backend. Use fs or s3.' });
+    }
+
+    if (backend === 's3') {
+      await objectStorage.checkS3Connection();
+    }
+
+    await upsertSetting({
+      key: STORAGE_BACKEND_SETTING_KEY,
+      type: 'string',
+      value: backend,
+      description: 'Active object storage backend (fs or s3)'
+    });
+
+    globalSettingsService.clearSettingsCache();
+    objectStorage.clearStorageConfigCache();
+
+    res.json({ ok: true, activeBackend: backend });
+  } catch (error) {
+    console.error('Error switching backend:', error);
+    res.status(400).json({ error: error.message || 'Failed to switch backend' });
+  }
+};

package/src/controllers/adminEjsVirtual.controller.js

@@ -0,0 +1,354 @@
+const fs = require('fs');
+const path = require('path');
+
+const VirtualEjsFile = require('../models/VirtualEjsFile');
+const VirtualEjsFileVersion = require('../models/VirtualEjsFileVersion');
+const VirtualEjsGroupChange = require('../models/VirtualEjsGroupChange');
+
+const ejsVirtualService = require('../services/ejsVirtual.service');
+const { getBasicAuthActor, createAuditEvent } = require('../services/audit.service');
+
+function normalizeViewsRoot(req) {
+  const viewsRoot = (req.app && req.app.get('views')) ? req.app.get('views') : path.join(process.cwd(), 'src', 'views');
+  return String(viewsRoot);
+}
+
+async function listFilesRecursive(rootDir, relDir = '') {
+  const abs = path.join(rootDir, relDir);
+  const items = await fs.promises.readdir(abs, { withFileTypes: true });
+  const results = [];
+
+  for (const item of items) {
+    const name = item.name;
+    if (name.startsWith('.')) continue;
+    if (name === 'node_modules') continue;
+
+    const nextRel = path.join(relDir, name);
+    const nextAbs = path.join(rootDir, nextRel);
+
+    if (item.isDirectory()) {
+      const nested = await listFilesRecursive(rootDir, nextRel);
+      results.push(...nested);
+      continue;
+    }
+
+    if (item.isFile() && name.endsWith('.ejs')) {
+      results.push(nextRel.replace(/\\/g, '/'));
+    }
+  }
+
+  return results;
+}
+
+exports.list = async (req, res) => {
+  try {
+    const viewsRoot = normalizeViewsRoot(req);
+    const dbFiles = await VirtualEjsFile.find({}).select('path enabled inferred integrated updatedAt').lean();
+    const dbByPath = new Map((dbFiles || []).map((f) => [f.path, f]));
+
+    let fsFiles = [];
+    try {
+      fsFiles = await listFilesRecursive(viewsRoot);
+    } catch (_) {
+      fsFiles = [];
+    }
+
+    const allPaths = new Set([...(fsFiles || []), ...Array.from(dbByPath.keys())]);
+    const items = Array.from(allPaths)
+      .sort()
+      .map((p) => {
+        const db = dbByPath.get(p) || null;
+        const isAdminView = p.startsWith('admin/');
+        const integratedFlag = isAdminView ? Boolean(db && db.integrated) : true;
+        return {
+          path: p,
+          existsOnFs: fsFiles.includes(p),
+          hasOverride: Boolean(db && typeof db.enabled === 'boolean'),
+          enabled: db ? Boolean(db.enabled) : false,
+          inferred: db ? Boolean(db.inferred) : fsFiles.includes(p),
+          integrated: integratedFlag,
+          updatedAt: db ? db.updatedAt : null,
+        };
+      });
+
+    res.json({ viewsRoot, items });
+  } catch (err) {
+    console.error('[adminEjsVirtual] list error', err);
+    res.status(500).json({ error: 'Failed to list EJS files' });
+  }
+};
+
+exports.getFile = async (req, res) => {
+  try {
+    const viewsRoot = normalizeViewsRoot(req);
+    const relPath = ejsVirtualService.normalizeRelPath(String(req.query.path || '').trim());
+
+    const fsContent = await ejsVirtualService.readFsView(viewsRoot, relPath);
+    const override = await VirtualEjsFile.findOne({ path: relPath }).lean();
+
+    const effective = await ejsVirtualService.resolveTemplateSource({ viewsRoot, relPath, allowDb: true });
+
+    res.json({
+      path: relPath,
+      fs: { content: fsContent },
+      db: override ? { enabled: Boolean(override.enabled), content: override.content || '', updatedAt: override.updatedAt } : null,
+      effective: { source: effective.source, content: effective.content },
+    });
+  } catch (err) {
+    const code = 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 });
+    console.error('[adminEjsVirtual] getFile error', err);
+    res.status(500).json({ error: 'Failed to load file' });
+  }
+};
+
+exports.saveFile = async (req, res) => {
+  try {
+    const actor = getBasicAuthActor(req);
+    const viewsRoot = normalizeViewsRoot(req);
+    const relPath = ejsVirtualService.normalizeRelPath(String(req.query.path || '').trim());
+
+    const content = typeof req.body?.content === 'string' ? req.body.content : '';
+    const enabled = req.body?.enabled !== undefined ? Boolean(req.body.enabled) : true;
+    const description = String(req.body?.description || '').trim();
+
+    const existing = await VirtualEjsFile.findOne({ path: relPath });
+    const before = existing ? existing.toObject() : null;
+
+    const next = await VirtualEjsFile.findOneAndUpdate(
+      { path: relPath },
+      {
+        $set: {
+          path: relPath,
+          enabled,
+          content,
+          source: 'manual',
+          inferred: true,
+          lastSeenAt: new Date(),
+        },
+        $setOnInsert: {
+          integrated: false,
+          renderCount: 0,
+          lastRenderedAt: null,
+        },
+      },
+      { upsert: true, new: true },
+    );
+
+    const groupCount = await VirtualEjsGroupChange.countDocuments({});
+    const group = await VirtualEjsGroupChange.create({
+      title: `Grouped changes ${groupCount + 1}`,
+      summary: description || 'Manual edit',
+      filePaths: [relPath],
+      versionIds: [],
+      createdBy: actor.actorId || null,
+    });
+
+    const version = await VirtualEjsFileVersion.create({
+      fileId: next._id,
+      path: relPath,
+      content,
+      source: 'manual',
+      description: description || 'Manual edit',
+      groupId: group._id,
+    });
+
+    await VirtualEjsGroupChange.updateOne({ _id: group._id }, { $set: { versionIds: [version._id] } });
+
+    await createAuditEvent({
+      ...actor,
+      action: 'ejsVirtual.file.save',
+      entityType: 'VirtualEjsFile',
+      entityId: relPath,
+      before,
+      after: next.toObject(),
+      meta: { groupId: String(group._id) },
+    });
+
+    ejsVirtualService.invalidateCacheForPath(relPath);
+
+    res.json({
+      file: next.toObject(),
+      version: version.toObject(),
+      group: group.toObject(),
+    });
+  } catch (err) {
+    const code = err.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: err.message });
+    console.error('[adminEjsVirtual] saveFile error', err);
+    res.status(500).json({ error: 'Failed to save file' });
+  }
+};
+
+exports.revertToDefault = async (req, res) => {
+  try {
+    const actor = getBasicAuthActor(req);
+    const relPath = ejsVirtualService.normalizeRelPath(String(req.query.path || '').trim());
+
+    const existing = await VirtualEjsFile.findOne({ path: relPath });
+    if (!existing) {
+      return res.json({ success: true, message: 'No override existed' });
+    }
+
+    const before = existing.toObject();
+
+    await VirtualEjsFile.deleteOne({ path: relPath });
+
+    await createAuditEvent({
+      ...actor,
+      action: 'ejsVirtual.file.revert_to_default',
+      entityType: 'VirtualEjsFile',
+      entityId: relPath,
+      before,
+      after: null,
+      meta: null,
+    });
+
+    ejsVirtualService.invalidateCacheForPath(relPath);
+
+    res.json({ success: true });
+  } catch (err) {
+    const code = err.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: err.message });
+    console.error('[adminEjsVirtual] revertToDefault error', err);
+    res.status(500).json({ error: 'Failed to revert to default' });
+  }
+};
+
+exports.listHistory = async (req, res) => {
+  try {
+    const relPath = ejsVirtualService.normalizeRelPath(String(req.query.path || '').trim());
+    const versions = await VirtualEjsFileVersion.find({ path: relPath })
+      .sort({ createdAt: -1 })
+      .limit(50)
+      .lean();
+    res.json({ path: relPath, versions });
+  } catch (err) {
+    const code = err.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: err.message });
+    console.error('[adminEjsVirtual] listHistory error', err);
+    res.status(500).json({ error: 'Failed to load history' });
+  }
+};
+
+exports.rollback = async (req, res) => {
+  try {
+    const actor = getBasicAuthActor(req);
+    const versionId = String(req.body?.versionId || '').trim();
+    if (!versionId) return res.status(400).json({ error: 'versionId is required' });
+
+    const version = await VirtualEjsFileVersion.findById(versionId).lean();
+    if (!version) return res.status(404).json({ error: 'Version not found' });
+
+    const relPath = ejsVirtualService.normalizeRelPath(version.path);
+
+    const existing = await VirtualEjsFile.findOne({ path: relPath });
+    const before = existing ? existing.toObject() : null;
+
+    const next = await VirtualEjsFile.findOneAndUpdate(
+      { path: relPath },
+      {
+        $set: {
+          path: relPath,
+          enabled: true,
+          content: version.content,
+          source: 'rollback',
+          inferred: true,
+          lastSeenAt: new Date(),
+        },
+        $setOnInsert: {
+          integrated: false,
+          renderCount: 0,
+          lastRenderedAt: null,
+        },
+      },
+      { upsert: true, new: true },
+    );
+
+    const groupCount = await VirtualEjsGroupChange.countDocuments({});
+    const group = await VirtualEjsGroupChange.create({
+      title: `Grouped changes ${groupCount + 1}`,
+      summary: `Rollback to ${versionId}`,
+      filePaths: [relPath],
+      versionIds: [],
+      createdBy: actor.actorId || null,
+    });
+
+    const newVersion = await VirtualEjsFileVersion.create({
+      fileId: next._id,
+      path: relPath,
+      content: version.content,
+      source: 'rollback',
+      description: `Rollback to ${versionId}`,
+      groupId: group._id,
+    });
+
+    await VirtualEjsGroupChange.updateOne({ _id: group._id }, { $set: { versionIds: [newVersion._id] } });
+
+    await createAuditEvent({
+      ...actor,
+      action: 'ejsVirtual.file.rollback',
+      entityType: 'VirtualEjsFile',
+      entityId: relPath,
+      before,
+      after: next.toObject(),
+      meta: { versionId },
+    });
+
+    ejsVirtualService.invalidateCacheForPath(relPath);
+
+    res.json({ file: next.toObject(), version: newVersion.toObject(), group: group.toObject() });
+  } catch (err) {
+    console.error('[adminEjsVirtual] rollback error', err);
+    res.status(500).json({ error: 'Failed to rollback' });
+  }
+};
+
+exports.vibe = async (req, res) => {
+  try {
+    const actor = getBasicAuthActor(req);
+    const viewsRoot = normalizeViewsRoot(req);
+
+    const { prompt, paths, providerKey, model } = req.body || {};
+
+    const result = await ejsVirtualService.vibeEdit({
+      prompt,
+      paths,
+      providerKey,
+      model,
+      viewsRoot,
+      actor,
+    });
+
+    res.json(result);
+  } catch (err) {
+    const code = err.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: err.message });
+    if (code === 'AI_INVALID') return res.status(500).json({ error: err.message });
+    console.error('[adminEjsVirtual] vibe error', err);
+    res.status(500).json({ error: 'Failed to run vibe edit', details: err.message });
+  }
+};
+
+exports.clearCache = async (req, res) => {
+  try {
+    const actor = getBasicAuthActor(req);
+    ejsVirtualService.clearCache();
+
+    await createAuditEvent({
+      ...actor,
+      action: 'ejsVirtual.cache.clear',
+      entityType: 'ejsVirtual',
+      entityId: null,
+      before: null,
+      after: { cleared: true },
+      meta: null,
+    });
+
+    res.json({ success: true });
+  } catch (err) {
+    console.error('[adminEjsVirtual] clearCache error', err);
+    res.status(500).json({ error: 'Failed to clear cache' });
+  }
+};