@intranefr/superbackend 1.4.3

package/src/controllers/adminUploadNamespaces.controller.js

@@ -0,0 +1,208 @@
+const GlobalSetting = require('../models/GlobalSetting');
+const Asset = require('../models/Asset');
+const uploadNamespacesService = require('../services/uploadNamespaces.service');
+const globalSettingsService = require('../services/globalSettings.service');
+
+const parseJson = (value) => {
+  if (!value) return {};
+  if (typeof value === 'object') return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return {};
+  }
+};
+
+exports.listNamespaces = async (req, res) => {
+  try {
+    const namespaces = await uploadNamespacesService.listNamespaces();
+    res.json(namespaces);
+  } catch (error) {
+    console.error('Error listing upload namespaces:', error);
+    res.status(500).json({ error: 'Failed to list upload namespaces' });
+  }
+};
+
+exports.getNamespacesSummary = async (req, res) => {
+  try {
+    let namespaces = await uploadNamespacesService.listNamespaces();
+
+    if (!namespaces.find((n) => n.key === 'default')) {
+      namespaces = [await uploadNamespacesService.resolveNamespace('default'), ...namespaces];
+    }
+
+    const stats = await Asset.aggregate([
+      { $match: { status: 'uploaded' } },
+      {
+        $group: {
+          _id: { $ifNull: ['$namespace', 'default'] },
+          totalFiles: { $sum: 1 },
+          totalBytes: { $sum: '$sizeBytes' },
+        },
+      },
+    ]);
+
+    const statsByNamespace = new Map(stats.map((s) => [String(s._id), s]));
+
+    const summary = namespaces
+      .slice()
+      .sort((a, b) => String(a.key).localeCompare(String(b.key)))
+      .map((ns) => {
+        const s = statsByNamespace.get(String(ns.key)) || { totalFiles: 0, totalBytes: 0 };
+        return {
+          key: ns.key,
+          enabled: ns.enabled !== false,
+          maxFileSizeBytes: ns.maxFileSizeBytes,
+          allowedContentTypes: ns.allowedContentTypes,
+          keyPrefix: ns.keyPrefix,
+          defaultVisibility: ns.defaultVisibility,
+          enforceVisibility: Boolean(ns.enforceVisibility),
+          stats: {
+            totalFiles: s.totalFiles || 0,
+            totalBytes: s.totalBytes || 0,
+          },
+        };
+      });
+
+    res.json(summary);
+  } catch (error) {
+    console.error('Error getting upload namespaces summary:', error);
+    res.status(500).json({ error: 'Failed to get upload namespaces summary' });
+  }
+};
+
+exports.getNamespace = async (req, res) => {
+  try {
+    const key = String(req.params.key || '').trim();
+    if (!key) {
+      return res.status(400).json({ error: 'key is required' });
+    }
+
+    const setting = await GlobalSetting.findOne({
+      key: uploadNamespacesService.getSettingKey(key),
+      type: 'json',
+    }).lean();
+
+    if (!setting) {
+      const resolved = await uploadNamespacesService.resolveNamespace(key);
+      return res.json(resolved);
+    }
+
+    const raw = parseJson(setting.value);
+    const normalized = uploadNamespacesService.normalizePayload(key, raw);
+    const merged = await uploadNamespacesService.resolveNamespace(key);
+
+    res.json({
+      ...merged,
+      ...normalized,
+      createdAt: setting.createdAt,
+      updatedAt: setting.updatedAt,
+    });
+  } catch (error) {
+    console.error('Error getting upload namespace:', error);
+    res.status(500).json({ error: 'Failed to get upload namespace' });
+  }
+};
+
+exports.createNamespace = async (req, res) => {
+  try {
+    const key = req.body?.key ? String(req.body.key).trim() : '';
+    if (!key) {
+      return res.status(400).json({ error: 'key is required' });
+    }
+
+    const existing = await GlobalSetting.findOne({ key: uploadNamespacesService.getSettingKey(key) }).lean();
+    if (existing) {
+      return res.status(409).json({ error: `Upload namespace '${key}' already exists` });
+    }
+
+    const normalized = uploadNamespacesService.normalizePayload(key, req.body || {});
+
+    const setting = await GlobalSetting.create({
+      key: uploadNamespacesService.getSettingKey(key),
+      type: 'json',
+      public: false,
+      description: `Upload namespace: ${key}`,
+      value: JSON.stringify(normalized),
+    });
+
+    globalSettingsService.clearSettingsCache();
+
+    const resolved = await uploadNamespacesService.resolveNamespace(key);
+    res.status(201).json({
+      ...resolved,
+      createdAt: setting.createdAt,
+      updatedAt: setting.updatedAt,
+    });
+  } catch (error) {
+    console.error('Error creating upload namespace:', error);
+    res.status(500).json({ error: 'Failed to create upload namespace' });
+  }
+};
+
+exports.updateNamespace = async (req, res) => {
+  try {
+    const key = String(req.params.key || '').trim();
+    if (!key) {
+      return res.status(400).json({ error: 'key is required' });
+    }
+
+    const settingKey = uploadNamespacesService.getSettingKey(key);
+    const existing = await GlobalSetting.findOne({ key: settingKey, type: 'json' });
+
+    const current = existing ? parseJson(existing.value) : {};
+    const mergedRaw = { ...current, ...req.body };
+    const normalized = uploadNamespacesService.normalizePayload(key, mergedRaw);
+
+    const setting = existing
+      ? await GlobalSetting.findOneAndUpdate(
+          { key: settingKey, type: 'json' },
+          { $set: { value: JSON.stringify(normalized) } },
+          { new: true }
+        )
+      : await GlobalSetting.create({
+          key: settingKey,
+          type: 'json',
+          public: false,
+          description: `Upload namespace: ${key}`,
+          value: JSON.stringify(normalized),
+        });
+
+    globalSettingsService.clearSettingsCache();
+
+    const resolved = await uploadNamespacesService.resolveNamespace(key);
+    res.json({
+      ...resolved,
+      createdAt: setting.createdAt,
+      updatedAt: setting.updatedAt,
+    });
+  } catch (error) {
+    console.error('Error updating upload namespace:', error);
+    res.status(500).json({ error: 'Failed to update upload namespace' });
+  }
+};
+
+exports.deleteNamespace = async (req, res) => {
+  try {
+    const key = String(req.params.key || '').trim();
+    if (!key) {
+      return res.status(400).json({ error: 'key is required' });
+    }
+
+    const setting = await GlobalSetting.findOneAndDelete({
+      key: uploadNamespacesService.getSettingKey(key),
+      type: 'json',
+    }).lean();
+
+    if (!setting) {
+      return res.status(404).json({ error: `Upload namespace '${key}' not found` });
+    }
+
+    globalSettingsService.clearSettingsCache();
+
+    res.json({ success: true });
+  } catch (error) {
+    console.error('Error deleting upload namespace:', error);
+    res.status(500).json({ error: 'Failed to delete upload namespace' });
+  }
+};

