@intranefr/superbackend 1.4.3

package/src/services/migrationAssets/index.js

@@ -0,0 +1,134 @@
+const objectStorage = require('../objectStorage.service');
+
+const { createFsLocalEndpoint } = require('./fsLocal');
+const { createS3Endpoint } = require('./s3');
+const { createSftpEndpoint } = require('./sftp');
+
+function normalizeType(raw) {
+  return String(raw || '').trim().toLowerCase();
+}
+
+async function resolveSourceEndpoint() {
+  const active = await objectStorage.getActiveBackend();
+  if (active === 's3') {
+    const cfg = await objectStorage.getS3Config();
+    if (!cfg) {
+      const err = new Error('Source S3 is not configured');
+      err.code = 'SOURCE_S3_NOT_CONFIGURED';
+      throw err;
+    }
+    return createS3Endpoint(cfg);
+  }
+
+  return createFsLocalEndpoint({ baseDir: process.env.UPLOAD_DIR || 'uploads' });
+}
+
+async function resolveTargetEndpointFromEnvConfig(envCfg) {
+  const target = envCfg?.assets?.target || null;
+  if (!target) return null;
+
+  const type = normalizeType(target.type);
+  if (type === 'fs_local') {
+    return createFsLocalEndpoint({ baseDir: target?.fs?.baseDir || process.env.UPLOAD_DIR || 'uploads' });
+  }
+  if (type === 'fs_remote') {
+    return createSftpEndpoint({
+      host: target?.ssh?.host,
+      port: target?.ssh?.port,
+      username: target?.ssh?.username,
+      privateKeyPem: target?.ssh?.privateKeyPem,
+      passphrase: target?.ssh?.passphrase,
+      baseDir: target?.ssh?.baseDir,
+    });
+  }
+  if (type === 's3') {
+    return createS3Endpoint({
+      endpoint: target?.s3?.endpoint,
+      region: target?.s3?.region,
+      bucket: target?.s3?.bucket,
+      accessKeyId: target?.s3?.accessKeyId,
+      secretAccessKey: target?.s3?.secretAccessKey,
+      forcePathStyle: target?.s3?.forcePathStyle,
+    });
+  }
+
+  const err = new Error('Unsupported assets target type');
+  err.code = 'UNSUPPORTED_ASSETS_TARGET';
+  throw err;
+}
+
+function normalizeKey(key) {
+  let s = String(key || '').trim();
+  while (s.startsWith('/')) s = s.slice(1);
+  if (s.startsWith('uploads/')) s = s.slice('uploads/'.length);
+  return s;
+}
+
+async function copyKeys({ keys, sourceEndpoint, targetEndpoint, dryRun = false, batchSize = 10 } = {}) {
+  const list = Array.isArray(keys) ? keys.map((k) => normalizeKey(k)).filter(Boolean) : [];
+
+  const result = {
+    ok: true,
+    requested: list.length,
+    copied: 0,
+    skipped: 0,
+    failed: [],
+    dryRun: Boolean(dryRun),
+    targetType: targetEndpoint?.type || null,
+    sourceType: sourceEndpoint?.type || null,
+    details: [],
+  };
+
+  for (let i = 0; i < list.length; i += batchSize) {
+    const slice = list.slice(i, i + batchSize);
+    await Promise.all(slice.map(async (key) => {
+      try {
+        const obj = await sourceEndpoint.getObject({ key });
+        if (!obj?.body) {
+          result.failed.push({
+            key,
+            error: 'Source object not found',
+            sourcePath: sourceEndpoint.describeKey ? sourceEndpoint.describeKey(key) : null,
+            targetPath: targetEndpoint.describeKey ? targetEndpoint.describeKey(key) : null,
+          });
+          result.ok = false;
+          return;
+        }
+        if (dryRun) {
+          result.skipped += 1;
+          result.details.push({
+            key,
+            status: 'skipped',
+            sourcePath: sourceEndpoint.describeKey ? sourceEndpoint.describeKey(key) : null,
+            targetPath: targetEndpoint.describeKey ? targetEndpoint.describeKey(key) : null,
+          });
+          return;
+        }
+        await targetEndpoint.putObject({ key, body: obj.body, contentType: obj.contentType || null });
+        result.copied += 1;
+        result.details.push({
+          key,
+          status: 'copied',
+          sourcePath: sourceEndpoint.describeKey ? sourceEndpoint.describeKey(key) : null,
+          targetPath: targetEndpoint.describeKey ? targetEndpoint.describeKey(key) : null,
+        });
+      } catch (e) {
+        result.failed.push({
+          key,
+          error: e?.message ? String(e.message) : 'Copy failed',
+          sourcePath: sourceEndpoint.describeKey ? sourceEndpoint.describeKey(key) : null,
+          targetPath: targetEndpoint.describeKey ? targetEndpoint.describeKey(key) : null,
+        });
+        result.ok = false;
+      }
+    }));
+  }
+
+  return result;
+}
+
+module.exports = {
+  resolveSourceEndpoint,
+  resolveTargetEndpointFromEnvConfig,
+  copyKeys,
+};

