@mac777/project-pinecone-models 1.1.9 → 1.1.11

package/dist/AuditLog.js

@@ -2,13 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const mongoose_1 = require("mongoose");
 const auditLogSchema = new mongoose_1.Schema({
-    userId: { type: String, required: true },
-    action: { type: String, required: true },
-    details: { type: Object, required: true },
-    performedBy: { type: String, required: true },
-    targetType: { type: String, required: true },
-    targetId: { type: String, required: true },
-    metadata: { type: Object, required: true },
+    userId: { type: String },
+    action: { type: String },
+    details: { type: Object },
+    performedBy: { type: String },
+    targetType: { type: String },
+    targetId: { type: String },
+    metadata: { type: Object },
     timestamp: { type: Date, default: Date.now },
 });
 exports.default = auditLogSchema;

package/dist/Order.d.ts

@@ -1,8 +1,15 @@
-import mongoose from 'mongoose';
-declare const orderSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+import mongoose from "mongoose";
+declare const _default: mongoose.Model<{
     userId: mongoose.Types.ObjectId;
-    createdAt: NativeDate;
     status: "pending" | "cancelled" | "confirmed" | "refunded";
+    pricing: {
+        currency: string;
+        platformFee: number;
+        subtotal: number;
+        paymentFee: number;
+        total: number;
+        hostPayout: number;
+    };
     tickets: mongoose.Types.DocumentArray<{
         quantity: number;
         ticketVariantId: mongoose.Types.ObjectId;
@@ -24,40 +31,98 @@ declare const orderSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
     }>;
     eventId: mongoose.Types.ObjectId;
     expiresAt: NativeDate;
-    orderNumber: string;
-    requiresManualReview: boolean;
-    manualReviewReason: string;
+    ticketCount: number;
+    ticketIds: mongoose.Types.ObjectId[];
     paymentMethod: "card" | "bkash" | "bank_transfer" | "free";
     paymentStatus: "pending" | "succeeded" | "failed";
-    ticketIds: mongoose.Types.ObjectId[];
+    requiresManualReview: boolean;
     buyerEmail: string;
     paidAt?: NativeDate | null | undefined;
-    pricing?: {
+    refundedAt?: NativeDate | null | undefined;
+    paymentId?: string | null | undefined;
+    manualReviewReason?: string | null | undefined;
+    confirmedAt?: NativeDate | null | undefined;
+    cancelledAt?: NativeDate | null | undefined;
+    reminderSentAt?: NativeDate | null | undefined;
+    buyerPhone?: string | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    orderNumber?: string | null | undefined;
+    refund?: {
+        reason: "event_cancelled" | "user_request" | "fraud";
+        amount: number;
+        refundedAt: NativeDate;
+        stripeRefundId?: string | null | undefined;
+    } | null | undefined;
+} & mongoose.DefaultTimestampProps, {}, {}, {}, mongoose.Document<unknown, {}, {
+    userId: mongoose.Types.ObjectId;
+    status: "pending" | "cancelled" | "confirmed" | "refunded";
+    pricing: {
         currency: string;
         platformFee: number;
         subtotal: number;
         paymentFee: number;
         total: number;
         hostPayout: number;
-    } | null | undefined;
+    };
+    tickets: mongoose.Types.DocumentArray<{
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, any, {
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }> & {
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }>;
+    eventId: mongoose.Types.ObjectId;
+    expiresAt: NativeDate;
+    ticketCount: number;
+    ticketIds: mongoose.Types.ObjectId[];
+    paymentMethod: "card" | "bkash" | "bank_transfer" | "free";
+    paymentStatus: "pending" | "succeeded" | "failed";
+    requiresManualReview: boolean;
+    buyerEmail: string;
+    paidAt?: NativeDate | null | undefined;
     refundedAt?: NativeDate | null | undefined;
+    paymentId?: string | null | undefined;
+    manualReviewReason?: string | null | undefined;
     confirmedAt?: NativeDate | null | undefined;
     cancelledAt?: NativeDate | null | undefined;
     reminderSentAt?: NativeDate | null | undefined;
     buyerPhone?: string | null | undefined;
     ipAddress?: string | null | undefined;
     userAgent?: string | null | undefined;
+    orderNumber?: string | null | undefined;
     refund?: {
         reason: "event_cancelled" | "user_request" | "fraud";
         amount: number;
         refundedAt: NativeDate;
         stripeRefundId?: string | null | undefined;
     } | null | undefined;
-    paymentId?: string | null | undefined;
-}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+} & mongoose.DefaultTimestampProps, {}, {
+    timestamps: true;
+    strict: true;
+}> & {
     userId: mongoose.Types.ObjectId;
-    createdAt: NativeDate;
     status: "pending" | "cancelled" | "confirmed" | "refunded";
+    pricing: {
+        currency: string;
+        platformFee: number;
+        subtotal: number;
+        paymentFee: number;
+        total: number;
+        hostPayout: number;
+    };
     tickets: mongoose.Types.DocumentArray<{
         quantity: number;
         ticketVariantId: mongoose.Types.ObjectId;
@@ -79,40 +144,102 @@ declare const orderSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
     }>;
     eventId: mongoose.Types.ObjectId;
     expiresAt: NativeDate;
-    orderNumber: string;
-    requiresManualReview: boolean;
-    manualReviewReason: string;
+    ticketCount: number;
+    ticketIds: mongoose.Types.ObjectId[];
     paymentMethod: "card" | "bkash" | "bank_transfer" | "free";
     paymentStatus: "pending" | "succeeded" | "failed";
-    ticketIds: mongoose.Types.ObjectId[];
+    requiresManualReview: boolean;
     buyerEmail: string;
     paidAt?: NativeDate | null | undefined;
-    pricing?: {
+    refundedAt?: NativeDate | null | undefined;
+    paymentId?: string | null | undefined;
+    manualReviewReason?: string | null | undefined;
+    confirmedAt?: NativeDate | null | undefined;
+    cancelledAt?: NativeDate | null | undefined;
+    reminderSentAt?: NativeDate | null | undefined;
+    buyerPhone?: string | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    orderNumber?: string | null | undefined;
+    refund?: {
+        reason: "event_cancelled" | "user_request" | "fraud";
+        amount: number;
+        refundedAt: NativeDate;
+        stripeRefundId?: string | null | undefined;
+    } | null | undefined;
+} & mongoose.DefaultTimestampProps & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+    strict: true;
+}, {
+    userId: mongoose.Types.ObjectId;
+    status: "pending" | "cancelled" | "confirmed" | "refunded";
+    pricing: {
         currency: string;
         platformFee: number;
         subtotal: number;
         paymentFee: number;
         total: number;
         hostPayout: number;
-    } | null | undefined;
+    };
+    tickets: mongoose.Types.DocumentArray<{
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, any, {
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }> & {
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }>;
+    eventId: mongoose.Types.ObjectId;
+    expiresAt: NativeDate;
+    ticketCount: number;
+    ticketIds: mongoose.Types.ObjectId[];
+    paymentMethod: "card" | "bkash" | "bank_transfer" | "free";
+    paymentStatus: "pending" | "succeeded" | "failed";
+    requiresManualReview: boolean;
+    buyerEmail: string;
+    paidAt?: NativeDate | null | undefined;
     refundedAt?: NativeDate | null | undefined;
+    paymentId?: string | null | undefined;
+    manualReviewReason?: string | null | undefined;
     confirmedAt?: NativeDate | null | undefined;
     cancelledAt?: NativeDate | null | undefined;
     reminderSentAt?: NativeDate | null | undefined;
     buyerPhone?: string | null | undefined;
     ipAddress?: string | null | undefined;
     userAgent?: string | null | undefined;
+    orderNumber?: string | null | undefined;
     refund?: {
         reason: "event_cancelled" | "user_request" | "fraud";
         amount: number;
         refundedAt: NativeDate;
         stripeRefundId?: string | null | undefined;
     } | null | undefined;
-    paymentId?: string | null | undefined;
-}>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<{
+} & mongoose.DefaultTimestampProps, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
     userId: mongoose.Types.ObjectId;
