@mac777/project-pinecone-models 1.0.1 → 1.0.2

package/dist/Event.d.ts

@@ -19,6 +19,7 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
         visibility: "hidden" | "public" | "invite_only";
         reserved: number;
         benefits: string[];
+        tier: string;
         description?: string | null | undefined;
         price?: {
             amount: number;
@@ -32,7 +33,6 @@ 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";
@@ -42,6 +42,7 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
         visibility: "hidden" | "public" | "invite_only";
         reserved: number;
         benefits: string[];
+        tier: string;
         description?: string | null | undefined;
         price?: {
             amount: number;
@@ -55,7 +56,6 @@ 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";
@@ -65,6 +65,7 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
         visibility: "hidden" | "public" | "invite_only";
         reserved: number;
         benefits: string[];
+        tier: string;
         description?: string | null | undefined;
         price?: {
             amount: number;
@@ -78,7 +79,6 @@ 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;
@@ -280,6 +280,7 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
         visibility: "hidden" | "public" | "invite_only";
         reserved: number;
         benefits: string[];
+        tier: string;
         description?: string | null | undefined;
         price?: {
             amount: number;
@@ -293,7 +294,6 @@ 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";
@@ -303,6 +303,7 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
         visibility: "hidden" | "public" | "invite_only";
         reserved: number;
         benefits: string[];
+        tier: string;
         description?: string | null | undefined;
         price?: {
             amount: number;
@@ -316,7 +317,6 @@ 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";
@@ -326,6 +326,7 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
         visibility: "hidden" | "public" | "invite_only";
         reserved: number;
         benefits: string[];
+        tier: string;
         description?: string | null | undefined;
         price?: {
             amount: number;
@@ -339,7 +340,6 @@ 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;
@@ -541,6 +541,7 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
         visibility: "hidden" | "public" | "invite_only";
         reserved: number;
         benefits: string[];
+        tier: string;
         description?: string | null | undefined;
         price?: {
             amount: number;
@@ -554,7 +555,6 @@ 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";
@@ -564,6 +564,7 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
         visibility: "hidden" | "public" | "invite_only";
         reserved: number;
         benefits: string[];
+        tier: string;
         description?: string | null | undefined;
         price?: {
             amount: number;
@@ -577,7 +578,6 @@ 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";
@@ -587,6 +587,7 @@ declare const eventSchema: mongoose.Schema<any, mongoose.Model<any, any, any, an
         visibility: "hidden" | "public" | "invite_only";
         reserved: number;
         benefits: string[];
+        tier: string;
         description?: string | null | undefined;
         price?: {
             amount: number;
@@ -600,7 +601,6 @@ 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;

package/dist/Event.js

@@ -94,7 +94,7 @@ const ticketSchema = new mongoose_1.default.Schema({
     reserved: { type: Number, default: 0 },
     status: { type: String, enum: ['active', 'sold_out', 'inactive'], default: 'active' },
     benefits: [String],
-    tier: { type: String, enum: ['early_bird', 'regular', 'vip'] },
+    tier: { type: String, required: true, default: 'regular' },
 });
 const scheduleSchema = new mongoose_1.default.Schema({
     startDate: { type: Date, required: true },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mac777/project-pinecone-models",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "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,274 @@
+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 limitsSchema = new mongoose.Schema({
+  minPerOrder: { type: Number, default: 1 },
+  maxPerOrder: { type: Number, default: 10 },
+}, { _id: false });
+
+const ticketSchema = new mongoose.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(this: any) { 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' },
+  benefits: [String],
+  tier: { type: String, required: true, default: 'regular' },
+});
+
+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 },
+  ticketsSold: { type: Number, default: 0 },
+  revenue: { type: Number, default: 0 },
+  checkIns: { type: Number, default: 0 },
+  averageRating: Number,
+  reviewCount: { type: Number, default: 0 },
+}, { _id: false });
+
+const pricingSchema = new mongoose.Schema({
+  platformFee: { type: Number, default: 5 },
+  paymentProcessingFee: Number,
+  currency: String,
+}, { _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,
+}, { _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],
+}, { _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 });
+
+// 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"]
+}