@feardread/fear 1.2.1 → 2.0.1

package/models/order.js

@@ -1,109 +1,43 @@
 const mongoose = require("mongoose");
+const Address = require("./address");
 
 const orderItemSchema = new mongoose.Schema({
-  productId: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: "Product",
-    required: true,
-  },
-  name: {
-    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,
-  },
+  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, // For size, color, etc.
-  },
+  attributes: { type: Map, of: String, },
 });
 
 const orderSchema = new mongoose.Schema(
   {
-    orderNumber: {
-      type: String,
-      unique: true,
-      required: true,
-    },
-    userId: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
-      index: true,
-    },
-    // Order Items
+    orderNumber: { type: String, unique: true, required: true, },
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: true, index: true, },
     items: [orderItemSchema],
-    
-    // Pricing
-    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"],
-    },
-    
-    // Payment Information
-    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,
-    },
+    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", "stripe"], required: true, },
+    paymentStatus: { type: String, enum: ["pending", "processing", "completed", "failed", "refunded", "partially_refunded"], default: "pending", index: true, },
     paymentDetails: {
       // Razorpay
       razorpayOrderId: String,
       razorpayPaymentId: String,
       razorpaySignature: String,
-      
       // PayPal
       paypalOrderId: String,
       paypalCaptureId: String,
-      
+      // Stripe
+      stripeOrderId: String,
+      stripePaymentId: String,
       // Common
       transactionId: String,
       paymentMethodId: {
@@ -112,8 +46,6 @@ const orderSchema = new mongoose.Schema(
       },
       paidAt: Date,
     },
-    
-    // Order Status
     orderStatus: {
       type: String,
       enum: [
@@ -130,62 +62,12 @@ const orderSchema = new mongoose.Schema(
       default: "pending",
       index: true,
     },
-    
-    // Shipping Information
-    shippingAddress: {
-      name: {
-        type: String,
-        required: true,
-      },
-      phone: {
-        type: String,
-        required: true,
-      },
-      email: String,
-      line1: {
-        type: String,
-        required: true,
-      },
-      line2: String,
-      city: {
-        type: String,
-        required: true,
-      },
-      state: {
-        type: String,
-        required: true,
-      },
-      postalCode: {
-        type: String,
-        required: true,
-      },
-      country: {
-        type: String,
-        required: true,
-        default: "IN",
-      },
-      landmark: String,
-    },
-    
-    billingAddress: {
-      name: String,
-      phone: String,
-      email: String,
-      line1: String,
-      line2: String,
-      city: String,
-      state: String,
-      postalCode: String,
-      country: String,
-    },
-    
-    // Shipping Details
+    shippingAddress: Address.schema,
+    billingAddress: Address.schema,
     shippingProvider: String,
     trackingNumber: String,
     estimatedDeliveryDate: Date,
     actualDeliveryDate: Date,
-    
-    // Status History
     statusHistory: [
       {
         status: String,
@@ -200,30 +82,21 @@ const orderSchema = new mongoose.Schema(
         },
       },
     ],
-    
-    // Discount/Coupon
     couponCode: String,
     couponDiscount: {
       type: Number,
       default: 0,
     },
-    
-    // Notes
     customerNote: String,
     internalNote: String,
-    
-    // Cancellation/Return
     cancellationReason: String,
     cancelledAt: Date,
     cancelledBy: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "User",
     },
-    
     returnReason: String,
     returnedAt: Date,
-    
-    // Refund Information
     refundAmount: Number,
     refundStatus: {
       type: String,
@@ -232,8 +105,6 @@ const orderSchema = new mongoose.Schema(
     },
     refundedAt: Date,
     refundTransactionId: String,
-    
-    // Metadata
     metadata: {
       type: Map,
       of: mongoose.Schema.Types.Mixed,
@@ -252,6 +123,8 @@ 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) {
@@ -288,7 +161,9 @@ orderSchema.statics.getUserOrders = async function (userId, options = {}) {
     .limit(limit)
     .skip(skip)
     .populate("items.productId", "name images")
-    .populate("paymentDetails.paymentMethodId");
+    .populate("paymentDetails.paymentMethodId")
+    .populate("shippingAddress")
+    .populate("billingAddress");
 };
 
 // Static method to get order statistics

package/models/payment.js

@@ -3,87 +3,28 @@ const crypto = require("crypto");
 
 const paymentMethodSchema = new mongoose.Schema(
   {
-    userId: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
-      index: true,
-    },
-    paymentType: {
-      type: String,
-      enum: ["razorpay", "paypal", "card", "upi", "netbanking"],
-      required: true,
-    },
-    paymentToken: {
-      type: String,
-      required: true,
-      // This stores the tokenized payment method from the payment gateway
-    },
-    isDefault: {
-      type: Boolean,
-      default: false,
-    },
-    isActive: {
-      type: Boolean,
-      default: true,
-    },
-    // Card/Payment details (only non-sensitive info for display)
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: true, index: true, },
+    paymentType: {  type: String, enum: ["razorpay", "paypal", "card", "upi", "netbanking", "stripe"], required: true, },
+    paymentToken: { type: String, required: true, },
+    isDefault: { type: Boolean, default: false, },
+    isActive: { type: Boolean,  default: true, },
     cardDetails: {
-      last4: {
-        type: String,
-        maxlength: 4,
-      },
-      brand: {
-        type: String, // Visa, Mastercard, Amex, etc.
-      },
-      expiryMonth: {
-        type: String,
-        maxlength: 2,
-      },
-      expiryYear: {
-        type: String,
-        maxlength: 4,
-      },
-      cardholderName: {
-        type: String,
-      },
-      fingerprint: {
-        type: String, // Unique identifier for the card
-      },
+      last4: { type: String, maxlength: 4, },
+      brand: { type: String, },
+      expiryMonth: { type: String, maxlength: 2, },
+      expiryYear: { type: String, maxlength: 4, },
+      cardholderName: { type: String, },
+      fingerprint: { type: String,} 
     },
-    // PayPal details
-    paypalDetails: {
-      email: {
-        type: String,
-      },
-      payerId: {
-        type: String,
-      },
+    paypalDetails: { 
+      email: { type: String, },
+      payerId: { type: String, },
     },
-    // UPI details
     upiDetails: {
-      vpa: {
-        type: String, // Virtual Payment Address (e.g., user@paytm)
-      },
-    },
-    // Billing address
-    billingAddress: {
-      name: String,
-      line1: String,
-      line2: String,
-      city: String,
-      state: String,
-      postalCode: String,
-      country: {
-        type: String,
-        default: "IN",
-      },
-    },
-    // Metadata for additional information
-    metadata: {
-      type: Map,
-      of: String,
+      vpa: { type: String, },
     },
+    billingAddress: { type: mongoose.Schema.Types.ObjectId, ref: "Address", required: true, index: true, },
+    metadata: { type: Map,  of: String, },
   },
   {
     timestamps: true,
@@ -193,6 +134,4 @@ paymentMethodSchema.virtual("isExpired").get(function () {
 paymentMethodSchema.set("toJSON", { virtuals: true });
 paymentMethodSchema.set("toObject", { virtuals: true });
 
-const PaymentMethod = mongoose.model("PaymentMethod", paymentMethodSchema);
-
-module.exports = PaymentMethod;
+module.exports = mongoose.model("PaymentMethod", paymentMethodSchema);

package/models/user.js

@@ -1,68 +1,135 @@
-const mongoose = require("mongoose");
-const bcrypt = require("bcrypt");
-const crypto = require("crypto");
+const mongoose = require('mongoose');
+const bcrypt = require('bcrypt');
 
 const userSchema = new mongoose.Schema({
-    name: { type: String, required: true },
-    lastname: { type: String, required: false },
-    email: { type: String, required: true, unique: true },
-    username: { type: String, required: false, unique: false },
-    mobile: { type: String, required: false, unique: true },
-    password: { type: String, required: true },
-    avatar: { type: Object, required: false, default: {
+  email: { type: String, required: true, unique: true, lowercase: true, trim: true,
+    match: [/^\S+@\S+\.\S+$/, 'Please enter a valid email']
+  },
+  password: { type: String, required: true, minlength: 8, select: false },
+  firstName: { type: String, required: true, trim: true },
+  lastName: { type: String, required: true, trim: true },
+  displayName: { type: String, trim: true },
+  avatar: { type: Object, required: false, default: {
       public_id: '',
-      secure_url: ''
-    }},
-    role: { type: String, default: "customer" },
-    isBlocked: { type: Boolean, default: false },
-    address: { type: String },
-    shipping: { type: String },
-    wishlist: [{ type: mongoose.Schema.Types.ObjectId, ref: "Product" }],
-    refreshToken: { type: String },
-      passwordChangedAt: Date,
-      passwordResetToken: String,
-      passwordResetExpires: Date
+      secure_url: '',
+    }, trim: true
+  },
+  bio: { type: String, maxlength: 500 },
+  dateOfBirth: Date,
+  mobile: { type: String, trim: true, unique: false, required: false },
+  role: { type: String, 
+    enum: ['user', 'admin', 'moderator'], default: 'user' },
+  status: { type: String, 
+    enum: ['active', 'inactive', 'suspended', 'deleted'], default: 'active' },
+  emailVerified: { type: Boolean, default: false },
+  emailVerificationToken: String,
+  emailVerificationExpires: Date,
+  passwordResetToken: String,
+  passwordResetExpires: Date,
+  twoFactorSecret: { type: String, select: false},
+  twoFactorEnabled: { type: Boolean, default: false },
+  preferences: {
+    language: { type: String, default: 'en' },
+    timezone: { type: String, default: 'UTC' },
+    notifications: {
+      email: { type: Boolean, default: true },
+      push: { type: Boolean, default: true },
+      sms: { type: Boolean, default: false }
     },
-  { timestamps: true }
-);
+    theme: { type: String, enum: ['light', 'dark', 'auto'], default: 'auto' }
+  },
+  socialAccounts: [{
+    provider: { type: String,
+      enum: ['google', 'facebook', 'github', 'apple']},
+    providerId: String,
+    email: String,
+    connectedAt: {
+      type: Date,
+      default: Date.now
+    }
+  }],
+  lastLoginAt: Date,
+  lastLoginIP: String,
+  loginAttempts: { type: Number, default: 0 },
+  lockUntil: Date
+}, {
+  timestamps: true
+});
+
+// Indexes
+userSchema.index({ email: 1 });
+userSchema.index({ 'profile.firstName': 1, 'profile.lastName': 1 });
+userSchema.index({ createdAt: 1 });
+userSchema.index({ status: 1, role: 1 });
+
+// Virtual for full name
+userSchema.virtual('profile.fullName').get(function() {
+  return `${this.profile.firstName} ${this.profile.lastName}`;
+});
 
-// Hooks
-userSchema.pre("save", async function (next) {
-  if (!this.isModified("password")) {
+// Hash password before saving
+userSchema.pre('save', async function(next) {
+  if (!this.isModified('password')) return next();
+  
+  try {
+    const salt = await bcrypt.genSalt(12);
+    this.password = await bcrypt.hash(this.password, salt);
     next();
+  } catch (error) {
+    next(error);
   }
-  const salt = await bcrypt.genSaltSync(10);
-  this.password = await bcrypt.hash(this.password, salt);
-  next();
 });
 
-// Methods
-userSchema.methods.compare = async function (entered) {
-  return await bcrypt.compare(entered, this.password);
+// Method to compare passwords
+userSchema.methods.comparePassword = async function(candidatePassword) {
+  return await bcrypt.compare(candidatePassword, this.password);
 };
 
-userSchema.methods.token = async function () {
-  const resettoken = crypto.randomBytes(32).toString("hex");
-
-  this.passwordResetToken = crypto.createHash("sha256").update(resettoken).digest("hex");
-  this.passwordResetExpires = Date.now() + 30 * 60 * 1000;
-
-  return resettoken;
+// Method to check if account is locked
+userSchema.methods.isLocked = function() {
+  return !!(this.lockUntil && this.lockUntil > Date.now());
 };
 
-//Statics
-userSchema.statics.countUsers = function () {
-  return this.countDocuments({});
+// Method to increment login attempts
+userSchema.methods.incLoginAttempts = async function() {
+  if (this.lockUntil && this.lockUntil < Date.now()) {
+    return await this.updateOne({
+      $set: { loginAttempts: 1 },
+      $unset: { lockUntil: 1 }
+    });
+  }
+  
+  const updates = { $inc: { loginAttempts: 1 } };
+  const maxAttempts = 5;
+  const lockTime = 2 * 60 * 60 * 1000; // 2 hours
+  
+  if (this.loginAttempts + 1 >= maxAttempts && !this.isLocked()) {
+    updates.$set = { lockUntil: Date.now() + lockTime };
+  }
+  
+  return await this.updateOne(updates);
 };
 
-userSchema.statics.findByEmail = async function (email) {
-return await this.findOne({ email });
+// Method to reset login attempts
+userSchema.methods.resetLoginAttempts = async function() {
+  return await this.updateOne({
+    $set: { loginAttempts: 0 },
+    $unset: { lockUntil: 1 }
+  });
 };
 
-// Query
-userSchema.query.paginate = function ({ page, limit }) {
-  const skip = limit * (page - 1);
-  return this.skip(skip).limit(limit);
+// Remove sensitive data from JSON output
+userSchema.methods.toJSON = function() {
+  const obj = this.toObject();
+  delete obj.password;
+  delete obj.twoFactorSecret;
+  delete obj.emailVerificationToken;
+  delete obj.emailVerificationExpires;
+  delete obj.passwordResetToken;
+  delete obj.passwordResetExpires;
+  delete obj.loginAttempts;
+  delete obj.lockUntil;
+  return obj;
 };
 
-module.exports = mongoose.model("User", userSchema);
+module.exports = mongoose.model('User', userSchema);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feardread/fear",
-  "version": "1.2.1",
+  "version": "2.0.1",
   "description": "",
   "main": "index.js",
   "scripts": {

package/routes/address.js

@@ -0,0 +1,16 @@
+const Address = require('../controllers/address');
+
+module.exports = ( fear ) => {
+      const router = fear.createRouter();
+      const handler = fear.getHandler();
+
+      router.get("/all", handler.async(Address.all));
+      router.post("/new", handler.async(Address.create));
+      router.post("/create", handler.async(Address.create));
+      router.route("/:id")
+            .get(handler.async(Address.read))
+            .put(handler.async(Address.update))
+            .delete(handler.async(Address.delete));
+
+      return router;
+}

package/routes/auth.js

@@ -1,13 +1,19 @@
 const Auth = require("../controllers/auth");
+const passport = require("passport");
 
 module.exports = (fear) => {
     const router = fear.createRouter();
     const handler = fear.getHandler();
     const validator = fear.getValidator();
+    //const passport = fear.getPassport();
 
-    router.post("/login", handler.async(Auth.login))
-    router.post("/logout", handler.async(Auth.logout))
-    router.post("/register", handler.async(Auth.register))
+    router.post("/login", handler.async(Auth.login));
+    router.post("/logout", handler.async(Auth.logout));
+    router.post("/register", handler.async(Auth.register));
+
+    router.post('/google', handler.async(Auth.googleAuth)); 
+    router.post('/google/link',handler.async(Auth.linkGoogleAccount));
+    router.delete('/google/unlink',handler.async(Auth.unlinkGoogleAccount));
 
     return router;
 }