package/src/services/migrationAssets/s3.js

@@ -0,0 +1,75 @@
+async function createS3Endpoint({ endpoint, region, bucket, accessKeyId, secretAccessKey, forcePathStyle } = {}) {
+  const safeEndpoint = String(endpoint || '').trim();
+  const safeBucket = String(bucket || '').trim();
+  const safeAccessKeyId = String(accessKeyId || '').trim();
+  const safeSecret = String(secretAccessKey || '').trim();
+
+  if (!safeEndpoint || !safeBucket || !safeAccessKeyId || !safeSecret) {
+    const err = new Error('Invalid S3 endpoint config');
+    err.code = 'INVALID_S3_CONFIG';
+    throw err;
+  }
+
+  const { S3Client, HeadBucketCommand, CreateBucketCommand, PutObjectCommand, GetObjectCommand } = await import('@aws-sdk/client-s3');
+
+  const client = new S3Client({
+    endpoint: safeEndpoint,
+    region: String(region || 'us-east-1').trim() || 'us-east-1',
+    credentials: {
+      accessKeyId: safeAccessKeyId,
+      secretAccessKey: safeSecret,
+    },
+    forcePathStyle: Boolean(forcePathStyle),
+  });
+
+  async function ensureBucket() {
+    try {
+      await client.send(new HeadBucketCommand({ Bucket: safeBucket }));
+      return { ok: true, bucket: safeBucket, ensured: false };
+    } catch (e) {
+      const status = e?.$metadata?.httpStatusCode;
+      if (status !== 404 && e?.name !== 'NotFound') throw e;
+      await client.send(new CreateBucketCommand({ Bucket: safeBucket }));
+      return { ok: true, bucket: safeBucket, ensured: true };
+    }
+  }
+
+  return {
+    type: 's3',
+    endpoint: safeEndpoint,
+    bucket: safeBucket,
+
+    async testWritable() {
+      await ensureBucket();
+      const key = `__migration_test__/${Date.now()}_${Math.random().toString(16).slice(2)}`;
+      await client.send(new PutObjectCommand({ Bucket: safeBucket, Key: key, Body: Buffer.from('ok') }));
+      return { ok: true, bucket: safeBucket, endpoint: safeEndpoint };
+    },
+
+    async getObject({ key }) {
+      const response = await client.send(new GetObjectCommand({ Bucket: safeBucket, Key: key }));
+      const chunks = [];
+      for await (const chunk of response.Body) chunks.push(chunk);
+      return { body: Buffer.concat(chunks), contentType: response.ContentType || null };
+    },
+
+    async putObject({ key, body, contentType }) {
+      await ensureBucket();
+      await client.send(new PutObjectCommand({
+        Bucket: safeBucket,
+        Key: key,
+        Body: body,
+        ContentType: contentType || undefined,
+      }));
+      return { ok: true, bucket: safeBucket, key };
+    },
+
+    describeKey(key) {
+      return `s3://${safeBucket}/${key}`;
+    },
+  };
+}
+
+module.exports = {
+  createS3Endpoint,
+};

