@intranefr/superbackend 1.4.3

package/src/services/email.service.js

@@ -0,0 +1,351 @@
+// Email service wrapper using Resend
+// Note: Resend package needs to be installed: npm install resend
+
+const GlobalSetting = require("../models/GlobalSetting");
+const EmailLog = require("../models/EmailLog");
+
+let resendClient = null;
+
+// Cache for settings
+const settingsCache = new Map();
+const CACHE_TTL = 60000; // 1 minute
+
+// Helper to get setting with cache
+const getSetting = async (key, defaultValue) => {
+  const cached = settingsCache.get(key);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+    return cached.value;
+  }
+
+  try {
+    const setting = await GlobalSetting.findOne({ key }).lean();
+    const value = setting ? setting.value : defaultValue;
+    settingsCache.set(key, { value, timestamp: Date.now() });
+    return value;
+  } catch (error) {
+    console.error(`Error fetching setting ${key}:`, error);
+    return defaultValue;
+  }
+};
+
+// Helper to replace template variables
+const replaceTemplateVars = (template, variables) => {
+  let result = template;
+  for (const [key, value] of Object.entries(variables)) {
+    const regex = new RegExp(`{{${key}}}`, "g");
+    result = result.replace(regex, value);
+  }
+  return result;
+};
+
+// Initialize Resend client if API key is available
+const initResend = async () => {
+  // Try to get API key from settings first, then fall back to env
+  const apiKey = await getSetting("RESEND_API_KEY", process.env.RESEND_API_KEY);
+
+  if (apiKey && !resendClient) {
+    try {
+      const { Resend } = require("resend");
+      resendClient = new Resend(apiKey);
+      console.log("✅ Resend email service initialized");
+    } catch (error) {
+      console.warn(
+        "⚠️  Resend package not installed. Email functionality will be simulated.",
+      );
+      console.warn("   Install with: npm install resend");
+    }
+  }
+};
+
+// Initialize on module load
+initResend().catch((err) => console.error("Error initializing Resend:", err));
+
+const sendEmail = async ({
+  to,
+  subject,
+  html,
+  text,
+  from,
+  userId,
+  type = "other",
+  metadata,
+}) => {
+  const defaultFrom =
+    from ||
+    (await getSetting(
+      "EMAIL_FROM",
+      process.env.EMAIL_FROM || "SaaSBackend <no-reply@resend.dev>",
+    ));
+  const toArray = Array.isArray(to) ? to : [to];
+
+  // If Resend is not configured, simulate email sending (for development)
+  if (!resendClient) {
+    console.log("📧 [SIMULATED EMAIL]");
+    console.log("   To:", toArray.join(", "));
+    console.log("   From:", defaultFrom);
+    console.log("   Subject:", subject);
+    console.log(
+      "   Body Preview:",
+      html ? html.substring(0, 100) + "..." : "No HTML",
+    );
+    console.log("   [Email would be sent in production with Resend API key]");
+
+    // Log simulated email
+    try {
+      await EmailLog.create({
+        userId,
+        to: toArray,
+        subject,
+        type,
+        status: "sent",
+        metadata: { ...metadata, simulated: true },
+      });
+    } catch (err) {
+      console.error("Error logging simulated email:", err.message);
+    }
+
+    return {
+      success: true,
+      simulated: true,
+      message: "Email simulated (Resend not configured)",
+    };
+  }
+
+  try {
+    const { data, error } = await resendClient.emails.send({
+      from: defaultFrom,
+      to: toArray,
+      subject,
+      html,
+      text,
+    });
+
+    if (error) {
+      console.error("❌ Email send error:", error);
+
+      // Log failure
+      await EmailLog.create({
+        userId,
+        to: toArray,
+        subject,
+        type,
+        status: "failed",
+        error: error.message,
+        metadata,
+      });
+
+      throw new Error(error.message || "Failed to send email");
+    }
+
+    console.log("✅ Email sent successfully:", data);
+
+    // Log success
+    await EmailLog.create({
+      userId,
+      to: toArray,
+      subject,
+      type,
+      providerId: data.id,
+      status: "sent",
+      metadata,
+    });
+
+    return {
+      success: true,
+      data,
+    };
+  } catch (error) {
+    console.error("❌ Error sending email:", error);
+
+    // Log failure (catch-all)
+    try {
+      await EmailLog.create({
+        userId,
+        to: toArray,
+        subject,
+        type,
+        status: "failed",
+        error: error.message,
+        metadata,
+      });
+    } catch (logErr) {
+      console.error("Error logging failed email:", logErr.message);
+    }
+
+    throw error;
+  }
+};
+
+const sendPasswordResetEmail = async (email, resetToken) => {
+  const frontendUrl = await getSetting(
+    "FRONTEND_URL",
+    process.env.FRONTEND_URL || "http://localhost:3000",
+  );
+  const resetUrl = `${frontendUrl}/reset-password?token=${resetToken}`;
+
+  // Try to get custom template from settings
+  const customTemplate = await getSetting("EMAIL_PASSWORD_RESET_HTML", null);
+
+  let html;
+  if (customTemplate) {
+    // Use custom template with variable replacement
+    html = replaceTemplateVars(customTemplate, { resetUrl });
+  } else {
+    // Use default template
+    html = `
+    <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
+      <h2>Password Reset Request</h2>
+      <p>Hello,</p>
+      <p>We received a request to reset your password.</p>
+      <p>Click the button below to reset your password:</p>
+      <div style="margin: 30px 0;">
+        <a href="${resetUrl}"
+           style="background-color: #4F46E5; color: white; padding: 12px 24px; text-decoration: none; border-radius: 5px; display: inline-block;">
+          Reset Password
+        </a>
+      </div>
+      <p>Or copy and paste this link into your browser:</p>
+      <p style="color: #666; word-break: break-all;">${resetUrl}</p>
+      <p><strong>This link will expire in 1 hour.</strong></p>
+      <p>If you didn't request a password reset, you can safely ignore this email.</p>
+    </div>
+  `;
+  }
+
+  const subject = await getSetting(
+    "EMAIL_PASSWORD_RESET_SUBJECT",
+    "Reset Your Password",
+  );
+
+  return sendEmail({
+    to: email,
+    subject,
+    html,
+    type: "password-reset",
+  });
+};
+
+const sendPasswordChangedEmail = async (email) => {
+  const html = `
+    <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
+      <h2>Password Changed Successfully</h2>
+      <p>Hello,</p>
+      <p>This is a confirmation that your account password has been changed successfully.</p>
+      <p>If you made this change, you can safely ignore this email.</p>
+      <p><strong>If you did not make this change, please contact our support team immediately.</strong></p>
+    </div>
+  `;
+
+  return sendEmail({
+    to: email,
+    subject: "Password Changed",
+    html,
+    type: "password-changed",
+  });
+};
+
+const sendAccountDeletionEmail = async (email) => {
+  const html = `
+    <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
+      <h2>Account Deleted</h2>
+      <p>Hello,</p>
+      <p>Your account has been successfully deleted as requested.</p>
+      <p>We're sorry to see you go.</p>
+    </div>
+  `;
+
+  return sendEmail({
+    to: email,
+    subject: "Account Deleted",
+    html,
+    type: "account-deleted",
+  });
+};
+
+const sendWelcomeEmail = async (email, name) => {
+  const html = `
+    <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
+      <h2>Welcome ${name}!</h2>
+      <p>Thank you for joining our service. We're excited to have you on board.</p>
+      <p>If you have any questions, feel free to reach out to our support team.</p>
+    </div>
+  `;
+
+  return sendEmail({
+    to: email,
+    subject: `Welcome ${name}!`,
+    html,
+    type: "welcome",
+  });
+};
+
+const sendNotificationEmail = async (email, title, message) => {
+  const html = `
+    <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
+      <h2>${title}</h2>
+      <p>${message}</p>
+    </div>
+  `;
+
+  return sendEmail({
+    to: email,
+    subject: `Notification: ${title}`,
+    html,
+    type: "notification",
+  });
+};
+
+const sendSubscriptionEmail = async (email, planName, status) => {
+  const html = `
+    <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
+      <h2>Subscription ${status}</h2>
+      <p>Plan: ${planName}</p>
+      <p>Status: ${status}</p>
+    </div>
+  `;
+
+  return sendEmail({
+    to: email,
+    subject: `Subscription ${status}`,
+    html,
+    type: "subscription",
+  });
+};
+
+const sendWaitingListEmail = async (email) => {
+  const html = `
+    <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
+      <h2>Welcome to our waiting list!</h2>
+      <p>Thanks for joining, ${email}!</p>
+      <p>We'll notify you as soon as a spot becomes available.</p>
+    </div>
+  `;
+
+  return sendEmail({
+    to: email,
+    subject: "Welcome to our waiting list!",
+    html,
+    type: "waiting-list",
+  });
+};
+
+const replaceTemplateVariables = (template, variables) => {
+  let result = template;
+  for (const [key, value] of Object.entries(variables)) {
+    const regex = new RegExp(`{{${key}}}`, "g");
+    result = result.replace(regex, value);
+  }
+  return result;
+};
+
+module.exports = {
+  sendEmail,
+  sendPasswordResetEmail,
+  sendPasswordChangedEmail,
+  sendAccountDeletionEmail,
+  sendWelcomeEmail,
+  sendNotificationEmail,
+  sendSubscriptionEmail,
+  sendWaitingListEmail,
+  replaceTemplateVariables,
+};

