@mac777/project-pinecone-models 1.1.11 → 1.1.13

package/src/Order.v2.ts

@@ -0,0 +1,252 @@
+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 orderSchema;

package/src/Payment.ts

@@ -3,8 +3,8 @@ import mongoose from 'mongoose';
 // Payment schema for transaction logging
 const paymentSchema = new mongoose.Schema({
   // LINKS
-  orderId: { type: mongoose.Schema.Types.ObjectId, required: true, index: true }, // Which order
-  userId: { type: mongoose.Schema.Types.ObjectId, required: true, index: true }, // Who paid
+  orderId: { type: mongoose.Schema.Types.ObjectId, ref: 'Order', required: true, index: true }, // Which order
+  userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true, index: true }, // Who paid
   
   paymentId: { type: String, required: true, unique: true, index: true }, // Stripe PI (unique)
 

package/src/Payout.ts

@@ -9,10 +9,12 @@ const payoutSchema = new mongoose.Schema({
   // Ownership
   hostId: {
     type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
     required: true
   },
   eventId: {
     type: mongoose.Schema.Types.ObjectId,
+    ref: 'Event',
     required: true
   },
   
@@ -61,12 +63,14 @@ const payoutSchema = new mongoose.Schema({
   // Admin Actions
   approvedBy: {
     type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
   },         // Admin who approved
   approvedAt: {
     type: Date,
   },
   rejectedBy: {
     type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
   },
   rejectedAt: {
     type: Date,

package/src/Ticket.ts

@@ -5,9 +5,9 @@ const ticketSchema = new mongoose.Schema({
   ticketNumber: { type: String, required: true, unique: true, index: true }, // Human-readable: "TKT-EVT123-A3K9-01"
 
   // BELONGS TO
-  orderId: { type: mongoose.Schema.Types.ObjectId, required: true, index: true }, // Parent order
-  eventId: { type: mongoose.Schema.Types.ObjectId, required: true, index: true }, // Which event
-  userId: { type: mongoose.Schema.Types.ObjectId, required: true, index: true }, // Owner
+  orderId: { type: mongoose.Schema.Types.ObjectId, ref: 'Order', required: true, index: true }, // Parent order
+  eventId: { type: mongoose.Schema.Types.ObjectId, ref: 'Event', required: true, index: true }, // Which event
+  userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true, index: true }, // Owner
   ticketVariantId: { type: mongoose.Schema.Types.ObjectId, required: true }, // Which type (VIP, GA, etc)
 
   // DETAILS (denormalized for speed)
@@ -38,10 +38,10 @@ const ticketSchema = new mongoose.Schema({
     default: 'not_checked_in'
   },
   checkedInAt: Date,
-  checkedInBy: mongoose.Schema.Types.ObjectId, // Staff/scanner user ID
+  checkedInBy: { type: mongoose.Schema.Types.ObjectId, ref: 'User' }, // Staff/scanner user ID
 
   // TRANSFER (if user transfers ticket to friend)
-  transferredTo: mongoose.Schema.Types.ObjectId, // New owner user ID
+  transferredTo: { type: mongoose.Schema.Types.ObjectId, ref: 'User' }, // New owner user ID
   transferredAt: Date,
 
   // LIFECYCLE

package/src/User.v2.ts

@@ -0,0 +1,187 @@
+import mongoose from "mongoose";
+
+/* ----------------------------------
+ * Subschemas
+ * ---------------------------------- */
+
+const contactSchema = new mongoose.Schema(
+  {
+    email: {
+      type: String,
+      required: true,
+      lowercase: true,
+      trim: true,
+      index: true
+    },
+    emailVerified: {
+      type: Boolean,
+      default: false
+    },
+    emailVerification: {
+      token: String,
+      expiresAt: Date
+    },
+
+    phone: {
+      type: String
+    },
+    phoneVerified: {
+      type: Boolean,
+      default: false
+    },
+    phoneVerification: {
+      token: String,
+      expiresAt: Date
+    }
+  },
+  { _id: false }
+);
+
+const identitySchema = new mongoose.Schema(
+  {
+    nidNumber: String,
+    nidVerified: {
+      type: Boolean,
+      default: false
+    },
+    verifiedAt: Date
+  },
+  { _id: false }
+);
+
+const payoutSchema = new mongoose.Schema(
+  {
+    method: {
+      type: String,
+      enum: ["bkash", "bank_transfer"],
+      default: "bkash"
+    },
+
+    bkash: {
+      number: String
+    },
+
+    bank: {
+      bankName: String,
+      accountName: String,
+      accountNumber: String,
+      branchName: String,
+      routingNumber: String
+    },
+
+    verified: {
+      type: Boolean,
+      default: false
+    },
+    verifiedAt: Date
+  },
+  { _id: false }
+);
+
+const profileSchema = new mongoose.Schema(
+  {
+    firstName: {
+      type: String,
+      required: true,
+      trim: true
+    },
+    lastName: {
+      type: String,
+      required: true,
+      trim: true
+    },
+    organization: String,
+
+    avatar: {
+      url: String,
+      publicId: String   // S3 / Cloudinary
+    }
+  },
+  { _id: false }
+);
+
+const authSchema = new mongoose.Schema(
+  {
+    provider: {
+      type: String,
+      enum: ["local", "google"],
+      default: "local"
+    },
+
+    password: {
+      type: String,
+      select: false
+    },
+
+    googleId: {
+      type: String,
+      index: true
+    },
+
+    refreshToken: {
+      type: String,
+      select: false
+    }
+  },
+  { _id: false }
+);
+
+/* ----------------------------------
+ * Main User Schema
+ * ---------------------------------- */
+
+const userSchema = new mongoose.Schema(
+  {
+    profile: profileSchema,
+
+    contact: contactSchema,
+
+    identity: identitySchema,
+
+    payout: payoutSchema,
+
+    auth: authSchema,
+
+    role: {
+      type: String,
+      enum: ["user", "host", "admin"],
+      default: "user",
+      index: true
+    },
+
+    status: {
+      type: String,
+      enum: ["active", "suspended", "deleted"],
+      default: "active",
+      index: true
+    },
+
+    lastLoginAt: Date
+  },
+  {
+    timestamps: true,
+    strict: true
+  }
+);
+
+/* ----------------------------------
+ * Indexes
+ * ---------------------------------- */
+
+userSchema.index({ "contact.email": 1 }, { unique: true });
+userSchema.index({ "auth.googleId": 1 }, { sparse: true });
+userSchema.index({ role: 1, status: 1 });
+
+/* ----------------------------------
+ * Virtuals
+ * ---------------------------------- */
+
+userSchema.virtual("fullName").get(function () {
+  return `${this.profile?.firstName || ""} ${this.profile?.lastName || ""}`;
+});
+
+/* ----------------------------------
+ * Export
+ * ---------------------------------- */
+
+export default userSchema;