@mac777/project-pinecone-models 1.1.8 → 1.1.11

package/src/Order.ts

@@ -1,201 +1,252 @@
-import mongoose from 'mongoose';
+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 ---------- */
 
-// 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
+    ipAddress: String,
+    userAgent: String
+  },
+  {
+    timestamps: true,
+    strict: true
   }
-}, { _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,
-  },
-
-  // WHAT
-  eventId: {
-    type: mongoose.Schema.Types.ObjectId,
-    required: true,
-  },
-
-  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
+);
+
+/* ----------------------------------
+ * 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" }
 });
 
-// Indexes for performance
-orderSchema.index({ userId: 1, createdAt: -1 });
-orderSchema.index({ eventId: 1, status: 1 });
-orderSchema.index({ status: 1, expiresAt: 1 });
+/* ----------------------------------
+ * Hooks
+ * ---------------------------------- */
 
-// Auto-generate order number
-orderSchema.pre('save', function(next) {
+// 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}`;
+    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();
 });
 
-// Update updatedAt on save
-orderSchema.pre('save', function(next) {
-  // Note: We don't have updatedAt field, but could add if needed
+// 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 default orderSchema;
+/* ----------------------------------
+ * Export
+ * ---------------------------------- */
+
+export default mongoose.model("Order", orderSchema);

package/src/index.ts

@@ -7,4 +7,5 @@ export { default as paymentSchema } from './Payment';
 export { default as orderSchema } from './Order';
 export { default as userSchema } from './User';
 export { default as eventViewsSchema } from './Event.views';
-export { default as payoutSchema } from './Payout';
+export { default as payoutSchema } from './Payout';
+export { default as auditLogSchema } from './AuditLog';