package/src/services/migrationAssets/sftp.js

@@ -0,0 +1,92 @@
+const path = require('path');
+
+async function createSftpEndpoint({ host, port, username, privateKeyPem, passphrase, baseDir } = {}) {
+  const safeHost = String(host || '').trim();
+  const safeUser = String(username || '').trim();
+  const safeKey = String(privateKeyPem || '').trim();
+  const safeBaseDir = String(baseDir || '').trim();
+
+  if (!safeHost || !safeUser || !safeKey || !safeBaseDir) {
+    const err = new Error('Invalid SFTP endpoint config');
+    err.code = 'INVALID_SFTP_CONFIG';
+    throw err;
+  }
+
+  const SftpClient = require('ssh2-sftp-client');
+  const client = new SftpClient();
+
+  const config = {
+    host: safeHost,
+    port: Number(port) || 22,
+    username: safeUser,
+    privateKey: safeKey,
+    passphrase: passphrase ? String(passphrase) : undefined,
+  };
+
+  async function connect() {
+    await client.connect(config);
+  }
+
+  async function end() {
+    try {
+      await client.end();
+    } catch (_) {
+      // ignore
+    }
+  }
+
+  function remotePath(key) {
+    return path.posix.join(safeBaseDir.replace(/\\/g, '/'), String(key || '').replace(/\\/g, '/'));
+  }
+
+  return {
+    type: 'fs_remote',
+    host: safeHost,
+    username: safeUser,
+    baseDir: safeBaseDir,
+
+    async testWritable() {
+      await connect();
+      try {
+        await client.mkdir(safeBaseDir, true);
+        const testKey = `.__migration_test__${Date.now()}_${Math.random().toString(16).slice(2)}`;
+        const p = path.posix.join(safeBaseDir.replace(/\\/g, '/'), testKey);
+        await client.put(Buffer.from('ok'), p);
+        await client.delete(p);
+        return { ok: true, host: safeHost, baseDir: safeBaseDir };
+      } finally {
+        await end();
+      }
+    },
+
+    async getObject({ key }) {
+      await connect();
+      try {
+        const buf = await client.get(remotePath(key));
+        const body = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
+        return { body, contentType: null };
+      } finally {
+        await end();
+      }
+    },
+
+    async putObject({ key, body }) {
+      await connect();
+      try {
+        await client.mkdir(path.posix.dirname(remotePath(key)), true);
+        await client.put(body, remotePath(key));
+        return { ok: true, key };
+      } finally {
+        await end();
+      }
+    },
+
+    describeKey(key) {
+      return remotePath(key);
+    },
+  };
+}
+
+module.exports = {
+  createSftpEndpoint,
+};

package/src/services/notification.service.js