-    createdAt: NativeDate;
     status: "pending" | "cancelled" | "confirmed" | "refunded";
+    pricing: {
+        currency: string;
+        platformFee: number;
+        subtotal: number;
+        paymentFee: number;
+        total: number;
+        hostPayout: number;
+    };
     tickets: mongoose.Types.DocumentArray<{
         quantity: number;
         ticketVariantId: mongoose.Types.ObjectId;
@@ -134,39 +261,90 @@ declare const orderSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
     }>;
     eventId: mongoose.Types.ObjectId;
     expiresAt: NativeDate;
-    orderNumber: string;
-    requiresManualReview: boolean;
-    manualReviewReason: string;
+    ticketCount: number;
+    ticketIds: mongoose.Types.ObjectId[];
     paymentMethod: "card" | "bkash" | "bank_transfer" | "free";
     paymentStatus: "pending" | "succeeded" | "failed";
-    ticketIds: mongoose.Types.ObjectId[];
+    requiresManualReview: boolean;
     buyerEmail: string;
     paidAt?: NativeDate | null | undefined;
-    pricing?: {
+    refundedAt?: NativeDate | null | undefined;
+    paymentId?: string | null | undefined;
+    manualReviewReason?: string | null | undefined;
+    confirmedAt?: NativeDate | null | undefined;
+    cancelledAt?: NativeDate | null | undefined;
+    reminderSentAt?: NativeDate | null | undefined;
+    buyerPhone?: string | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    orderNumber?: string | null | undefined;
+    refund?: {
+        reason: "event_cancelled" | "user_request" | "fraud";
+        amount: number;
+        refundedAt: NativeDate;
+        stripeRefundId?: string | null | undefined;
+    } | null | undefined;
+} & mongoose.DefaultTimestampProps>, {}, mongoose.ResolveSchemaOptions<{
+    timestamps: true;
+    strict: true;
+}>> & mongoose.FlatRecord<{
+    userId: mongoose.Types.ObjectId;
+    status: "pending" | "cancelled" | "confirmed" | "refunded";
+    pricing: {
         currency: string;
         platformFee: number;
         subtotal: number;
         paymentFee: number;
         total: number;
         hostPayout: number;
-    } | null | undefined;
+    };
+    tickets: mongoose.Types.DocumentArray<{
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, any, {
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }> & {
+        quantity: number;
+        ticketVariantId: mongoose.Types.ObjectId;
+        variantName: string;
+        pricePerTicket: number;
+        subtotal: number;
+    }>;
+    eventId: mongoose.Types.ObjectId;
+    expiresAt: NativeDate;
+    ticketCount: number;
+    ticketIds: mongoose.Types.ObjectId[];
+    paymentMethod: "card" | "bkash" | "bank_transfer" | "free";
+    paymentStatus: "pending" | "succeeded" | "failed";
+    requiresManualReview: boolean;
+    buyerEmail: string;
+    paidAt?: NativeDate | null | undefined;
     refundedAt?: NativeDate | null | undefined;
+    paymentId?: string | null | undefined;
+    manualReviewReason?: string | null | undefined;
     confirmedAt?: NativeDate | null | undefined;
     cancelledAt?: NativeDate | null | undefined;
     reminderSentAt?: NativeDate | null | undefined;
     buyerPhone?: string | null | undefined;
     ipAddress?: string | null | undefined;
     userAgent?: string | null | undefined;
+    orderNumber?: string | null | undefined;
     refund?: {
         reason: "event_cancelled" | "user_request" | "fraud";
         amount: number;
         refundedAt: NativeDate;
         stripeRefundId?: string | null | undefined;
     } | null | undefined;
-    paymentId?: string | null | undefined;
-}> & {
+} & mongoose.DefaultTimestampProps> & {
     _id: mongoose.Types.ObjectId;
 } & {
     __v: number;
-}>;
-export default orderSchema;
+}>>;
+export default _default;

