@feardread/fear 1.1.4 → 1.1.6

package/controllers/payment.js

@@ -1,31 +1,191 @@
 const Razorpay = require("razorpay");
+const paypal = require("@paypal/checkout-server-sdk");
+const Payment = require("../models/payment");
+const methods = require("./crud");
+
 const instance = new Razorpay({
   key_id: "rzp_test_HSSeDI22muUrLR",
   key_secret: "sRO0YkBxvgMg0PvWHJN16Uf7",
 });
 
-const checkout = async (req, res) => {
-  const { amount } = req.body;
-  const option = {
-    amount: amount * 100,
-    currency: "INR",
-  };
-  const order = await instance.orders.create(option);
-  res.json({
-    success: true,
-    order,
-  });
+// 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 paymentVerification = async (req, res) => {
-  const { razorpayOrderId, razorpayPaymentId } = req.body;
-  res.json({
-    razorpayOrderId,
-    razorpayPaymentId,
-  });
+const paypalClient = () => {
+  return new paypal.core.PayPalHttpClient(paypalEnvironment());
 };
 
-module.exports = {
-  checkout,
-  paymentVerification,
+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,
+    });
+  }
+};
+
+exports.createStripePayment = async (req, res) => {
+   try {
+    const { paymentMethodId, amount, currency } = req.body;
+
+    // Create a PaymentIntent
+    const paymentIntent = await stripe.paymentIntents.create({
+      amount: amount,
+      currency: currency || 'usd',
+      payment_method: paymentMethodId,
+      confirmation_method: 'manual',
+      confirm: true,
+      return_url: 'https://your-site.com/payment-success',
+    });
+
+    res.json({
+      clientSecret: paymentIntent.client_secret,
+      status: paymentIntent.status,
+    });
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+};
+exports.saveStripePayment = async (req, res) => {
+  try {
+    const { paymentMethodId, customerId } = req.body;
+
+    // Attach payment method to customer
+    await stripe.paymentMethods.attach(paymentMethodId, {
+      customer: customerId,
+    });
+
+    // Set as default payment method
+    await stripe.customers.update(customerId, {
+      invoice_settings: {
+        default_payment_method: paymentMethodId,
+      },
+    });
+
+    res.json({ success: true });
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+}
+// ============ PAYPAL METHODS ============
+
+exports.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,
+    });
+  }
+};
+
+exports.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)) {
+    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/validator/index.js

@@ -52,7 +52,7 @@ exports.input = {
    * @returns {object} Validation result
    */
   register: (data) => {
-    const { email, password, firstname, lastname, name } = data;
+    const { email, password, firstName, lastName, displayName } = data;
 
     if (!email) return { isValid: false, message: "Email is required" };
     if (!exports.input.email(email)) return { isValid: false, message: "Please provide a valid email address" };
@@ -60,7 +60,7 @@ exports.input = {
     const passwordValidation = exports.input.password(password);
     if (!passwordValidation.isValid) return passwordValidation;
 
-    const fullName = firstname && lastname ? `${firstname} ${lastname}` : name;
+    const fullName = (displayName) ? displayName : `${firstName} ${lastName}`;
     if (!fullName) return { isValid: false, message: "Name is required" };
 
     return { isValid: true, name: fullName };

package/models/address.js

@@ -0,0 +1,37 @@
+const mongoose = require('mongoose');
+
+const addressSchema = new mongoose.Schema({
+  userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true, index: true },
+  type: { type: String, enum: ['home', 'work', 'billing', 'shipping', 'other'], default: 'billing' },
+  isDefault: { type: Boolean, default: false },
+  name: { type: String, trim: true, maxlength: 50 },
+  line1: { type: String, required: true, trim: true },
+  line2: { type: String, trim: true },
+  city: { type: String, required: true, trim: true },
+  state: { type: String, required: true, trim: true },
+  postalCode: { type: String, required: true, trim: true },
+  country: { type: String, required: true, default: 'US', uppercase: true },
+  coordinates: { type: { type: String, enum: ['Point'], default: 'Point' },
+    coordinates: { type: [Number], default: [0, 0] }},
+  phoneNumber: { type: String, trim: true },
+  deliveryInstructions: { type: String, trim: true, maxlength: 500 }
+}, {
+  timestamps: true
+});
+
+// Indexes
+addressSchema.index({ userId: 1, isDefault: 1 });
+addressSchema.index({ coordinates: '2dsphere' });
+
+// Ensure only one default address per user
+addressSchema.pre('save', async function(next) {
+  if (this.isDefault) {
+    await this.constructor.updateMany(
+      { userId: this.userId, _id: { $ne: this._id } },
+      { $set: { isDefault: false } }
+    );
+  }
+  next();
+});
+
+module.exports = mongoose.model('Address', addressSchema);

package/models/order.js

@@ -1,88 +1,116 @@
-const mongoose = require("mongoose"); // Erase if already required
+const mongoose = require("mongoose");
 
-// Declare the Schema of the Mongo model
-var orderSchema = new mongoose.Schema(
+const orderItemSchema = new mongoose.Schema({
+  productId: {  type: mongoose.Schema.Types.ObjectId, ref: "Product", required: true },
+  title: { type: String,  required: true, },
+  quantity: { type: Number, required: true, min: 1, },
+  price: { type: Number, required: true, },
+  discount: { type: Number,  default: 0, },
+  tax: { type: Number, default: 0, },
+  subtotal: { type: Number, required: true, },
+  image: String,
+  sku: String,
+  attributes: { type: Map, of: String, },
+});
+
+const orderSchema = new mongoose.Schema(
   {
-    user: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
+    orderNumber: { type: String, unique: true, required: true, },
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: true, index: true, },
+    items: [orderItemSchema],
+    subtotal: {  type: Number, required: true },
+    discount: { type: Number, default: 0, },
+    tax: { type: Number, default: 0, },
+    shippingCost: { type: Number, default: 0, },
+    total: { type: Number, required: true, },
+    currency: { type: String,  default: "INR", enum: ["INR", "USD", "EUR", "GBP"], },
+    paymentMethod: { type: String, enum: ["razorpay", "paypal", "card", "upi", "netbanking", "cod"], required: true, },
+    paymentStatus: {
+      type: String,
+      enum: ["pending", "processing", "completed", "failed", "refunded", "partially_refunded"],
+      default: "pending",
+      index: true,
     },
-    shippingInfo: {
-      firstname: {
-        type: String,
-        required: true,
-      },
-      lastname: {
-        type: String,
-        required: true,
-      },
-      address: {
-        type: String,
-        required: true,
-      },
-      city: {
-        type: String,
-        required: true,
-      },
-      state: {
-        type: String,
-        required: true,
-      },
-      other: {
-        type: String,
-      },
-      pincode: {
-        type: Number,
-        required: true,
+    paymentDetails: {
+      // Razorpay
+      razorpayOrderId: String,
+      razorpayPaymentId: String,
+      razorpaySignature: String,
+      
+      // PayPal
+      paypalOrderId: String,
+      paypalCaptureId: String,
+      
+      // Common
+      transactionId: String,
+      paymentMethodId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "PaymentMethod",
       },
+      paidAt: Date,
     },
-    paymentInfo: {
-      razorpayOrderId: {
-        type: String,
-        required: true,
-      },
-      razorpayPaymentId: {
-        type: String,
-        required: true,
-      },
+    orderStatus: {
+      type: String,
+      enum: [
+        "pending",
+        "confirmed",
+        "processing",
+        "shipped",
+        "out_for_delivery",
+        "delivered",
+        "cancelled",
+        "returned",
+        "refunded"
+      ],
+      default: "pending",
+      index: true,
     },
-    orderItems: [
+    shippingAddress: { type: mongoose.Schema.Types.ObjectId, ref: "Address", required: true, },
+    billingAddress: { type: mongoose.Schema.Types.ObjectId, ref: "Address", required: true, },
+    shippingProvider: String,
+    trackingNumber: String,
+    estimatedDeliveryDate: Date,
+    actualDeliveryDate: Date,
+    statusHistory: [
       {
-        product: {
-          type: mongoose.Schema.Types.ObjectId,
-          ref: "Product",
-          required: true,
+        status: String,
+        timestamp: {
+          type: Date,
+          default: Date.now,
         },
-        quantity: {
-          type: Number,
-          required: true,
-        },
-        price: {
-          type: Number,
-          required: true,
+        note: String,
+        updatedBy: {
+          type: mongoose.Schema.Types.ObjectId,
+          ref: "User",
         },
       },
     ],
-    paidAt: {
-      type: Date,
-      default: Date.now(),
-    },
-    month: {
+    couponCode: String,
+    couponDiscount: {
       type: Number,
-      default: new Date().getMonth(),
+      default: 0,
     },
-    totalPrice: {
-      type: Number,
-      required: true,
-    },
-    totalPriceAfterDiscount: {
-      type: Number,
-      required: true,
+    customerNote: String,
+    internalNote: String,
+    cancellationReason: String,
+    cancelledAt: Date,
+    cancelledBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
     },
-    orderStatus: {
+    returnReason: String,
+    returnedAt: Date,
+    refundAmount: Number,
+    refundStatus: {
       type: String,
-      default: "Ordered",
+      enum: ["none", "pending", "processing", "completed", "failed"],
+      default: "none",
+    },
+    refundedAt: Date,
+    refundTransactionId: String,
+    metadata: {
+      type: Map,
+      of: mongoose.Schema.Types.Mixed,
     },
   },
   {
@@ -90,5 +118,154 @@ var orderSchema = new mongoose.Schema(
   }
 );
 
-//Export the model
-module.exports = mongoose.model("Order", orderSchema);
+// Indexes for better query performance
+orderSchema.index({ orderNumber: 1 });
+orderSchema.index({ userId: 1, createdAt: -1 });
+orderSchema.index({ orderStatus: 1, createdAt: -1 });
+orderSchema.index({ paymentStatus: 1 });
+orderSchema.index({ "paymentDetails.razorpayOrderId": 1 });
+orderSchema.index({ "paymentDetails.paypalOrderId": 1 });
+orderSchema.index({ trackingNumber: 1 });
+orderSchema.index({ shippingAddress: 1 });
+orderSchema.index({ billingAddress: 1 });
+
+// Pre-save middleware to generate order number
+orderSchema.pre("save", async function (next) {
+  if (!this.orderNumber) {
+    const timestamp = Date.now().toString(36).toUpperCase();
+    const random = Math.random().toString(36).substring(2, 7).toUpperCase();
+    this.orderNumber = `ORD-${timestamp}-${random}`;
+  }
+  next();
+});
+
+// Pre-save middleware to add status history
+orderSchema.pre("save", function (next) {
+  if (this.isModified("orderStatus")) {
+    this.statusHistory.push({
+      status: this.orderStatus,
+      timestamp: new Date(),
+    });
+  }
+  next();
+});
+
+// Static method to get orders by user
+orderSchema.statics.getUserOrders = async function (userId, options = {}) {
+  const { status, limit = 10, skip = 0 } = options;
+  const query = { userId };
+  
+  if (status) {
+    query.orderStatus = status;
+  }
+  
+  return await this.find(query)
+    .sort({ createdAt: -1 })
+    .limit(limit)
+    .skip(skip)
+    .populate("items.productId", "name images")
+    .populate("paymentDetails.paymentMethodId")
+    .populate("shippingAddress")
+    .populate("billingAddress");
+};
+
+// Static method to get order statistics
+orderSchema.statics.getOrderStats = async function (userId) {
+  const stats = await this.aggregate([
+    { $match: { userId: mongoose.Types.ObjectId(userId) } },
+    {
+      $group: {
+        _id: "$orderStatus",
+        count: { $sum: 1 },
+        totalAmount: { $sum: "$total" },
+      },
+    },
+  ]);
+  
+  return stats;
+};
+
+// Instance method to mark as paid
+orderSchema.methods.markAsPaid = async function (paymentInfo) {
+  this.paymentStatus = "completed";
+  this.paymentDetails = {
+    ...this.paymentDetails,
+    ...paymentInfo,
+    paidAt: new Date(),
+  };
+  this.orderStatus = "confirmed";
+  return await this.save();
+};
+
+// Instance method to update order status
+orderSchema.methods.updateStatus = async function (status, note, updatedBy) {
+  this.orderStatus = status;
+  this.statusHistory.push({
+    status,
+    timestamp: new Date(),
+    note,
+    updatedBy,
+  });
+  
+  // Update specific dates based on status
+  if (status === "delivered") {
+    this.actualDeliveryDate = new Date();
+  } else if (status === "cancelled") {
+    this.cancelledAt = new Date();
+    this.cancelledBy = updatedBy;
+  } else if (status === "returned") {
+    this.returnedAt = new Date();
+  }
+  
+  return await this.save();
+};
+
+// Instance method to process refund
+orderSchema.methods.processRefund = async function (amount, transactionId) {
+  this.refundAmount = amount || this.total;
+  this.refundStatus = "completed";
+  this.refundedAt = new Date();
+  this.refundTransactionId = transactionId;
+  this.paymentStatus = amount >= this.total ? "refunded" : "partially_refunded";
+  this.orderStatus = "refunded";
+  return await this.save();
+};
+
+// Instance method to add tracking information
+orderSchema.methods.addTracking = async function (provider, trackingNumber, estimatedDelivery) {
+  this.shippingProvider = provider;
+  this.trackingNumber = trackingNumber;
+  this.estimatedDeliveryDate = estimatedDelivery;
+  this.orderStatus = "shipped";
+  return await this.save();
+};
+
+// Virtual for order age in days
+orderSchema.virtual("orderAge").get(function () {
+  return Math.floor((Date.now() - this.createdAt) / (1000 * 60 * 60 * 24));
+});
+
+// Virtual for items count
+orderSchema.virtual("itemsCount").get(function () {
+  return this.items.reduce((total, item) => total + item.quantity, 0);
+});
+
+// Virtual for checking if order can be cancelled
+orderSchema.virtual("canCancel").get(function () {
+  return ["pending", "confirmed", "processing"].includes(this.orderStatus);
+});
+
+// Virtual for checking if order can be returned
+orderSchema.virtual("canReturn").get(function () {
+  const returnWindow = 7; // days
+  return (
+    this.orderStatus === "delivered" &&
+    this.orderAge <= returnWindow
+  );
+});
+
+// Ensure virtuals are included in JSON
+orderSchema.set("toJSON", { virtuals: true });
+orderSchema.set("toObject", { virtuals: true });
+
+module.exports = mongoose.model("Order", orderSchema);