package/src/services/errorLogger.js

@@ -0,0 +1,221 @@
+const crypto = require('crypto');
+const os = require('os');
+
+const ErrorAggregate = require('../models/ErrorAggregate');
+
+const SENSITIVE_KEYS = [
+  'password',
+  'token',
+  'secret',
+  'authorization',
+  'cookie',
+  'apikey',
+  'api_key',
+  'accesstoken',
+  'refreshtoken',
+];
+
+async function getConfig() {
+  return {
+    errorTrackingEnabled: process.env.ERROR_TRACKING_ENABLED !== 'false',
+    errorMaxSamplesPerAggregate: parseInt(process.env.ERROR_MAX_SAMPLES, 10) || 20,
+    errorSampleRatePercent: parseInt(process.env.ERROR_SAMPLE_RATE_PERCENT, 10) || 100,
+    errorRateLimitPerMinute: parseInt(process.env.ERROR_RATE_LIMIT_PER_MINUTE, 10) || 30,
+    errorRateLimitAnonPerMinute: parseInt(process.env.ERROR_RATE_LIMIT_ANON_PER_MINUTE, 10) || 10,
+  };
+}
+
+function scrubValue(key, value) {
+  const lowerKey = String(key).toLowerCase();
+  for (const sensitive of SENSITIVE_KEYS) {
+    if (lowerKey.includes(sensitive)) {
+      return '[REDACTED]';
+    }
+  }
+  return value;
+}
+
+function scrubObject(obj, depth = 0) {
+  if (depth > 5 || !obj || typeof obj !== 'object') return obj;
+  if (Array.isArray(obj)) {
+    return obj.slice(0, 10).map((item) => scrubObject(item, depth + 1));
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === 'object' && value !== null) {
+      result[key] = scrubObject(value, depth + 1);
+    } else {
+      result[key] = scrubValue(key, value);
+    }
+  }
+  return result;
+}
+
+function normalizeMessage(message) {
+  if (!message) return '';
+  return String(message)
+    .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '<UUID>')
+    .replace(/[0-9a-f]{24}/gi, '<OBJECTID>')
+    .replace(/\b\d{4,}\b/g, '<NUM>')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 500);
+}
+
+function extractTopFrame(stack) {
+  if (!stack) return null;
+  const lines = String(stack).split('\n').slice(1, 4);
+  for (const line of lines) {
+    const match = line.match(/at\s+(?:(.+?)\s+)?\(?(.+?):(\d+):(\d+)\)?/);
+    if (match) {
+      const fn = match[1] || '<anonymous>';
+      const file = match[2].split('/').pop();
+      return `${fn}@${file}:${match[3]}`;
+    }
+  }
+  return null;
+}
+
+function computeFingerprint({ source, errorName, messageTemplate, topFrame, path, statusBucket }) {
+  const parts = [
+    source || 'unknown',
+    errorName || 'Error',
+    messageTemplate || '',
+    topFrame || '',
+    path || '',
+    statusBucket || '',
+  ];
+  const hash = crypto.createHash('sha256').update(parts.join('|')).digest('hex');
+  return hash.slice(0, 32);
+}
+
+function getStatusBucket(statusCode) {
+  if (!statusCode) return null;
+  if (statusCode >= 500) return '5xx';
+  if (statusCode >= 400) return '4xx';
+  if (statusCode >= 300) return '3xx';
+  return null;
+}
+
+function getTodayKey() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+let isLogging = false;
+
+async function logError(event) {
+  if (isLogging) return null;
+  isLogging = true;
+
+  try {
+    const config = await getConfig();
+    if (!config.errorTrackingEnabled) {
+      return null;
+    }
+
+    if (config.errorSampleRatePercent < 100) {
+      if (Math.random() * 100 > config.errorSampleRatePercent) {
+        return null;
+      }
+    }
+
+    const source = event.source || 'backend';
+    const errorName = event.errorName || event.name || 'Error';
+    const rawMessage = String(event.message || '').slice(0, 2000);
+    const messageTemplate = normalizeMessage(rawMessage);
+    const stack = String(event.stack || '').slice(0, 5000);
+    const topFrame = extractTopFrame(stack);
+    const path = event.request?.path || event.path || '';
+    const statusCode = event.request?.statusCode || event.statusCode;
+    const statusBucket = getStatusBucket(statusCode);
+
+    const fingerprint = computeFingerprint({
+      source,
+      errorName,
+      messageTemplate,
+      topFrame,
+      path,
+      statusBucket,
+    });
+
+    const sample = {
+      at: new Date(),
+      message: rawMessage,
+      stack,
+      actor: scrubObject({
+        userId: event.actor?.userId || event.userId,
+        role: event.actor?.role || event.role,
+        ip: event.actor?.ip || event.ip,
+        userAgent: event.actor?.userAgent || event.userAgent,
+      }),
+      request: scrubObject({
+        method: event.request?.method || event.method,
+        path,
+        statusCode,
+        requestId: event.request?.requestId || event.requestId,
+      }),
+      runtime: scrubObject({
+        ...(event.runtime || {}),
+        nodeVersion: process.version,
+        hostname: os.hostname(),
+      }),
+      extra: scrubObject(event.extra || {}),
+    };
+
+    const todayKey = getTodayKey();
+    const maxSamples = config.errorMaxSamplesPerAggregate;
+
+    const result = await ErrorAggregate.findOneAndUpdate(
+      { fingerprint },
+      {
+        $inc: { countTotal: 1, [`countsByDay.${todayKey}`]: 1 },
+        $set: { lastSeenAt: new Date() },
+        $setOnInsert: {
+          fingerprint,
+          source,
+          severity: event.severity || 'error',
+          errorName,
+          errorCode: event.errorCode || event.code,
+          messageTemplate,
+          topFrame,
+          httpStatusBucket: statusBucket,
+          firstSeenAt: new Date(),
+          status: 'open',
+        },
+        $push: {
+          samples: {
+            $each: [sample],
+            $slice: -maxSamples,
+          },
+        },
+      },
+      { upsert: true, new: true },
+    );
+
+    return result;
+  } catch (err) {
+    try {
+      console.log('[ErrorLogger] Failed to log error:', err.message);
+    } catch (e) {
+      // ignore
+    }
+    return null;
+  } finally {
+    isLogging = false;
+  }
+}
+
+function logErrorSync(event) {
+  setImmediate(() => {
+    logError(event).catch(() => {});
+  });
+}
+
+module.exports = {
+  logError,
+  logErrorSync,
+  getConfig,
+  scrubObject,
+  normalizeMessage,
+  computeFingerprint,
+};