@mac777/project-pinecone-models 1.0.1 → 1.0.3

package/dist/Event.d.ts

@@ -4,7 +4,6 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
     createdAt: NativeDate;
     updatedAt: NativeDate;
     status: "approved" | "rejected" | "draft" | "pending_approval" | "published" | "live" | "ended" | "cancelled";
-    visibility: "public" | "private" | "unlisted";
     hostId: mongoose.Types.ObjectId;
     title: string;
     categories: string[];
@@ -12,14 +11,14 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
     languages: string[];
     tickets: mongoose.Types.DocumentArray<{
         name: string;
-        status: "active" | "sold_out" | "inactive";
         quantity: number;
         sold: number;
-        remaining: number;
-        visibility: "hidden" | "public" | "invite_only";
         reserved: number;
+        isActive: boolean;
+        isVisible: boolean;
+        wristbandColor: string;
         benefits: string[];
-        description?: string | null | undefined;
+        tier: string;
         price?: {
             amount: number;
             currency: string;
@@ -32,17 +31,16 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
             minPerOrder: number;
             maxPerOrder: number;
         } | null | undefined;
-        tier?: "early_bird" | "regular" | "vip" | null | undefined;
     }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, any, {
         name: string;
-        status: "active" | "sold_out" | "inactive";
         quantity: number;
         sold: number;
-        remaining: number;
-        visibility: "hidden" | "public" | "invite_only";
         reserved: number;
+        isActive: boolean;
+        isVisible: boolean;
+        wristbandColor: string;
         benefits: string[];
-        description?: string | null | undefined;
+        tier: string;
         price?: {
             amount: number;
             currency: string;
@@ -55,17 +53,16 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
             minPerOrder: number;
             maxPerOrder: number;
         } | null | undefined;
-        tier?: "early_bird" | "regular" | "vip" | null | undefined;
     }> & {
         name: string;
-        status: "active" | "sold_out" | "inactive";
         quantity: number;
         sold: number;
-        remaining: number;
-        visibility: "hidden" | "public" | "invite_only";
         reserved: number;
+        isActive: boolean;
+        isVisible: boolean;
+        wristbandColor: string;
         benefits: string[];
-        description?: string | null | undefined;
+        tier: string;
         price?: {
             amount: number;
             currency: string;
@@ -78,11 +75,11 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
             minPerOrder: number;
             maxPerOrder: number;
         } | null | undefined;
-        tier?: "early_bird" | "regular" | "vip" | null | undefined;
     }>;
     termsAccepted: boolean;
     legalPermissionAccepted: boolean;
     platformTermsAccepted: boolean;
