@mac777/project-pinecone-models 1.1.11 → 1.1.12

package/src/Order.ts

@@ -1,252 +1,201 @@
-import mongoose from "mongoose";
-
-/* ----------------------------------
- * Embedded Schemas
- * ---------------------------------- */
-
-const orderTicketSchema = new mongoose.Schema(
-  {
-    ticketVariantId: {
-      type: mongoose.Schema.Types.ObjectId,
-      required: true,
-      ref: "TicketVariant"
-    },
-    variantName: {
-      type: String,
-      required: true,
-      trim: true
-    },
-    quantity: {
-      type: Number,
-      required: true,
-      min: 1
-    },
-    pricePerTicket: {
-      type: Number,
-      required: true,
-      min: 0
-    },
-    subtotal: {
-      type: Number,
-      required: true,
-      min: 0
-    }
-  },
-  { _id: false }
-);
-
-const pricingSchema = new mongoose.Schema(
-  {
-    subtotal: { type: Number, required: true, min: 0 },
-    platformFee: { type: Number, required: true, min: 0 },
-    paymentFee: { type: Number, required: true, min: 0 },
-    total: { type: Number, required: true, min: 0 },
-    currency: { type: String, default: "BDT" },
-    hostPayout: { type: Number, required: true, min: 0 }
-  },
-  { _id: false }
-);
-
-const refundSchema = new mongoose.Schema(
-  {
-    reason: {
-      type: String,
-      enum: ["event_cancelled", "user_request", "fraud"],
-      required: true
-    },
-    amount: {
-      type: Number,
-      required: true,
-      min: 0
-    },
-    refundedAt: {
-      type: Date,
-      default: Date.now
-    },
-    stripeRefundId: String
-  },
-  { _id: false }
-);
-
-/* ----------------------------------
- * Main Order Schema
- * ---------------------------------- */
-
-const orderSchema = new mongoose.Schema(
-  {
-    /* ---------- Identity ---------- */
-
-    orderNumber: {
-      type: String,
-      unique: true,
-      index: true
-    },
-
-    userId: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
-      index: true
-    },
-
-    eventId: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "Event",
-      required: true,
-      index: true
-    },
-
-    /* ---------- Tickets ---------- */
-
-    tickets: {
-      type: [orderTicketSchema],
-      validate: (v: any) => v.length > 0
-    },
-
-    ticketCount: {
-      type: Number,
-      required: true,
-      min: 1
-    },
-
-    ticketIds: [{
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "Ticket"
-    }],
-
-    /* ---------- Pricing ---------- */
-
-    pricing: {
-      type: pricingSchema,
-      required: true
-    },
-
-    /* ---------- Payment ---------- */
-
-    paymentId: String,
-
-    paymentMethod: {
-      type: String,
-      enum: ["card", "bkash", "bank_transfer", "free"],
-      required: true
-    },
-
-    paymentStatus: {
-      type: String,
-      enum: ["pending", "succeeded", "failed"],
-      default: "pending",
-      index: true
-    },
-
-    paidAt: Date,
-
-    /* ---------- Order Lifecycle ---------- */
-
-    status: {
-      type: String,
-      enum: ["pending", "confirmed", "cancelled", "refunded"],
-      default: "pending",
-      index: true
-    },
-
-    requiresManualReview: {
-      type: Boolean,
-      default: false
-    },
-
-    manualReviewReason: String,
-
-    confirmedAt: Date,
-    cancelledAt: Date,
-    refundedAt: Date,
-
-    expiresAt: {
-      type: Date,
-      required: true,
-      index: true
-    },
-
-    reminderSentAt: Date,
-
-    /* ---------- Buyer ---------- */
-
-    buyerEmail: {
-      type: String,
-      required: true,
-      lowercase: true,
-      trim: true,
-      index: true
-    },
-
-    buyerPhone: String,
-
-    /* ---------- Refund ---------- */
-
-    refund: {
-      type: refundSchema,
-      validate: {
-        validator(refund: any) {
-          return !refund || refund.amount <= this.pricing.total;
-        },
-        message: "Refund amount exceeds order total"
-      }
-    },
-
-    /* ---------- Audit ---------- */
+import mongoose from 'mongoose';
 