package/dist/Order.js

@@ -4,15 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const mongoose_1 = __importDefault(require("mongoose"));
-// Order Ticket Schema
+/* ----------------------------------
+ * Embedded Schemas
+ * ---------------------------------- */
 const orderTicketSchema = new mongoose_1.default.Schema({
     ticketVariantId: {
         type: mongoose_1.default.Schema.Types.ObjectId,
-        required: true
+        required: true,
+        ref: "TicketVariant"
     },
     variantName: {
         type: String,
-        required: true
+        required: true,
+        trim: true
     },
     quantity: {
         type: Number,
@@ -30,45 +34,19 @@ const orderTicketSchema = new mongoose_1.default.Schema({
         min: 0
     }
 }, { _id: false });
-// Pricing Schema
 const pricingSchema = new mongoose_1.default.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
-    }
+    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 });
-// Refund Schema
 const refundSchema = new mongoose_1.default.Schema({
     reason: {
         type: String,
-        required: true,
-        enum: ['event_cancelled', 'user_request', 'fraud']
+        enum: ["event_cancelled", "user_request", "fraud"],
+        required: true
     },
     amount: {
         type: Number,
@@ -81,104 +59,145 @@ const refundSchema = new mongoose_1.default.Schema({
     },
     stripeRefundId: String
 }, { _id: false });
-// Main Order Schema
+/* ----------------------------------
+ * Main Order Schema
+ * ---------------------------------- */
 const orderSchema = new mongoose_1.default.Schema({
+    /* ---------- Identity ---------- */
     orderNumber: {
         type: String,
-        required: true,
         unique: true,
+        index: true
     },
-    // WHO
     userId: {
         type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "User",
         required: true,
+        index: true
     },
-    // WHAT
     eventId: {
         type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "Event",
         required: true,
+        index: true
     },
-    paymentId: {
-        type: String,
-        required: false,
+    /* ---------- Tickets ---------- */
+    tickets: {
+        type: [orderTicketSchema],
+        validate: (v) => v.length > 0
     },
-    tickets: [orderTicketSchema],
-    // MONEY
-    pricing: pricingSchema,
-    // STATUS
-    status: {
-        type: String,
+    ticketCount: {
+        type: Number,
         required: true,
-        enum: ['pending', 'confirmed', 'cancelled', 'refunded'],
-        default: 'pending'
-    },
-    requiresManualReview: {
-        type: Boolean,
-        default: false
+        min: 1
     },
-    manualReviewReason: {
-        type: String,
-        default: null
+    ticketIds: [{
+            type: mongoose_1.default.Schema.Types.ObjectId,
+            ref: "Ticket"
+        }],
+    /* ---------- Pricing ---------- */
+    pricing: {
+        type: pricingSchema,
+        required: true
     },
+    /* ---------- Payment ---------- */
+    paymentId: String,
     paymentMethod: {
         type: String,
-        required: true,
-        enum: ['card', 'bkash', 'bank_transfer', 'free']
+        enum: ["card", "bkash", "bank_transfer", "free"],
+        required: true
     },
     paymentStatus: {
         type: String,
-        required: true,
-        enum: ['pending', 'succeeded', 'failed'],
-        default: 'pending'
+        enum: ["pending", "succeeded", "failed"],
+        default: "pending",
+        index: true
     },
     paidAt: Date,
-    // TICKETS ISSUED
-    ticketIds: [{
-            type: mongoose_1.default.Schema.Types.ObjectId,
-            ref: 'Ticket'
-        }],
-    // LIFECYCLE
-    createdAt: {
-        type: Date,
-        default: Date.now,
+    /* ---------- Order Lifecycle ---------- */
+    status: {
+        type: String,
+        enum: ["pending", "confirmed", "cancelled", "refunded"],
+        default: "pending",
         index: true
     },
-    expiresAt: {
-        type: Date,
-        required: true
+    requiresManualReview: {
+        type: Boolean,
+        default: false
     },
+    manualReviewReason: String,
     confirmedAt: Date,
     cancelledAt: Date,
     refundedAt: Date,
+    expiresAt: {
+        type: Date,
+        required: true,
+        index: true
+    },
     reminderSentAt: Date,
-    // CONTACT
+    /* ---------- Buyer ---------- */
     buyerEmail: {
         type: String,
-        required: true
+        required: true,
+        lowercase: true,
+        trim: true,
+        index: true
     },
     buyerPhone: String,
-    // AUDIT
+    /* ---------- Refund ---------- */
+    refund: {
+        type: refundSchema,
+        validate: {
+            validator(refund) {
+                return !refund || refund.amount <= this.pricing.total;
+            },
+            message: "Refund amount exceeds order total"
+        }
+    },
+    /* ---------- Audit ---------- */
     ipAddress: String,
-    userAgent: String,
-    // REFUND (if applicable)
-    refund: refundSchema
+    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" }
 });
-// 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) {
+/* ----------------------------------
+ * Hooks
+ * ---------------------------------- */
+// 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();
 });
-// Update updatedAt on save
-orderSchema.pre('save', function (next) {
-    // Note: We don't have updatedAt field, but could add if needed
+// 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();
 });
-exports.default = orderSchema;
+/* ----------------------------------
+ * Export
+ * ---------------------------------- */
+exports.default = mongoose_1.default.model("Order", orderSchema);

package/dist/Payment.d.ts

@@ -2,7 +2,7 @@ import mongoose from 'mongoose';
 declare const paymentSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
     userId: mongoose.Types.ObjectId;
     createdAt: NativeDate;
-    status: "pending" | "refunded" | "succeeded" | "failed";
+    status: "pending" | "succeeded" | "failed" | "refunded";
     amount: number;
     currency: string;
     paymentId: string;
@@ -20,7 +20,7 @@ declare const paymentSchema: mongoose.Schema<any, mongoose.Model<any, any, any,
 }, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
     userId: mongoose.Types.ObjectId;
     createdAt: NativeDate;
-    status: "pending" | "refunded" | "succeeded" | "failed";
+    status: "pending" | "succeeded" | "failed" | "refunded";
     amount: number;
     currency: string;
     paymentId: string;
@@ -38,7 +38,7 @@ declare const paymentSchema: mongoose.Schema<any, mongoose.Model<any, any, any,
 }>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<{
     userId: mongoose.Types.ObjectId;
     createdAt: NativeDate;
-    status: "pending" | "refunded" | "succeeded" | "failed";
+    status: "pending" | "succeeded" | "failed" | "refunded";
     amount: number;
     currency: string;
     paymentId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mac777/project-pinecone-models",
-  "version": "1.1.9",
+  "version": "1.1.11",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

package/src/AuditLog.ts

@@ -12,13 +12,13 @@ export interface IAuditLog extends Document {
 }
 
 const auditLogSchema = new Schema<IAuditLog>({
-    userId: { type: String, required: true },
-    action: { type: String, required: true },
-    details: { type: Object, required: true },
-    performedBy: { type: String, required: true },
-    targetType: { type: String, required: true },
-    targetId: { type: String, required: true },
-    metadata: { type: Object, required: true },
+    userId: { type: String },
+    action: { type: String },
+    details: { type: Object },
+    performedBy: { type: String },
+    targetType: { type: String },
+    targetId: { type: String },
+    metadata: { type: Object },
     timestamp: { type: Date, default: Date.now },
 });
 

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);