package/src/controllers/assets.controller.js

@@ -0,0 +1,248 @@
+const Asset = require('../models/Asset');
+const objectStorage = require('../services/objectStorage.service');
+const uploadNamespacesService = require('../services/uploadNamespaces.service');
+
+const buildPublicUrl = (key) => {
+  return `/public/assets/${key}`;
+};
+
+const formatAssetResponse = (asset) => {
+  const obj = asset.toObject ? asset.toObject() : asset;
+  const response = {
+    _id: obj._id,
+    key: obj.key,
+    originalName: obj.originalName,
+    contentType: obj.contentType,
+    sizeBytes: obj.sizeBytes,
+    visibility: obj.visibility,
+    status: obj.status,
+    createdAt: obj.createdAt,
+    updatedAt: obj.updatedAt
+  };
+
+  if (obj.visibility === 'public') {
+    response.publicUrl = buildPublicUrl(obj.key);
+  }
+
+  return response;
+};
+
+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 originalName = file.originalname || file.name;
+    const sizeBytes = buffer.length;
+
+    const namespaceKey = req.body?.namespace ? String(req.body.namespace).trim() : 'default';
+    const namespaceConfig = await uploadNamespacesService.resolveNamespace(namespaceKey);
+
+    const hardCapMaxFileSizeBytes = await uploadNamespacesService.getEffectiveHardCapMaxFileSizeBytes();
+
+    const validation = uploadNamespacesService.validateUpload({
+      namespaceConfig,
+      contentType,
+      sizeBytes,
+      hardCapMaxFileSizeBytes,
+    });
+
+    if (!validation.ok) {
+      return res.status(400).json({
+        error: 'Upload rejected by namespace policy',
+        namespace: namespaceConfig.key,
+        hardCapMaxFileSizeBytes,
+        errors: validation.errors,
+      });
+    }
+
+    const key = uploadNamespacesService.generateObjectKey({
+      namespaceConfig,
+      originalName,
+    });
+
+    const visibility = uploadNamespacesService.computeVisibility({
+      namespaceConfig,
+      requestedVisibility: req.body?.visibility,
+    });
+
+    const orgId = req.body.orgId || null;
+
+    const { provider, bucket } = await objectStorage.putObject({
+      key,
+      body: buffer,
+      contentType
+    });
+
+    const asset = await Asset.create({
+      key,
+      provider,
+      bucket,
+      originalName,
+      contentType,
+      sizeBytes,
+      visibility,
+      namespace: namespaceConfig.key,
+      visibilityEnforced: Boolean(namespaceConfig.enforceVisibility),
+      ownerUserId: req.user._id,
+      orgId,
+      status: 'uploaded'
+    });
+
+    res.status(201).json({ asset: formatAssetResponse(asset) });
+  } catch (error) {
+    console.error('Error uploading asset:', error);
+    res.status(500).json({ error: 'Failed to upload asset' });
+  }
+};
+
+exports.list = async (req, res) => {
+  try {
+    const page = Math.max(1, parseInt(req.query.page) || 1);
+    const limit = Math.min(100, Math.max(1, parseInt(req.query.limit) || 20));
+    const skip = (page - 1) * limit;
+
+    const filter = {
+      ownerUserId: req.user._id,
+      status: 'uploaded'
+    };
+
+    if (req.query.visibility) {
+      filter.visibility = req.query.visibility;
+    }
+
+    if (req.query.orgId) {
+      filter.orgId = req.query.orgId;
+    }
+
+    const [assets, total] = await Promise.all([
+      Asset.find(filter).sort({ createdAt: -1 }).skip(skip).limit(limit).lean(),
+      Asset.countDocuments(filter)
+    ]);
+
+    res.json({
+      assets: assets.map(formatAssetResponse),
+      pagination: {
+        page,
+        limit,
+        total,
+        pages: Math.ceil(total / limit)
+      }
+    });
+  } catch (error) {
+    console.error('Error listing assets:', error);
+    res.status(500).json({ error: 'Failed to list assets' });
+  }
+};
+
+exports.get = async (req, res) => {
+  try {
+    const asset = await Asset.findOne({
+      _id: req.params.id,
+      ownerUserId: req.user._id,
+      status: 'uploaded'
+    }).lean();
+
+    if (!asset) {
+      return res.status(404).json({ error: 'Asset not found' });
+    }
+
+    res.json({ asset: formatAssetResponse(asset) });
+  } catch (error) {
+    console.error('Error getting asset:', error);
+    res.status(500).json({ error: 'Failed to get asset' });
+  }
+};
+
+exports.download = async (req, res) => {
+  try {
+    const asset = await Asset.findOne({
+      _id: req.params.id,
+      ownerUserId: req.user._id,
+      status: 'uploaded'
+    }).lean();
+
+    if (!asset) {
+      return res.status(404).json({ error: 'Asset not found' });
+    }
+
+    const result = await objectStorage.getObject({ key: asset.key });
+
+    if (!result) {
+      return res.status(404).json({ error: 'File not found in storage' });
+    }
+
+    res.set('Content-Type', asset.contentType);
+    res.set('Content-Disposition', `attachment; filename="${asset.originalName}"`);
+    res.send(result.body);
+  } catch (error) {
+    console.error('Error downloading asset:', error);
+    res.status(500).json({ error: 'Failed to download asset' });
+  }
+};
+
+exports.delete = async (req, res) => {
+  try {
+    const asset = await Asset.findOne({
+      _id: req.params.id,
+      ownerUserId: req.user._id,
+      status: 'uploaded'
+    });
+
+    if (!asset) {
+      return res.status(404).json({ error: 'Asset not found' });
+    }
+
+    await objectStorage.deleteObject({ key: asset.key });
+
+    asset.status = 'deleted';
+    await asset.save();
+
+    res.json({ success: true });
+  } catch (error) {
+    console.error('Error deleting asset:', error);
+    res.status(500).json({ error: 'Failed to delete asset' });
+  }
+};
+
+exports.getPublicAsset = async (req, res) => {
+  try {
+    const key = req.params[0] || req.params.key;
+
+    if (!key) {
+      return res.status(400).json({ error: 'Asset key required' });
+    }
+
+    const asset = await Asset.findOne({
+      key,
+      visibility: 'public',
+      status: 'uploaded'
+    }).lean();
+
+    if (!asset) {
+      return res.status(404).json({ error: 'Asset not found' });
+    }
+
+    const result = await objectStorage.getObject({ key: asset.key });
+
+    if (!result) {
+      return res.status(404).json({ error: 'File not found in storage' });
+    }
+
+    res.set('Content-Type', asset.contentType);
+    res.set('Cache-Control', 'public, max-age=31536000');
+    res.send(result.body);
+  } catch (error) {
+    console.error('Error serving public asset:', error);
+    res.status(500).json({ error: 'Failed to serve asset' });
+  }
+};