-    ipAddress: String,
-    userAgent: String
-  },
-  {
-    timestamps: true,
-    strict: true
+// Order Ticket Schema
+const orderTicketSchema = new mongoose.Schema({
+  ticketVariantId: {
+    type: mongoose.Schema.Types.ObjectId,
+    required: true
+  },
+  variantName: {
+    type: String,
+    required: true
+  },
+  quantity: {
+    type: Number,
+    required: true,
+    min: 1
+  },
+  pricePerTicket: {
+    type: Number,
+    required: true,
+    min: 0
+  },
+  subtotal: {
+    type: Number,
+    required: true,
+    min: 0
   }
-);
-
-/* ----------------------------------
- * Indexes
- * ---------------------------------- */
-
-orderSchema.index({ status: 1, createdAt: -1 });
-orderSchema.index({ eventId: 1, status: 1, createdAt: -1 });
-orderSchema.index({ paymentStatus: 1, createdAt: -1 });
-orderSchema.index({ expiresAt: 1 }, {
-  expireAfterSeconds: 0,
-  partialFilterExpression: { status: "pending" }
-});
+}, { _id: false });
+
+// Pricing Schema
+const pricingSchema = new mongoose.Schema({
+  subtotal: {
+    type: Number,
+    required: true,
+    min: 0
+  },
+  platformFee: {
+    type: Number,
+    required: true,
+    min: 0
+  },
+  paymentFee: {
+    type: Number,
+    required: true,
+    min: 0
+  },
+  total: {
+    type: Number,
+    required: true,
+    min: 0
+  },
+  currency: {
+    type: String,
+    required: true,
+    default: 'BDT'
+  },
+  hostPayout: {
+    type: Number,
+    required: true,
+    min: 0
+  }
+}, { _id: false });
+
+// Refund Schema
+const refundSchema = new mongoose.Schema({
+  reason: {
+    type: String,
+    required: true,
+    enum: ['event_cancelled', 'user_request', 'fraud']
+  },
+  amount: {
+    type: Number,
+    required: true,
+    min: 0
+  },
+  refundedAt: {
+    type: Date,
+    default: Date.now
+  },
+  stripeRefundId: String
+}, { _id: false });
+
+// Main Order Schema
+const orderSchema = new mongoose.Schema({
+  orderNumber: {
+    type: String,
+    required: true,
+    unique: true,
+  },
+
+  // WHO
+  userId: {
+    type: mongoose.Schema.Types.ObjectId,
+    required: true,
+  },
 
-/* ----------------------------------
- * Hooks
- * ---------------------------------- */
+  // WHAT
+  eventId: {
+    type: mongoose.Schema.Types.ObjectId,
+    required: true,
+  },
 
-// Generate order number
-orderSchema.pre("save", function (next) {
-  if (this.isNew && !this.orderNumber) {
-    const ts = Date.now().toString().slice(-6);
-    const rand = Math.random().toString(36).substring(2, 8).toUpperCase();
-    this.orderNumber = `ORD-${ts}-${rand}`;
-  }
-  next();
+  paymentId: {
+    type: String,
+    required: false,
+  },
+
+  tickets: [orderTicketSchema],
+
+  // MONEY
+  pricing: pricingSchema,
+
+  // STATUS
+  status: {
+    type: String,
+    required: true,
+    enum: ['pending', 'confirmed', 'cancelled', 'refunded'],
+    default: 'pending'
+  },
+
+  requiresManualReview: {
+    type: Boolean,
+    default: false
+  },
+
+  manualReviewReason: {
+    type: String,
+    default: null
+  },
+  
+  paymentMethod: {
+    type: String,
+    required: true,
+    enum: ['card', 'bkash', 'bank_transfer', 'free']
+  },
+  paymentStatus: {
+    type: String,
+    required: true,
+    enum: ['pending', 'succeeded', 'failed'],
+    default: 'pending'
+  },
+  paidAt: Date,
+
+  // TICKETS ISSUED
+  ticketIds: [{
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Ticket'
+  }],
+
+  // LIFECYCLE
+  createdAt: {
+    type: Date,
+    default: Date.now,
+    index: true
+  },
+  expiresAt: {
+    type: Date,
+    required: true
+  },
+  confirmedAt: Date,
+  cancelledAt: Date,
+  refundedAt: Date,
+  reminderSentAt: Date,
+
+  // CONTACT
+  buyerEmail: {
+    type: String,
+    required: true
+  },
+  buyerPhone: String,
+
+  // AUDIT
+  ipAddress: String,
+  userAgent: String,
+
+  // REFUND (if applicable)
+  refund: refundSchema
 });
 
-// Compute ticket count
-orderSchema.pre("validate", function (next) {
-  if (this.tickets?.length) {
-    this.ticketCount = this.tickets.reduce((sum, t) => sum + t.quantity, 0);
+// Indexes for performance
+orderSchema.index({ userId: 1, createdAt: -1 });
+orderSchema.index({ eventId: 1, status: 1 });
+orderSchema.index({ status: 1, expiresAt: 1 });
+
+// Auto-generate order number
+orderSchema.pre('save', function(next) {
+  if (this.isNew && !this.orderNumber) {
+    const timestamp = Date.now().toString().slice(-6);
+    const random = Math.random().toString(36).substring(2, 8).toUpperCase();
+    this.orderNumber = `ORD-${timestamp}-${random}`;
   }
   next();
 });
 
-// Pricing immutability after confirmation
-orderSchema.pre("save", function (next) {
-  if (!this.isNew && this.isModified("pricing") && this.status !== "pending") {
-    return next(new Error("Pricing cannot be modified after confirmation"));
-  }
+// Update updatedAt on save
+orderSchema.pre('save', function(next) {
+  // Note: We don't have updatedAt field, but could add if needed
   next();
 });
 
-/* ----------------------------------
- * Export
- * ---------------------------------- */
-
-export default mongoose.model("Order", orderSchema);
+export default orderSchema;

package/src/Order.v2.ts

@@ -0,0 +1,253 @@
+import mongoose from "mongoose";
+
+/* ----------------------------------
+ * Embedded Schemas
+ * ---------------------------------- */
+
+const orderTicketSchema = new mongoose.Schema(
+  {
+    ticketVariantId: {
+      type: mongoose.Schema.Types.ObjectId,
+      required: true,
+      ref: "TicketVariant"
+    },
+    variantName: {
+      type: String,
+      required: true,
+      trim: true
+    },
+    quantity: {
+      type: Number,
+      required: true,
+      min: 1
+    },
+    pricePerTicket: {
+      type: Number,
+      required: true,
+      min: 0
+    },
+    subtotal: {
+      type: Number,
+      required: true,
+      min: 0
+    }
+  },
+  { _id: false }
+);
+
+const pricingSchema = new mongoose.Schema(
+  {
+    subtotal: { type: Number, required: true, min: 0 },
+    platformFee: { type: Number, required: true, min: 0 },
+    paymentFee: { type: Number, required: true, min: 0 },
+    total: { type: Number, required: true, min: 0 },
+    currency: { type: String, default: "BDT" },
+    hostPayout: { type: Number, required: true, min: 0 }
+  },
+  { _id: false }
+);
+
+const refundSchema = new mongoose.Schema(
+  {
+    reason: {
+      type: String,
+      enum: ["event_cancelled", "user_request", "fraud"],
+      required: true
+    },
+    amount: {
+      type: Number,
+      required: true,
+      min: 0
+    },
+    refundedAt: {
+      type: Date,
+      default: Date.now
+    },
+    stripeRefundId: String
+  },
+  { _id: false }
+);
+
+/* ----------------------------------
+ * Main Order Schema
+ * ---------------------------------- */
+
+const orderSchema = new mongoose.Schema(
+  {
+    /* ---------- Identity ---------- */
+
+    orderNumber: {
+      type: String,
+      unique: true,
+      index: true
+    },
+
+    userId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      required: true,
+      index: true
+    },
+
+    eventId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Event",
+      required: true,
+      index: true
+    },
+
+    /* ---------- Tickets ---------- */
+
+    tickets: {
+      type: [orderTicketSchema],
+      validate: (v: any) => v.length > 0
+    },
+
+    ticketCount: {
+      type: Number,
+      required: true,
+      min: 1
+    },
+
+    ticketIds: [{
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Ticket"
+    }],
+
+    /* ---------- Pricing ---------- */
+
+    pricing: {
+      type: pricingSchema,
+      required: true
+    },
+
+    /* ---------- Payment ---------- */
+
+    paymentId: String,
+
+    paymentMethod: {
+      type: String,
+      enum: ["card", "bkash", "bank_transfer", "free"],
+      required: true
+    },
+
+    paymentStatus: {
+      type: String,
+      enum: ["pending", "succeeded", "failed"],
+      default: "pending",
+      index: true
+    },
+
+    paidAt: Date,
+
+    /* ---------- Order Lifecycle ---------- */
+
+    status: {
+      type: String,
+      enum: ["pending", "confirmed", "cancelled", "refunded"],
+      default: "pending",
+      index: true
+    },
+
+    requiresManualReview: {
+      type: Boolean,
+      default: false
+    },
+
+    manualReviewReason: String,
+
+    confirmedAt: Date,
+    cancelledAt: Date,
+    refundedAt: Date,
+
+    expiresAt: {
+      type: Date,
+      required: true,
+      index: true
+    },
+
+    reminderSentAt: Date,
+
+    /* ---------- Buyer ---------- */
+
+    buyerEmail: {
+      type: String,
+      required: true,
+      lowercase: true,
+      trim: true,
+      index: true
+    },
+
+    buyerPhone: String,
+
+    /* ---------- Refund ---------- */
+
+    refund: {
+      type: refundSchema,
+      validate: {
+        validator(refund: any) {
+          return !refund || refund.amount <= this.pricing.total;
+        },
+        message: "Refund amount exceeds order total"
+      }
+    },
+
+    /* ---------- Audit ---------- */
+
+    ipAddress: String,
+    userAgent: String
+  },
+  {
+    timestamps: true,
+    strict: true
+  }
+);
+
+/* ----------------------------------
+ * Indexes
+ * ---------------------------------- */
+
+orderSchema.index({ status: 1, createdAt: -1 });
+orderSchema.index({ eventId: 1, status: 1, createdAt: -1 });
+orderSchema.index({ paymentStatus: 1, createdAt: -1 });
+orderSchema.index({ expiresAt: 1 }, {
+  expireAfterSeconds: 0,
+  partialFilterExpression: { status: "pending" }
+});
+
+/* ----------------------------------
+ * Hooks
+ * ---------------------------------- */
+
+// Generate order number
+orderSchema.pre("save", function (next) {
+  if (this.isNew && !this.orderNumber) {
+    const ts = Date.now().toString().slice(-6);
+    const rand = Math.random().toString(36).substring(2, 8).toUpperCase();
+    this.orderNumber = `ORD-${ts}-${rand}`;
+  }
+  next();
+});
+
+// Compute ticket count
+orderSchema.pre("validate", function (next) {
+  if (this.tickets?.length) {
+    this.ticketCount = this.tickets.reduce((sum, t) => sum + t.quantity, 0);
+  }
+  next();
+});
+
+// Pricing immutability after confirmation
+orderSchema.pre("save", function (next) {
+  if (!this.isNew && this.isModified("pricing") && this.status !== "pending") {
+    return next(new Error("Pricing cannot be modified after confirmation"));
+  }
+  next();
+});
+
+/* ----------------------------------
+ * Export
+ * ---------------------------------- */
+
+export default mongoose.model("Order", orderSchema);
+