@feardread/fear 1.2.1 → 2.0.0

package/controllers/auth/password.js

@@ -0,0 +1,237 @@
+const crypto = require('crypto');
+const User = require('../../models/user');
+//const { validateMongoDbId } = require('../utils/validateMongoDbId');
+
+// Response helper
+const response = {
+    success: (res, data, statusCode = 200, message = "Operation successful") => {
+        return res.status(statusCode).json({
+            success: true,
+            message,
+            data
+        });
+    },
+
+    error: (res, statusCode, message, error = null) => {
+        const responseObj = { success: false, message };
+        if (error && process.env.NODE_ENV === "development") {
+            responseObj.error = error;
+        }
+        return res.status(statusCode).json(responseObj);
+    }
+};
+
+// Update password for authenticated user
+exports.updatePassword = (req, res) => {
+    const { _id } = req.user;
+    const { currentPassword, newPassword } = req.body;
+
+    //validateMongoDbId(_id);
+
+    if (!currentPassword || !newPassword) {
+        return response.error(res, 400, 'Current password and new password are required');
+    }
+
+    User.findById(_id)
+        .then((user) => {
+            if (!user) {
+                return response.error(res, 404, 'User not found');
+            }
+
+            // Verify current password
+            return user.isPasswordMatched(currentPassword)
+                .then((isMatch) => {
+                    if (!isMatch) {
+                        return response.error(res, 401, 'Current password is incorrect');
+                    }
+
+                    user.password = newPassword;
+                    return user.save();
+                })
+                .then((updatedUser) => {
+                    // Send confirmation email
+                    const mailService = req.app.get('mailService');
+                    
+                    return mailService.sendEmail({
+                        to: updatedUser.email,
+                        subject: 'Password Changed Successfully',
+                        html: mailService.templates.passwordResetSuccessTemplate(updatedUser.email),
+                        text: mailService.templates.generatePlainText({ email: updatedUser.email }, 'passwordResetSuccess')
+                    })
+                    .then(() => {
+                        const userResponse = updatedUser.toJSON();
+                        return response.success(res, { user: userResponse }, 200, 'Password updated successfully');
+                    })
+                    .catch((emailError) => {
+                        // Log error but don't fail the password update
+                        console.error('Failed to send confirmation email:', emailError);
+                        const userResponse = updatedUser.toJSON();
+                        return response.success(res, { user: userResponse }, 200, 'Password updated successfully');
+                    });
+                });
+        })
+        .catch((error) => {
+            return response.error(res, 500, 'Error updating password', error.message);
+        });
+};
+
+// Request password reset token
+exports.forgotPasswordToken = (req, res) => {
+    const { email } = req.body;
+
+    if (!email) {
+        return response.error(res, 400, 'Email is required');
+    }
+
+    User.findOne({ email })
+        .then((user) => {
+            if (!user) {
+                return response.error(res, 404, 'User not found with this email');
+            }
+
+            // Create reset token
+            return user.createPasswordResetToken()
+                .then((token) => {
+                    return user.save()
+                        .then(() => ({ user, token }));
+                });
+        })
+        .then(({ user, token }) => {
+            // Construct reset URL
+            const resetURL = `${req.protocol}://${req.get('host')}/reset-password/${token}`;
+
+            // Send email
+            const mailService = req.app.get('mailService');
+            
+            return mailService.sendEmail({
+                to: user.email,
+                subject: 'Password Reset Request',
+                html: mailService.templates.passwordResetTemplate(resetURL, user.email),
+                text: mailService.templates.generatePlainText({ resetURL, email: user.email }, 'passwordReset')
+            })
+            .then(() => {
+                return response.success(
+                    res,
+                    {
+                        message: 'Password reset link sent to email',
+                        expiresIn: '10 minutes'
+                    },
+                    200,
+                    'Password reset email sent successfully'
+                );
+            })
+            .catch((emailError) => {
+                // Clear reset token if email fails
+                user.passwordResetToken = undefined;
+                user.passwordResetExpires = undefined;
+                return user.save()
+                    .then(() => {
+                        return response.error(res, 500, 'Error sending password reset email', emailError.message);
+                    });
+            });
+        })
+        .catch((error) => {
+            return response.error(res, 500, 'Error processing password reset request', error.message);
+        });
+};
+
+// Reset password with token
+exports.resetPassword = (req, res) => {
+    const { password } = req.body;
+    const { token } = req.params;
+
+    if (!password) {
+        return response.error(res, 400, 'New password is required');
+    }
+
+    if (!token) {
+        return response.error(res, 400, 'Reset token is required');
+    }
+
+    const hashedToken = crypto.createHash("sha256").update(token).digest("hex");
+
+    User.findOne({
+        passwordResetToken: hashedToken,
+        passwordResetExpires: { $gt: Date.now() }
+    })
+        .then((user) => {
+            if (!user) {
+                return response.error(res, 400, 'Token expired or invalid. Please try again');
+            }
+
+            // Update password and clear reset token
+            user.password = password;
+            user.passwordResetToken = undefined;
+            user.passwordResetExpires = undefined;
+
+            return user.save();
+        })
+        .then((updatedUser) => {
+            // Send confirmation email
+            const mailService = req.app.get('mailService');
+
+            return mailService.sendEmail({
+                to: updatedUser.email,
+                subject: 'Password Changed Successfully',
+                html: mailService.templates.passwordResetSuccessTemplate(updatedUser.email),
+                text: mailService.templates.generatePlainText({ email: updatedUser.email }, 'passwordResetSuccess')
+            })
+            .then(() => {
+                const userResponse = updatedUser.toJSON();
+                return response.success(
+                    res,
+                    { user: userResponse },
+                    200,
+                    'Password reset successfully'
+                );
+            })
+            .catch((emailError) => {
+                // Log error but don't fail the password reset
+                console.error('Failed to send confirmation email:', emailError);
+                const userResponse = updatedUser.toJSON();
+                return response.success(
+                    res,
+                    { user: userResponse },
+                    200,
+                    'Password reset successfully'
+                );
+            });
+        })
+        .catch((error) => {
+            return response.error(res, 500, 'Error resetting password', error.message);
+        });
+};
+
+// Verify reset token validity (optional)
+exports.verifyResetToken = (req, res) => {
+    const { token } = req.params;
+
+    if (!token) {
+        return response.error(res, 400, 'Reset token is required');
+    }
+
+    const hashedToken = crypto.createHash("sha256").update(token).digest("hex");
+
+    User.findOne({
+        passwordResetToken: hashedToken,
+        passwordResetExpires: { $gt: Date.now() }
+    })
+        .then((user) => {
+            if (!user) {
+                return response.error(res, 400, 'Token expired or invalid');
+            }
+
+            return response.success(
+                res,
+                {
+                    valid: true,
+                    email: user.email.replace(/(.{2})(.*)(@.*)/, '$1***$3') // Partially masked email
+                },
+                200,
+                'Token is valid'
+            );
+        })
+        .catch((error) => {
+            return response.error(res, 500, 'Error verifying token', error.message);
+        });
+};