package/src/controllers/auth.controller.js

@@ -0,0 +1,93 @@
+const User = require('../models/User');
+const { generateAccessToken, generateRefreshToken, verifyRefreshToken } = require('../utils/jwt');
+const asyncHandler = require('../utils/asyncHandler');
+
+// Register new user
+const register = asyncHandler(async (req, res) => {
+  const { email, password, name } = req.body;
+
+  if (!email || !password) {
+    return res.status(400).json({ error: 'Email and password are required' });
+  }
+
+  if (password.length < 6) {
+    return res.status(400).json({ error: 'Password must be at least 6 characters' });
+  }
+
+  const existingUser = await User.findOne({ email: email.toLowerCase() });
+  if (existingUser) {
+    return res.status(400).json({ error: 'Email already registered' });
+  }
+
+  const user = new User({
+    email: email.toLowerCase(),
+    passwordHash: password,
+    name
+  });
+
+  await user.save();
+
+  const token = generateAccessToken(user._id, user.role);
+  const refreshToken = generateRefreshToken(user._id);
+
+  res.status(201).json({
+    token,
+    refreshToken,
+    user: user.toJSON()
+  });
+});
+
+// Login user
+const login = asyncHandler(async (req, res) => {
+  const { email, password } = req.body;
+
+  if (!email || !password) {
+    return res.status(400).json({ error: 'Email and password are required' });
+  }
+
+  const user = await User.findOne({ email: email.toLowerCase() });
+  if (!user) {
+    return res.status(401).json({ error: 'Invalid email or password' });
+  }
+
+  const isMatch = await user.comparePassword(password);
+  if (!isMatch) {
+    return res.status(401).json({ error: 'Invalid email or password' });
+  }
+
+  const token = generateAccessToken(user._id, user.role);
+  const refreshToken = generateRefreshToken(user._id);
+
+  res.json({
+    token,
+    refreshToken,
+    user: user.toJSON()
+  });
+});
+
+// Refresh access token
+const refresh = asyncHandler(async (req, res) => {
+  const { refreshToken } = req.body;
+
+  if (!refreshToken) {
+    return res.status(400).json({ error: 'Refresh token required' });
+  }
+
+  const decoded = verifyRefreshToken(refreshToken);
+  const newToken = generateAccessToken(decoded.userId);
+  const newRefreshToken = generateRefreshToken(decoded.userId);
+
+  res.json({ token: newToken, refreshToken: newRefreshToken });
+});
+
+// Get current user
+const me = asyncHandler(async (req, res) => {
+  res.json({ user: req.user.toJSON() });
+});
+
+module.exports = {
+  register,
+  login,
+  refresh,
+  me
+};