@@ -0,0 +1,212 @@
+const Notification = require('../models/Notification');
+const User = require('../models/User');
+const emailService = require('./email.service');
+const crypto = require('crypto');
+
+async function createNotification({
+  userId,
+  type,
+  title,
+  message,
+  channel = 'in_app',
+  metadata = {},
+  sentByAdminId = null,
+  broadcastId = null,
+}) {
+  const notification = await Notification.create({
+    userId,
+    type,
+    title,
+    message,
+    channel,
+    metadata,
+    sentByAdminId,
+    broadcastId,
+    read: false,
+    emailStatus: channel === 'in_app' ? 'skipped' : 'pending',
+  });
+
+  return notification;
+}
+
+async function sendEmailForNotification(notification, userEmail) {
+  if (!notification || !userEmail) return notification;
+
+  if (notification.channel === 'in_app') {
+    return notification;
+  }
+
+  try {
+    const typeColors = {
+      info: '#3B82F6',
+      success: '#10B981',
+      warning: '#F59E0B',
+      error: '#EF4444',
+    };
+
+    const color = typeColors[notification.type] || '#6B7280';
+
+    await emailService.sendEmail({
+      to: userEmail,
+      subject: notification.title,
+      html: `
+        <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
+          <div style="border-left: 4px solid ${color}; padding-left: 16px; margin: 20px 0;">
+            <h2 style="margin: 0 0 10px 0; color: #1F2937;">${escapeHtml(notification.title)}</h2>
+            <p style="margin: 0; color: #4B5563; line-height: 1.6;">${escapeHtml(notification.message)}</p>
+          </div>
+          <p style="color: #9CA3AF; font-size: 12px; margin-top: 30px;">
+            This is an automated notification from your account.
+          </p>
+        </div>
+      `,
+      type: 'notification',
+      metadata: {
+        notificationId: notification._id.toString(),
+        notificationType: notification.type,
+      },
+    });
+
+    notification.emailStatus = 'sent';
+    notification.emailSentAt = new Date();
+    await notification.save();
+  } catch (error) {
+    console.error('Failed to send notification email:', error);
+    notification.emailStatus = 'failed';
+    await notification.save();
+  }
+
+  return notification;
+}
+
+function escapeHtml(str) {
+  return String(str || '')
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+async function sendToUser({
+  userId,
+  type,
+  title,
+  message,
+  channel = 'in_app',
+  metadata = {},
+  sentByAdminId = null,
+}) {
+  const user = await User.findById(userId).lean();
+  if (!user) {
+    throw new Error('User not found');
+  }
+
+  const notification = await createNotification({
+    userId,
+    type,
+    title,
+    message,
+    channel,
+    metadata,
+    sentByAdminId,
+  });
+
+  if (channel === 'email' || channel === 'both') {
+    await sendEmailForNotification(notification, user.email);
+  }
+
+  return notification;
+}
+
+async function sendToUsers({
+  userIds,
+  type,
+  title,
+  message,
+  channel = 'in_app',
+  metadata = {},
+  sentByAdminId = null,
+}) {
+  const broadcastId = crypto.randomBytes(12).toString('hex');
+  const results = [];
+
+  for (const userId of userIds) {
+    try {
+      const user = await User.findById(userId).lean();
+      if (!user) continue;
+
+      const notification = await createNotification({
+        userId,
+        type,
+        title,
+        message,
+        channel,
+        metadata,
+        sentByAdminId,
+        broadcastId,
+      });
+
+      if (channel === 'email' || channel === 'both') {
+        await sendEmailForNotification(notification, user.email);
+      }
+
+      results.push({ userId, success: true, notificationId: notification._id });
+    } catch (error) {
+      console.error(`Failed to send notification to user ${userId}:`, error);
+      results.push({ userId, success: false, error: error.message });
+    }
+  }
+
+  return { broadcastId, results };
+}
+
+async function broadcast({
+  type,
+  title,
+  message,
+  channel = 'in_app',
+  metadata = {},
+  sentByAdminId = null,
+  userFilter = {},
+}) {
+  const users = await User.find(userFilter).select('_id email').lean();
+  const userIds = users.map((u) => u._id);
+
+  return sendToUsers({
+    userIds,
+    type,
+    title,
+    message,
+    channel,
+    metadata,
+    sentByAdminId,
+  });
+}
+
+async function getNotificationStats() {
+  const [totalCount, unreadCount, emailPendingCount, emailSentCount, emailFailedCount] = await Promise.all([
+    Notification.countDocuments({}),
+    Notification.countDocuments({ read: false }),
+    Notification.countDocuments({ emailStatus: 'pending' }),
+    Notification.countDocuments({ emailStatus: 'sent' }),
+    Notification.countDocuments({ emailStatus: 'failed' }),
+  ]);
+
+  return {
+    total: totalCount,
+    unread: unreadCount,
+    emailPending: emailPendingCount,
+    emailSent: emailSentCount,
+    emailFailed: emailFailedCount,
+  };
+}
+
+module.exports = {
+  createNotification,
+  sendEmailForNotification,
+  sendToUser,
+  sendToUsers,
+  broadcast,
+  getNotificationStats,
+};