package/controllers/order.js

@@ -7,7 +7,6 @@ exports.getMyOrders = async (req, res) => {
       const orders = await Order.find({ user: _id })
         .populate("user")
         .populate("orderItems.product")
-        .populate("orderItems.color");
       res.json({
         orders,
       });

package/controllers/payment.js

@@ -1,148 +1,11 @@
-const Razorpay = require("razorpay");
-const paypal = require("@paypal/checkout-server-sdk");
-const Payment = require("../models/payment");
+const Payment = require('../models/payment');
 const methods = require("./crud");
 
-const instance = new Razorpay({
-  key_id: "rzp_test_HSSeDI22muUrLR",
-  key_secret: "sRO0YkBxvgMg0PvWHJN16Uf7",
-});
 
-// Razorpay instance
-const razorpayInstance = new Razorpay({
-  key_id: "rzp_test_HSSeDI22muUrLR",
-  key_secret: "sRO0YkBxvgMg0PvWHJN16Uf7",
-});
-
-// PayPal environment setup
-const paypalEnvironment = () => {
-  const clientId = process.env.PAYPAL_CLIENT_ID || "YOUR_PAYPAL_CLIENT_ID";
-  const clientSecret = process.env.PAYPAL_CLIENT_SECRET || "YOUR_PAYPAL_CLIENT_SECRET";
-  
-  // Use sandbox for testing, live for production
-  return new paypal.core.SandboxEnvironment(clientId, clientSecret);
-  // For production: return new paypal.core.LiveEnvironment(clientId, clientSecret);
-};
-
-const paypalClient = () => {
-  return new paypal.core.PayPalHttpClient(paypalEnvironment());
-};
-
-exports.checkout = async (req, res) => {
-  try {
-    const { amount } = req.body;
-    const option = {
-      amount: amount * 100,
-      currency: "INR",
-    };
-    const order = await razorpayInstance.orders.create(option);
-    res.json({
-      success: true,
-      order,
-    });
-  } catch (error) {
-    res.status(500).json({
-      success: false,
-      message: "Error creating Razorpay order",
-      error: error.message,
-    });
-  }
-};
-
-exports.paymentVerification = async (req, res) => {
-  try {
-    const { razorpayOrderId, razorpayPaymentId, razorpaySignature } = req.body;
-    
-    // Verify signature for security
-    const crypto = require("crypto");
-    const generatedSignature = crypto
-      .createHmac("sha256", "sRO0YkBxvgMg0PvWHJN16Uf7")
-      .update(`${razorpayOrderId}|${razorpayPaymentId}`)
-      .digest("hex");
-    
-    if (generatedSignature === razorpaySignature) {
-      res.json({
-        success: true,
-        razorpayOrderId,
-        razorpayPaymentId,
-        verified: true,
-      });
-    } else {
-      res.status(400).json({
-        success: false,
-        message: "Payment verification failed",
-      });
-    }
-  } catch (error) {
-    res.status(500).json({
-      success: false,
-      message: "Error verifying payment",
-      error: error.message,
-    });
-  }
-};
-
-// ============ PAYPAL METHODS ============
-
-const createPayPalOrder = async (req, res) => {
-  try {
-    const { amount, currency = "USD" } = req.body;
-    
-    const request = new paypal.orders.OrdersCreateRequest();
-    request.prefer("return=representation");
-    request.requestBody({
-      intent: "CAPTURE",
-      purchase_units: [{
-        amount: {
-          currency_code: currency,
-          value: amount.toString(),
-        },
-      }],
-    });
-    
-    const order = await paypalClient().execute(request);
-    
-    res.json({
-      success: true,
-      orderId: order.result.id,
-      order: order.result,
-    });
-  } catch (error) {
-    res.status(500).json({
-      success: false,
-      message: "Error creating PayPal order",
-      error: error.message,
-    });
-  }
-};
-
-const capturePayPalOrder = async (req, res) => {
-  try {
-    const { orderId } = req.body;
-    
-    const request = new paypal.orders.OrdersCaptureRequest(orderId);
-    request.requestBody({});
-    
-    const capture = await paypalClient().execute(request);
-    
-    res.json({
-      success: true,
-      captureId: capture.result.id,
-      status: capture.result.status,
-      capture: capture.result,
-    });
-  } catch (error) {
-    res.status(500).json({
-      success: false,
-      message: "Error capturing PayPal order",
-      error: error.message,
-    });
-  }
-};
-
-const crud = methods.crudController( Payment );
-for(prop in crud) {
-  if(crud.hasOwnProperty(prop)) {
+// Extend with CRUD methods
+const crud = methods.crudController(Payment);
+for (const prop in crud) {
+  if (crud.hasOwnProperty(prop)) {
     module.exports[prop] = crud[prop];
   }
 }

package/libs/db/index.js

@@ -41,6 +41,11 @@ class DatabaseManager {
       await this.close();
       process.exit(0);
     });
+
+    process.on('UnhandledRejection', async (promise, reson) => {
+      console.log('Unhandled Rejection at ', reason);
+      await this.close();
+    })
   }
 
   /**

package/libs/emailer/info.js

@@ -1,41 +1,29 @@
 require("dotenv").config({ path: "backend/.env" });
 
 module.exports = {
-  "smtp": {
-    "service": process.env.SMTP_SERVICE,
-    "host": process.env.SMTP_HOST,
-    "port": process.env.SMTP_PORT,
-    "auth": {
-      "user": process.env.SMTP_MAIL,
-      "pass": process.env.SMTP_PASS
-    },
-    "apps": {
-      "gfolio": {
-        "auth": {
-          "user": process.env.SMTP_MAIL,
-          "pass": process.env.SMTP_PASS
-        },
-      },
-      "gdrea": {
-        "auth": {
-          "user": process.env.SMTP_MAIL,
-          "pass": process.env.SMTP_PASS
-        },
-      },
-      "jbird": {
-        "auth": {
-          "user": process.env.SMTP_MAIL,
-          "pass": process.env.SMTP_PASS
-        },
-      },
-    }
+  mailgun: {
+    domain: "fear.dedyn.io",
+    region: 'US',
+    apikey: process.env.MG_API_KEY,
+    sandbox: "sandbox933b4315c0164f209bbf0bc7fb908598.mailgun.org"
   },
-  "imap": {
-    "host": "mail.mydomain.com",
-    "port": 999,
-    "auth": {
-      "user": "user@domain.com",
-      "pass": "xxx"
+  smtp: {
+    secure: process.env.SMTP_SECURE === 'true',
+    mailgun: {
+      host: process.env.MG_SMTP_HOST,
+      port: parseInt(process.env.SMTP_PORT),
+      auth: {
+        user: process.env.MG_SMTP_USER,
+        pass: process.env.MG_SMTP_PASS
+      }
+    },
+    google: {
+      host: process.env.GOOGLE_SMTP_HOST,
+      port: parseInt(process.env.SMTP_PORT),
+      auth: {
+        user: process.env.GOOGLE_SMTP_USER,
+        pass: process.env.GOOGLE_SMTP_PASS
+      }
     }
   }
 }