+    visibility: "public" | "private" | "unlisted";
     history: mongoose.Types.DocumentArray<{
         timestamp: NativeDate;
         action?: string | null | undefined;
@@ -195,15 +192,20 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
     publishedAt?: NativeDate | null | undefined;
     metrics?: {
         views: number;
+        uniqueViews: number;
+        totalOrders: number;
         ticketsSold: number;
         revenue: number;
         checkIns: number;
+        uniqueViewers: string[];
         reviewCount: number;
+        conversionRate: number;
+        lastViewedAt?: NativeDate | null | undefined;
         averageRating?: number | null | undefined;
     } | null | undefined;
     pricing?: {
+        currency: string;
         platformFee: number;
-        currency?: string | null | undefined;
         paymentProcessingFee?: number | null | undefined;
     } | null | undefined;
     payout?: {
@@ -244,6 +246,8 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
         isFlagged: boolean;
         suspendedUntil?: NativeDate | null | undefined;
         banReason?: string | null | undefined;
+        suspendedAt?: NativeDate | null | undefined;
+        suspensionReason?: string | null | undefined;
     } | null | undefined;
     seo?: {
         keywords: string[];
@@ -255,6 +259,8 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
         isFeatured: boolean;
         isPremium: boolean;
         badges: string[];
+        featuredPriority: number;
+        featuredAt?: NativeDate | null | undefined;
     } | null | undefined;
     submittedAt?: NativeDate | null | undefined;
     deletedAt?: NativeDate | null | undefined;
@@ -265,7 +271,6 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
     createdAt: NativeDate;
     updatedAt: NativeDate;
     status: "approved" | "rejected" | "draft" | "pending_approval" | "published" | "live" | "ended" | "cancelled";
-    visibility: "public" | "private" | "unlisted";
     hostId: mongoose.Types.ObjectId;
     title: string;
     categories: string[];
@@ -273,14 +278,14 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
     languages: string[];
     tickets: mongoose.Types.DocumentArray<{
         name: string;
-        status: "active" | "sold_out" | "inactive";
         quantity: number;
         sold: number;
-        remaining: number;
-        visibility: "hidden" | "public" | "invite_only";
         reserved: number;
+        isActive: boolean;
+        isVisible: boolean;
+        wristbandColor: string;
         benefits: string[];
-        description?: string | null | undefined;
+        tier: string;
         price?: {
             amount: number;
             currency: string;
@@ -293,17 +298,16 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
             minPerOrder: number;
             maxPerOrder: number;
         } | null | undefined;
-        tier?: "early_bird" | "regular" | "vip" | null | undefined;
     }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, any, {
         name: string;
-        status: "active" | "sold_out" | "inactive";
         quantity: number;
         sold: number;
-        remaining: number;
-        visibility: "hidden" | "public" | "invite_only";
         reserved: number;
+        isActive: boolean;
+        isVisible: boolean;
+        wristbandColor: string;
         benefits: string[];
-        description?: string | null | undefined;
+        tier: string;
         price?: {
             amount: number;
             currency: string;
@@ -316,17 +320,16 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
             minPerOrder: number;
             maxPerOrder: number;
         } | null | undefined;
-        tier?: "early_bird" | "regular" | "vip" | null | undefined;
     }> & {
         name: string;
-        status: "active" | "sold_out" | "inactive";
         quantity: number;
         sold: number;
-        remaining: number;
-        visibility: "hidden" | "public" | "invite_only";
         reserved: number;
+        isActive: boolean;
+        isVisible: boolean;
+        wristbandColor: string;
         benefits: string[];
-        description?: string | null | undefined;
+        tier: string;
         price?: {
             amount: number;
             currency: string;
@@ -339,11 +342,11 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
             minPerOrder: number;
             maxPerOrder: number;
         } | null | undefined;
-        tier?: "early_bird" | "regular" | "vip" | null | undefined;
     }>;
     termsAccepted: boolean;
     legalPermissionAccepted: boolean;
     platformTermsAccepted: boolean;
+    visibility: "public" | "private" | "unlisted";
     history: mongoose.Types.DocumentArray<{
         timestamp: NativeDate;
         action?: string | null | undefined;
@@ -456,15 +459,20 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
     publishedAt?: NativeDate | null | undefined;
     metrics?: {
         views: number;
+        uniqueViews: number;
+        totalOrders: number;
         ticketsSold: number;
         revenue: number;
         checkIns: number;
+        uniqueViewers: string[];
         reviewCount: number;
+        conversionRate: number;
+        lastViewedAt?: NativeDate | null | undefined;
         averageRating?: number | null | undefined;
     } | null | undefined;
     pricing?: {
+        currency: string;
         platformFee: number;
-        currency?: string | null | undefined;
         paymentProcessingFee?: number | null | undefined;
     } | null | undefined;
     payout?: {
@@ -505,6 +513,8 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
         isFlagged: boolean;
         suspendedUntil?: NativeDate | null | undefined;
         banReason?: string | null | undefined;
+        suspendedAt?: NativeDate | null | undefined;
+        suspensionReason?: string | null | undefined;
     } | null | undefined;
     seo?: {
         keywords: string[];
@@ -516,6 +526,8 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
         isFeatured: boolean;
         isPremium: boolean;
         badges: string[];
+        featuredPriority: number;
+        featuredAt?: NativeDate | null | undefined;
     } | null | undefined;
     submittedAt?: NativeDate | null | undefined;
     deletedAt?: NativeDate | null | undefined;
@@ -526,7 +538,6 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
     createdAt: NativeDate;
     updatedAt: NativeDate;
     status: "approved" | "rejected" | "draft" | "pending_approval" | "published" | "live" | "ended" | "cancelled";
-    visibility: "public" | "private" | "unlisted";
     hostId: mongoose.Types.ObjectId;
     title: string;
     categories: string[];
@@ -534,14 +545,14 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
     languages: string[];
     tickets: mongoose.Types.DocumentArray<{
         name: string;
-        status: "active" | "sold_out" | "inactive";
         quantity: number;
         sold: number;
-        remaining: number;
-        visibility: "hidden" | "public" | "invite_only";
         reserved: number;
+        isActive: boolean;
+        isVisible: boolean;
+        wristbandColor: string;
         benefits: string[];
-        description?: string | null | undefined;
+        tier: string;
         price?: {
             amount: number;
             currency: string;
@@ -554,17 +565,16 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
             minPerOrder: number;
             maxPerOrder: number;
         } | null | undefined;
-        tier?: "early_bird" | "regular" | "vip" | null | undefined;
     }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, any, {
         name: string;
-        status: "active" | "sold_out" | "inactive";
         quantity: number;
         sold: number;
-        remaining: number;
-        visibility: "hidden" | "public" | "invite_only";
         reserved: number;
+        isActive: boolean;
+        isVisible: boolean;
+        wristbandColor: string;
         benefits: string[];
-        description?: string | null | undefined;
+        tier: string;
         price?: {
             amount: number;
             currency: string;
@@ -577,17 +587,16 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
             minPerOrder: number;
             maxPerOrder: number;
         } | null | undefined;
-        tier?: "early_bird" | "regular" | "vip" | null | undefined;
     }> & {
         name: string;
-        status: "active" | "sold_out" | "inactive";
         quantity: number;
         sold: number;
-        remaining: number;
-        visibility: "hidden" | "public" | "invite_only";
         reserved: number;
+        isActive: boolean;
+        isVisible: boolean;
+        wristbandColor: string;
         benefits: string[];
-        description?: string | null | undefined;
+        tier: string;
         price?: {
             amount: number;
             currency: string;
@@ -600,11 +609,11 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
             minPerOrder: number;
             maxPerOrder: number;
         } | null | undefined;
-        tier?: "early_bird" | "regular" | "vip" | null | undefined;
     }>;
     termsAccepted: boolean;
     legalPermissionAccepted: boolean;
     platformTermsAccepted: boolean;
+    visibility: "public" | "private" | "unlisted";
     history: mongoose.Types.DocumentArray<{
         timestamp: NativeDate;
         action?: string | null | undefined;
@@ -717,15 +726,20 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
     publishedAt?: NativeDate | null | undefined;
     metrics?: {
         views: number;
+        uniqueViews: number;
+        totalOrders: number;
         ticketsSold: number;
         revenue: number;
         checkIns: number;
+        uniqueViewers: string[];
         reviewCount: number;
+        conversionRate: number;
+        lastViewedAt?: NativeDate | null | undefined;
         averageRating?: number | null | undefined;
     } | null | undefined;
     pricing?: {
+        currency: string;
         platformFee: number;
-        currency?: string | null | undefined;
         paymentProcessingFee?: number | null | undefined;
     } | null | undefined;
     payout?: {
@@ -766,6 +780,8 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
         isFlagged: boolean;
         suspendedUntil?: NativeDate | null | undefined;
         banReason?: string | null | undefined;
+        suspendedAt?: NativeDate | null | undefined;
+        suspensionReason?: string | null | undefined;
     } | null | undefined;
     seo?: {
         keywords: string[];
@@ -777,6 +793,8 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
         isFeatured: boolean;
         isPremium: boolean;
         badges: string[];
+        featuredPriority: number;
+        featuredAt?: NativeDate | null | undefined;
     } | null | undefined;
     submittedAt?: NativeDate | null | undefined;
     deletedAt?: NativeDate | null | undefined;

package/dist/Event.js

@@ -77,24 +77,22 @@ const salesWindowSchema = new mongoose_1.default.Schema({
     startDate: Date,
     endDate: Date,
 }, { _id: false });
-const limitsSchema = new mongoose_1.default.Schema({
-    minPerOrder: { type: Number, default: 1 },
-    maxPerOrder: { type: Number, default: 10 },
-}, { _id: false });
 const ticketSchema = new mongoose_1.default.Schema({
     name: { type: String, required: true },
-    description: String,
     price: priceSchema,
     quantity: { type: Number, required: true },
     sold: { type: Number, default: 0 },
-    remaining: { type: Number, default: function () { return this.quantity - this.sold; } },
-    salesWindow: salesWindowSchema,
-    limits: limitsSchema,
-    visibility: { type: String, enum: ['public', 'hidden', 'invite_only'], default: 'public' },
     reserved: { type: Number, default: 0 },
-    status: { type: String, enum: ['active', 'sold_out', 'inactive'], default: 'active' },
+    isActive: { type: Boolean, default: true },
+    isVisible: { type: Boolean, default: true },
+    wristbandColor: { type: String, default: '#000000' },
+    limits: {
+        minPerOrder: { type: Number, default: 1 },
+        maxPerOrder: { type: Number, default: 10 },
+    },
     benefits: [String],
-    tier: { type: String, enum: ['early_bird', 'regular', 'vip'] },
+    tier: { type: String, default: 'regular' },
+    salesWindow: salesWindowSchema,
 });
 const scheduleSchema = new mongoose_1.default.Schema({
     startDate: { type: Date, required: true },
@@ -105,16 +103,25 @@ const scheduleSchema = new mongoose_1.default.Schema({
 }, { _id: false });
 const metricsSchema = new mongoose_1.default.Schema({
     views: { type: Number, default: 0 },
+    uniqueViews: { type: Number, default: 0 },
+    totalOrders: { type: Number, default: 0 },
     ticketsSold: { type: Number, default: 0 },
     revenue: { type: Number, default: 0 },
     checkIns: { type: Number, default: 0 },
+    uniqueViewers: [String],
+    lastViewedAt: Date, // for trending calculation
+    // --- For Review ---
     averageRating: Number,
     reviewCount: { type: Number, default: 0 },
+    conversionRate: { type: Number, default: 0 }, // (ticketsSold / views) * 100
 }, { _id: false });
 const pricingSchema = new mongoose_1.default.Schema({
     platformFee: { type: Number, default: 5 },
     paymentProcessingFee: Number,
-    currency: String,
+    currency: {
+        type: String,
+        default: 'BDT'
+    },
 }, { _id: false });
 const payoutSchema = new mongoose_1.default.Schema({
     status: { type: String, enum: ['pending', 'scheduled', 'completed'] },
@@ -144,6 +151,8 @@ const moderationSchema = new mongoose_1.default.Schema({
     flags: [flagSchema],
     suspendedUntil: Date,
     banReason: String,
+    suspendedAt: Date,
+    suspensionReason: String,
 }, { _id: false });
 const seoSchema = new mongoose_1.default.Schema({
     metaTitle: String,
@@ -155,6 +164,8 @@ const featuresSchema = new mongoose_1.default.Schema({
     isFeatured: { type: Boolean, default: false },
     isPremium: { type: Boolean, default: false },
     badges: [String],
+    featuredAt: Date, // timestamp when featured
+    featuredPriority: { type: Number, default: 0 }, // for ordering featured events
 }, { _id: false });
 const historySchema = new mongoose_1.default.Schema({
     action: String,
@@ -221,6 +232,17 @@ eventSchema.index({ hostId: 1 });
 eventSchema.index({ 'schedule.startDate': 1 });
 eventSchema.index({ type: 1 });
 eventSchema.index({ categories: 1 });
+// New compound indexes for optimized queries
+// For trending events (recent views + high sales)
+eventSchema.index({ 'metrics.lastViewedAt': -1, 'metrics.ticketsSold': -1 });
+// For featured events
+eventSchema.index({ 'features.isFeatured': 1, 'features.featuredPriority': -1 });
+// For filtering by status + visibility + date
+eventSchema.index({ status: 1, visibility: 1, 'schedule.startDate': 1 });
+// For location-based queries with status
+eventSchema.index({ 'venue.address.city': 1, status: 1 });
+// For host's events with status filter
+eventSchema.index({ hostId: 1, status: 1, updatedAt: -1 });
 // Validation: sum(tickets.quantity) <= venue.capacity
 eventSchema.pre('save', function (next) {
     if (this.tickets && this.tickets.length > 0 && this.venue) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mac777/project-pinecone-models",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -12,10 +12,6 @@
     "zod": "^3.22.4",
     "zxcvbn": "^4.4.2"
   },
-  "files": ["dist"],
-  "publishConfig": {
-    "access": "public"
-  },
   "devDependencies": {
     "typescript": "^5.0.0"
   }

package/src/Bkash.ts

@@ -0,0 +1,10 @@
+import mongoose from 'mongoose';
+
+const bkashSchema = new mongoose.Schema({
+    auth_token: {
+        type: String,
+        required: true,
+    }
+}, { timestamps: true });
+
+export default bkashSchema;

package/src/Event.ts

@@ -0,0 +1,301 @@
+import mongoose from 'mongoose';
+
+const mediaSchema = new mongoose.Schema({
+  coverImage: {
+    url: String,
+    thumbnailUrl: String,
+    alt: String,
+  },
+  gallery: [{
+    url: String,
+    caption: String,
+    order: Number,
+  }],
+}, { _id: false });
+
+const addressSchema = new mongoose.Schema({
+  street: String,
+  city: { type: String, required: true },
+  state: String,
+  postalCode: String,
+  country: { type: String, required: true },
+}, { _id: false });
+
+const venueSchema = new mongoose.Schema({
+  name: { type: String, required: true },
+  address: addressSchema,
+  coordinates: {
+    type: {
+      type: String,
+      enum: ['Point'],
+      default: 'Point'
+    },
+    coordinates: [Number] // [lng, lat]
+  },
+  capacity: { type: Number, required: true, min: 10, max: 100000 },
+  type: { type: String, enum: ['indoor', 'outdoor', 'hybrid'] },
+  parking: Boolean,
+  publicTransit: String,
+}, { _id: false });
+
+const contactPersonSchema = new mongoose.Schema({
+  name: { type: String, required: true },
+  phone: { type: String, required: true },
+  email: { type: String, required: true },
+  designation: String,
+}, { _id: false });
+
+const organizerSchema = new mongoose.Schema({
+  role: { type: String, enum: ['event_organizer', 'venue_owner', 'authorized_rep', 'artist'] },
+  companyName: String,
+  contactPerson: contactPersonSchema,
+}, { _id: false });
+
+const documentSchema = new mongoose.Schema({
+  type: { type: String, enum: ['venue_booking', 'permit', 'insurance', 'license', 'portfolio', 'other'] },
+  url: String,
+  filename: String,
+  objectKey: String,
+  uploadedAt: Date,
+  status: { type: String, enum: ['pending', 'approved', 'rejected'] },
+  rejectionReason: String,
+}, { _id: false });
+
+const verificationSchema = new mongoose.Schema({
+  status: { type: String, enum: ['unverified', 'pending', 'verified', 'rejected', 'needs_info'], default: 'unverified' },
+  documents: [documentSchema],
+  additionalInfo: String,
+  adminNotes: String,
+  reviewedBy: mongoose.Schema.Types.ObjectId,
+  reviewedAt: Date,
+  rejectionReason: String,
+  requestedInfo: String,
+}, { _id: false });
+
+const priceSchema = new mongoose.Schema({
+  amount: { type: Number, required: true },
+  currency: { type: String, default: 'USD' },
+}, { _id: false });
+
+const salesWindowSchema = new mongoose.Schema({
+  startDate: Date,
+  endDate: Date,
+}, { _id: false });
+
+const ticketSchema = new mongoose.Schema({
+  name: { type: String, required: true },
+  price: priceSchema,
+  quantity: { type: Number, required: true },
+  sold: { type: Number, default: 0 },
+  reserved: { type: Number, default: 0 },
+  isActive: { type: Boolean, default: true },
+  isVisible: { type: Boolean, default: true },
+  wristbandColor: { type: String, default: '#000000' },
+  limits: {
+    minPerOrder: { type: Number, default: 1 },
+    maxPerOrder: { type: Number, default: 10 },
+  },
+  benefits: [String],
+  tier: { type: String, default: 'regular' },
+  salesWindow: salesWindowSchema,
+});
+
+const scheduleSchema = new mongoose.Schema({
+  startDate: { type: Date, required: true },
+  endDate: { type: Date, required: true },
+  timezone: String,
+  isMultiDay: Boolean,
+  doors: String,
+}, { _id: false });
+
+const metricsSchema = new mongoose.Schema({
+  views: { type: Number, default: 0 },
+  uniqueViews: { type: Number, default: 0 },
+  totalOrders: { type: Number, default: 0 },
+  ticketsSold: { type: Number, default: 0 },
+  revenue: { type: Number, default: 0 },
+  checkIns: { type: Number, default: 0 },
+  uniqueViewers: [String],
+  lastViewedAt: Date, // for trending calculation
+
+  // --- For Review ---
+  averageRating: Number,
+  reviewCount: { type: Number, default: 0 },
+  conversionRate: { type: Number, default: 0 }, // (ticketsSold / views) * 100
+}, { _id: false });
+
+const pricingSchema = new mongoose.Schema({
+  platformFee: { type: Number, default: 5 },
+  paymentProcessingFee: Number,
+  currency: {
+    type: String,
+    default: 'BDT'
+  },
+}, { _id: false });
+
+const payoutSchema = new mongoose.Schema({
+  status: { type: String, enum: ['pending', 'scheduled', 'completed'] },
+  amount: Number,
+  scheduledDate: Date,
+  paidAt: Date,
+  stripePayoutId: String,
+}, { _id: false });
+
+const cancellationSchema = new mongoose.Schema({
+  allowed: { type: Boolean, default: true },
+  refundPercentage: { type: Number, default: 100 },
+  deadlineHours: Number,
+}, { _id: false });
+
+const policiesSchema = new mongoose.Schema({
+  cancellation: cancellationSchema,
+  transferable: { type: Boolean, default: false },
+}, { _id: false });
+
+const flagSchema = new mongoose.Schema({
+  reportedBy: mongoose.Schema.Types.ObjectId,
+  reason: String,
+  description: String,
+  createdAt: { type: Date, default: Date.now },
+  status: { type: String, enum: ['pending', 'resolved', 'dismissed'], default: 'pending' },
+}, { _id: false });
+
+const moderationSchema = new mongoose.Schema({
+  isFlagged: { type: Boolean, default: false },
+  flags: [flagSchema],
+  suspendedUntil: Date,
+  banReason: String,
+  suspendedAt: Date,
+  suspensionReason: String,
+}, { _id: false });
+
+const seoSchema = new mongoose.Schema({
+  metaTitle: String,
+  metaDescription: String,
+  keywords: [String],
+  ogImage: String,
+}, { _id: false });
+
+const featuresSchema = new mongoose.Schema({
+  isFeatured: { type: Boolean, default: false },
+  isPremium: { type: Boolean, default: false },
+  badges: [String],
+  featuredAt: Date, // timestamp when featured
+  featuredPriority: { type: Number, default: 0 }, // for ordering featured events
+}, { _id: false });
+
+const historySchema = new mongoose.Schema({
+  action: String,
+  performedBy: mongoose.Schema.Types.ObjectId,
+  timestamp: { type: Date, default: Date.now },
+  changes: mongoose.Schema.Types.Mixed,
+}, { _id: false });
+
+const eventSchema = new mongoose.Schema({
+  hostId: { type: mongoose.Schema.Types.ObjectId, required: true },
+  slug: String,
+
+  // STEP 1: BASICS
+  title: { type: String, required: true, minlength: 10, maxlength: 100 },
+  type: { type: String, enum: ['concert', 'sports', 'conference', 'festival', 'theater', 'comedy', 'networking', 'workshop', 'other'], required: true },
+  categories: [{ type: String }],
+  tagline: { type: String, maxlength: 150 },
+
+  // STEP 2: DETAILS
+  description: { type: String, minlength: 50, maxlength: 5000 },
+  highlights: [{ type: String }],
+  languages: [String],
+  ageRestriction: { type: String, enum: ['all_ages', '18+', '21+'] },
+  dressCode: String,
+
+  media: mediaSchema,
+
+  // STEP 3: DATE, TIME & LOCATION
+  schedule: scheduleSchema,
+  venue: venueSchema,
+
+  // STEP 4: VERIFICATION
+  organizer: organizerSchema,
+  verification: verificationSchema,
+
+  // STEP 5: TICKETS
+  tickets: [ticketSchema],
+  termsAccepted: { type: Boolean, default: false },
+  legalPermissionAccepted: { type: Boolean, default: false },
+  platformTermsAccepted: { type: Boolean, default: false },
+  // STATUS & WORKFLOW
+  status: { type: String, enum: ['draft', 'pending_approval', 'approved', 'rejected', 'published', 'live', 'ended', 'cancelled'], default: 'draft' },
+  rejectionReason: String,
+  visibility: { type: String, enum: ['public', 'private', 'unlisted'], default: 'public' },
+  publishedAt: Date,
+
+  // METRICS
+  metrics: metricsSchema,
+
+  // BUSINESS
+  pricing: pricingSchema,
+  payout: payoutSchema,
+
+  // POLICIES
+  policies: policiesSchema,
+
+  // MODERATION
+  moderation: moderationSchema,
+
+  // SEO
+  seo: seoSchema,
+
+  // FEATURES
+  features: featuresSchema,
+
+  // AUDIT
+  createdAt: { type: Date, default: Date.now },
+  updatedAt: { type: Date, default: Date.now },
+  submittedAt: Date,
+  history: [historySchema],
+  deletedAt: Date,
+});
+
+// Indexes
+eventSchema.index({ slug: 1 });
+eventSchema.index({ 'venue.coordinates': '2dsphere' });
+eventSchema.index({ status: 1, visibility: 1 });
+eventSchema.index({ hostId: 1 });
+eventSchema.index({ 'schedule.startDate': 1 });
+eventSchema.index({ type: 1 });
+eventSchema.index({ categories: 1 });
+
+// New compound indexes for optimized queries
+// For trending events (recent views + high sales)
+eventSchema.index({ 'metrics.lastViewedAt': -1, 'metrics.ticketsSold': -1 });
+
+// For featured events
+eventSchema.index({ 'features.isFeatured': 1, 'features.featuredPriority': -1 });
+
+// For filtering by status + visibility + date
+eventSchema.index({ status: 1, visibility: 1, 'schedule.startDate': 1 });
+
+// For location-based queries with status
+eventSchema.index({ 'venue.address.city': 1, status: 1 });
+
+// For host's events with status filter
+eventSchema.index({ hostId: 1, status: 1, updatedAt: -1 });
+
+// Validation: sum(tickets.quantity) <= venue.capacity
+eventSchema.pre('save', function(next) {
+  if (this.tickets && this.tickets.length > 0 && this.venue) {
+    const totalCapacity = this.tickets.reduce((sum, ticket) => sum + ticket.quantity, 0);
+    if (totalCapacity > this.venue.capacity) {
+      return next(new Error('Total ticket quantity exceeds venue capacity'));
+    }
+  }
+  next();
+});
+
+// Update updatedAt on save
+eventSchema.pre('save', function(next) {
+  this.updatedAt = new Date();
+  next();
+});
+
+export default eventSchema;

package/src/Media.ts

@@ -0,0 +1,36 @@
+import mongoose from 'mongoose';
+
+const mediaSchema = new mongoose.Schema({
+  userId: { type: mongoose.Schema.Types.ObjectId, required: true },
+  type: { type: String, enum: ['event_cover', 'event_gallery', 'verification_doc'], required: true },
+  provider: { type: String, enum: ['imagekit', 'backblaze'], required: true },
+  status: { type: String, enum: ['temp', 'permanent', 'deleted'], required: true },
+
+  // ImageKit specific
+  fileId: String,
+  url: String,
+  thumbnailUrl: String,
+
+  // Backblaze specific
+  bucketName: String,
+  objectKey: String,
+
+  // Metadata
+  filename: { type: String, required: true },
+  mimeType: { type: String, required: true },
+  size: { type: Number, required: false },
+
+  // Lifecycle
+  uploadedAt: { type: Date, default: Date.now },
+  movedToPermanentAt: Date,
+  expiresAt: Date,  // For temp files
+  deletedAt: Date,
+});
+
+// Indexes
+mediaSchema.index({ userId: 1 });
+mediaSchema.index({ status: 1 });
+mediaSchema.index({ expiresAt: 1 });
+mediaSchema.index({ uploadedAt: 1 });
+
+export default mediaSchema;

package/src/Order.ts

@@ -0,0 +1,201 @@
+import mongoose from 'mongoose';
+
+// 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
+  }
+}, { _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']
+  },
+  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 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();
+});
+
+// Update updatedAt on save
+orderSchema.pre('save', function(next) {
+  // Note: We don't have updatedAt field, but could add if needed
+  next();
+});
+
+export default orderSchema;

package/src/Payment.ts

@@ -0,0 +1,61 @@
+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
+  
+  paymentId: { type: String, required: true, unique: true, index: true }, // Stripe PI (unique)
+
+  // MONEY
+  amount: { type: Number, required: true },
+  currency: { type: String, required: true, default: 'BDT' },
+
+  // STATUS
+  status: {
+    type: String,
+    required: true,
+    enum: ['pending', 'succeeded', 'failed', 'refunded'],
+    default: 'pending'
+  },
+
+  // METADATA
+  paymentMethod: { type: String, required: true, enum: ['bkash', 'card'] },
+  last4: String, // Card last 4 digits (for receipt)
+  brand: { type: String, enum: ['visa', 'mastercard', 'amex', 'discover'] }, // Card brand
+
+  // FAILURE (if failed)
+  failureCode: String, // "insufficient_funds", "card_declined", etc.
+  failureMessage: String,
+
+  // REFUND (if refunded)
+  refundId: String, // Stripe refund ID
+  refundAmount: Number,
+  refundedAt: Date,
+
+  // TIMESTAMPS
+  createdAt: { type: Date, default: Date.now },
+  succeededAt: Date,
+  failedAt: Date,
+});
+
+// Indexes for performance
+paymentSchema.index({ orderId: 1 });
+paymentSchema.index({ userId: 1, createdAt: -1 });
+paymentSchema.index({ status: 1, createdAt: -1 });
+
+// Pre-save middleware to set timestamps based on status
+paymentSchema.pre('save', function(next) {
+  if (this.isModified('status')) {
+    const now = new Date();
+    if (this.status === 'succeeded' && !this.succeededAt) {
+      this.succeededAt = now;
+    } else if (this.status === 'failed' && !this.failedAt) {
+      this.failedAt = now;
+    }
+  }
+  next();
+});
+
+export default paymentSchema;

package/src/Ticket.ts

@@ -0,0 +1,105 @@
+import mongoose from 'mongoose';
+
+// Ticket schema for individual issued tickets
+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
+  ticketVariantId: { type: mongoose.Schema.Types.ObjectId, required: true }, // Which type (VIP, GA, etc)
+
+  // DETAILS (denormalized for speed)
+  eventTitle: { type: String, required: true },
+  eventDate: { type: Date, required: true },
+  eventVenue: { type: String, required: true },
+  ticketType: { type: String, required: true }, // "VIP Pass"
+  price: { type: Number, required: true },
+
+  // QR CODE
+  qrCode: { type: String, unique: true, required: true }, // Unique hash: SHA256(ticketId + secret)
+  qrCodeUrl: { type: String, required: true }, // ImageKit/S3 URL to QR image
+
+  // STATUS
+  status: {
+    type: String,
+    required: true,
+    enum: ['valid', 'used', 'cancelled', 'refunded', 'transferred'],
+    default: 'valid',
+    index: true
+  },
+
+  // CHECK-IN
+  checkInStatus: {
+    type: String,
+    required: true,
+    enum: ['not_checked_in', 'checked_in'],
+    default: 'not_checked_in'
+  },
+  checkedInAt: Date,
+  checkedInBy: mongoose.Schema.Types.ObjectId, // Staff/scanner user ID
+
+  // TRANSFER (if user transfers ticket to friend)
+  transferredTo: mongoose.Schema.Types.ObjectId, // New owner user ID
+  transferredAt: Date,
+
+  // LIFECYCLE
+  issuedAt: { type: Date, default: Date.now }, // When ticket was created
+  validUntil: { type: Date, required: true }, // Event end date (after this, ticket expires)
+
+  // SECURITY
+  secretHash: { type: String, required: true }, // Internal validation hash (never exposed)
+});
+
+
+// Pre-save middleware to set default validUntil if not provided
+ticketSchema.pre('save', function(next) {
+  if (this.isNew && !this.validUntil && this.eventDate) {
+    // Set validUntil to end of event day if eventDate is provided
+    const eventEnd = new Date(this.eventDate);
+    eventEnd.setHours(23, 59, 59, 999); // End of the event day
+    this.validUntil = eventEnd;
+  }
+  next();
+});
+
+// Virtual for checking if ticket is expired
+ticketSchema.virtual('isExpired').get(function() {
+  return new Date() > this.validUntil;
+});
+
+// Method to check if ticket can be used
+ticketSchema.methods.canBeUsed = function() {
+  return this.status === 'valid' &&
+         this.checkInStatus === 'not_checked_in' &&
+         !this.isExpired;
+};
+
+// Method to mark as used (check-in)
+ticketSchema.methods.checkIn = function(staffUserId: string) {
+  if (!this.canBeUsed()) {
+    throw new Error('Ticket cannot be checked in');
+  }
+
+  this.checkInStatus = 'checked_in';
+  this.checkedInAt = new Date();
+  this.checkedInBy = new mongoose.Types.ObjectId(staffUserId);
+
+  return this.save();
+};
+
+// Method to transfer ticket
+ticketSchema.methods.transfer = function(newOwnerId: string) {
+  if (this.status !== 'valid') {
+    throw new Error('Only valid tickets can be transferred');
+  }
+
+  this.transferredTo = new mongoose.Types.ObjectId(newOwnerId);
+  this.transferredAt = new Date();
+  this.userId = new mongoose.Types.ObjectId(newOwnerId); // Update ownership
+
+  return this.save();
+};
+
+export default ticketSchema;

package/src/User.ts

@@ -0,0 +1,47 @@
+import mongoose from "mongoose";
+
+const userSchema = new mongoose.Schema({
+    firstName: {
+        type: String,
+        required: true
+    },
+    lastName: {
+        type: String,
+        required: true
+    },
+    email: {
+        type: String,
+        required: true,
+        unique: true
+    },
+    password: {
+        type: String,
+        required: false
+    },
+    organization: {
+        type: String,
+        required: false
+    },
+    role: {
+        type: String,
+        enum: ['user', 'host', 'admin'],
+        default: 'user'
+    },
+    refreshToken: {
+        type: String,
+        required: false
+    },
+    provider: {
+        type: String,
+        enum: ['google', 'local'],
+        default: 'local'
+    },
+    googleId: {
+        type: String,
+        required: false
+    }
+}, {
+    timestamps: true
+})
+
+export default userSchema;

package/src/index.ts

@@ -0,0 +1,9 @@
+// Shared database models for Pinecone microservices
+export { default as eventSchema } from './Event';
+export { default as ticketSchema } from './Ticket';
+export { default as mediaSchema } from './Media';
+export { default as bkashSchema } from './Bkash';
+export { default as paymentSchema } from './Payment';
+export { default as orderSchema } from './Order';
+export { default as userSchema } from './User';
+

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}