flykup_model_production 1.0.0

package/models/blockedRegion.models.js

@@ -0,0 +1,27 @@
+import mongoose from 'mongoose';
+
+const blockedRegionSchema = new mongoose.Schema({
+  region: {
+    type: String,
+    trim: true,
+  },
+  regionName: {
+    type: String,
+    trim: true,
+  },
+  country: {
+    type: String,
+    trim: true,
+  },
+  countryName: {
+    type: String,
+    trim: true,
+  },
+
+}, {
+  timestamps: true
+});
+
+const BlockedRegion = mongoose.model('BlockedRegion', blockedRegionSchema);
+
+export default BlockedRegion;

package/models/category.model.js

@@ -0,0 +1,29 @@
+import mongoose from 'mongoose';
+
+const SubcategorySchema = new mongoose.Schema({
+  name: {
+    type: String,
+    required: true,
+  },
+  minFee: {
+    type: Number,
+    required: true,
+  },
+  maxFee: {
+    type: Number,
+    required: true,
+  },
+});
+
+const CategorySchema = new mongoose.Schema({
+ 
+  categoryName: {
+    type: String,
+    required: true,
+  },
+  subcategories: [SubcategorySchema],
+}, { timestamps: true });
+
+const Category = mongoose.model('Category', CategorySchema);
+
+export default Category;

package/models/chat.model.js

@@ -0,0 +1,496 @@
+import mongoose from "mongoose";
+
+// Chat Room Schema - Handles different types of conversations
+const ChatRoomSchema = new mongoose.Schema({
+  // Room identification
+  roomType: {
+    type: String,
+    enum: [
+      'direct_message',    // 1-on-1 chat
+      'group_chat',        // Group conversations
+      'live_stream_chat',  // Chat during live streams
+      'product_inquiry',   // Product-specific conversations
+      'seller_support',    // Seller support conversations
+      'order_related'      // Order-related conversations
+    ],
+    required: true
+  },
+
+  // Participants
+  participants: [{
+    userId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'users',
+      required: true
+    },
+    userType: {
+      type: String,
+      enum: ['user', 'seller', 'admin'],
+      required: true
+    },
+    joinedAt: {
+      type: Date,
+      default: Date.now
+    },
+    leftAt: {
+      type: Date,
+      default: null
+    },
+    role: {
+      type: String,
+      enum: ['member', 'moderator', 'admin'],
+      default: 'member'
+    },
+    // Notification settings per participant
+    notifications: {
+      enabled: { type: Boolean, default: true },
+      mentions: { type: Boolean, default: true },
+      messages: { type: Boolean, default: true }
+    },
+    // Read receipts
+    lastReadMessageId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'chatmessages',
+      default: null
+    },
+    lastReadAt: {
+      type: Date,
+      default: null
+    },
+    isFavorite: {
+      type: Boolean,
+      default: false
+    },
+    favoritedAt: {
+      type: Date,
+      default: null
+    },
+    isPinned: { type: Boolean, default: false }, // Add this field
+    pinnedAt: Date, // Add this field
+  }],
+
+  // Room metadata
+  roomName: {
+    type: String,
+    maxLength: 100,
+    default: null // For group chats
+  },
+
+  roomDescription: {
+    type: String,
+    maxLength: 500,
+    default: null
+  },
+
+  // Room settings
+  settings: {
+    isPrivate: { type: Boolean, default: false },
+    allowFileSharing: { type: Boolean, default: true },
+    allowVoiceMessages: { type: Boolean, default: true },
+    maxParticipants: { type: Number, default: 100 },
+    autoDeleteMessages: { type: Boolean, default: false },
+    autoDeleteAfterDays: { type: Number, default: 30 },
+    moderationEnabled: { type: Boolean, default: false }
+  },
+
+  // Context-specific data
+  contextData: {
+    // For product inquiries
+    productId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'productlistings',
+      default: null
+    },
+
+    // For live stream chats
+    liveStreamId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'shows',
+      default: null
+    },
+
+    // For order-related chats
+    // orderId: {
+    //   type: mongoose.Schema.Types.ObjectId,
+    //   ref: 'orders',
+    //   default: null
+    // },
+
+    // For seller support
+    supportTicketId: {
+      type: String,
+      default: null
+    }
+  },
+
+  // Last activity
+  lastActivity: {
+    lastMessageId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'chatmessages',
+      default: null
+    },
+    lastMessageAt: {
+      type: Date,
+      default: Date.now
+    },
+    lastMessagePreview: {
+      type: String,
+      maxLength: 200,
+      default: null
+    }
+  },
+
+  // Room status
+  status: {
+    type: String,
+    enum: ['active', 'archived', 'blocked', 'deleted'],
+    default: 'active'
+  },
+
+  // Created by
+  createdBy: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'users',
+    required: true
+  }
+}, {
+  timestamps: true,
+  strict: true
+});
+
+// Chat Message Schema
+const ChatMessageSchema = new mongoose.Schema({
+  // Message identification
+  chatRoomId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'chatrooms',
+    required: true,
+    index: true
+  },
+
+  // Sender information
+  senderId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'users',
+    required: true,
+    index: true
+  },
+
+  senderType: {
+    type: String,
+    enum: ['user', 'seller', 'admin', 'system'],
+    required: true
+  },
+
+  // Message content
+  messageType: {
+    type: String,
+    enum: [
+      'text',
+      'image',
+      'video',
+      'audio',
+      'file',
+      'product_share',
+      'live_stream_share',
+      'location',
+      'contact',
+      'system_message',
+      'emoji_reaction',
+      'poll',
+      'payment_request'
+    ],
+    required: true
+  },
+
+  content: {
+    // For text messages
+    text: {
+      type: String,
+      maxLength: 2000,
+      default: null
+    },
+
+    // For media messages
+    media: {
+      type: {
+        type: String,
+        enum: ['image', 'video', 'audio', 'file'],
+        default: null
+      },
+      url: { type: String, default: null },
+      thumbnail: { type: String, default: null },
+      fileName: { type: String, default: null },
+      fileSize: { type: Number, default: null },
+      duration: { type: Number, default: null }, // For audio/video
+      dimensions: {
+        width: { type: Number, default: null },
+        height: { type: Number, default: null }
+      }
+    },
+
+    // For product shares
+    productShare: {
+      productId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'products',
+        default: null
+      },
+      productName: { type: String, default: null },
+      productImage: { type: String, default: null },
+      productPrice: { type: Number, default: null }
+    },
+
+    // For live stream shares
+    liveStreamShare: {
+      liveStreamId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'livestreams',
+        default: null
+      },
+      streamTitle: { type: String, default: null },
+      streamThumbnail: { type: String, default: null },
+      isLive: { type: Boolean, default: false }
+    },
+
+    // For location sharing
+    location: {
+      latitude: { type: Number, default: null },
+      longitude: { type: Number, default: null },
+      address: { type: String, default: null }
+    },
+
+    // For system messages
+    systemMessage: {
+      type: { type: String, default: null },
+      data: { type: mongoose.Schema.Types.Mixed, default: null }
+    },
+
+    // For polls
+    poll: {
+      question: { type: String, default: null },
+      options: [{ type: String }],
+      allowMultiple: { type: Boolean, default: false },
+      expiresAt: { type: Date, default: null }
+    }
+  },
+
+  // Message metadata
+  metadata: {
+    // Reply to another message
+    replyToMessageId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'chatmessages',
+      default: null
+    },
+
+    // Forward information
+    forwardedFrom: {
+      chatRoomId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'chatrooms',
+        default: null
+      },
+      originalMessageId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'chatmessages',
+        default: null
+      }
+    },
+
+    // Mentions
+    mentions: [{
+      userId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'users'
+      },
+      userName: { type: String }
+    }],
+
+    // Hashtags
+    hashtags: [{ type: String }],
+
+    // Message editing
+    isEdited: { type: Boolean, default: false },
+    editedAt: { type: Date, default: null },
+    editHistory: [{
+      content: { type: String },
+      editedAt: { type: Date }
+    }]
+  },
+
+  // Message status
+  status: {
+    type: String,
+    enum: ['sent', 'delivered', 'read', 'failed', 'deleted'],
+    default: 'sent'
+  },
+
+  // Delivery and read receipts
+  deliveryStatus: [{
+    userId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'users'
+    },
+    deliveredAt: { type: Date },
+    readAt: { type: Date }
+  }],
+
+  // Message reactions
+  reactions: [{
+    userId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'users'
+    },
+    emoji: { type: String },
+    reactedAt: { type: Date, default: Date.now }
+  }],
+
+  // Moderation
+  moderation: {
+    isReported: { type: Boolean, default: false },
+    reportCount: { type: Number, default: 0 },
+    isBlocked: { type: Boolean, default: false },
+    blockedReason: { type: String, default: null },
+    moderatedBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'users',
+      default: null
+    }
+  },
+
+  // Scheduled messages
+  scheduledFor: {
+    type: Date,
+    default: null
+  },
+
+  // Auto-delete
+  expiresAt: {
+    type: Date,
+    default: null
+  }
+}, {
+  timestamps: true,
+  strict: true
+});
+
+// Chat Room Member Schema - For tracking membership history
+const ChatRoomMemberSchema = new mongoose.Schema({
+  chatRoomId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'chatrooms',
+    required: true
+  },
+
+  userId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'users',
+    required: true
+  },
+
+  userType: {
+    type: String,
+    enum: ['user', 'seller', 'admin'],
+    required: true
+  },
+
+  role: {
+    type: String,
+    enum: ['member', 'moderator', 'admin'],
+    default: 'member'
+  },
+
+  joinedAt: {
+    type: Date,
+    default: Date.now
+  },
+
+  leftAt: {
+    type: Date,
+    default: null
+  },
+
+  addedBy: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'users',
+    default: null
+  },
+
+  removedBy: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'users',
+    default: null
+  },
+
+  status: {
+    type: String,
+    enum: ['active', 'left', 'removed', 'banned'],
+    default: 'active'
+  }
+}, {
+  timestamps: true
+});
+
+// Block/Mute Schema - For user blocking and muting
+const ChatBlockSchema = new mongoose.Schema({
+  blockerId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'users',
+    required: true
+  },
+
+  blockedUserId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'users',
+    required: true
+  },
+
+  blockType: {
+    type: String,
+    enum: ['block', 'mute'],
+    required: true
+  },
+
+  reason: {
+    type: String,
+    maxLength: 500,
+    default: null
+  },
+
+  expiresAt: {
+    type: Date,
+    default: null // null means permanent
+  },
+
+  isActive: {
+    type: Boolean,
+    default: true
+  }
+}, {
+  timestamps: true
+});
+
+// Indexes for better performance
+ChatRoomSchema.index({ 'participants.userId': 1, roomType: 1 });
+ChatRoomSchema.index({ 'contextData.productId': 1 });
+ChatRoomSchema.index({ 'contextData.liveStreamId': 1 });
+ChatRoomSchema.index({ 'lastActivity.lastMessageAt': -1 });
+
+ChatMessageSchema.index({ chatRoomId: 1, createdAt: -1 });
+ChatMessageSchema.index({ senderId: 1, createdAt: -1 });
+ChatMessageSchema.index({ 'metadata.mentions.userId': 1 });
+
+ChatRoomMemberSchema.index({ chatRoomId: 1, userId: 1 });
+ChatRoomMemberSchema.index({ userId: 1, status: 1 });
+
+ChatBlockSchema.index({ blockerId: 1, blockedUserId: 1 });
+
+// Models
+const ChatRoom = mongoose.model('chatrooms', ChatRoomSchema);
+const ChatMessage = mongoose.model('chatmessages', ChatMessageSchema);
+const ChatRoomMember = mongoose.model('chatroommembers', ChatRoomMemberSchema);
+const ChatBlock = mongoose.model('chatblocks', ChatBlockSchema);
+
+export { ChatRoom, ChatMessage, ChatRoomMember, ChatBlock };

package/models/coHostInvitation.model.js

@@ -0,0 +1,56 @@
+import mongoose, { Schema } from "mongoose";
+
+const coHostInviteSchema = new Schema(
+  {
+    show: { type: Schema.Types.ObjectId, ref: "shows", required: true },
+    host: {
+      userId: { type: Schema.Types.ObjectId, ref: "users", required: true },
+      hostId: {
+        type: mongoose.Schema.Types.ObjectId,
+        required: true,
+        refPath: "host.hostModel",
+      },
+      hostModel: {
+        type: String,
+        required: true,
+        enum: {
+          values: ["sellers", "dropshippers"],
+          message: `{VALUE} is invalid host model`,
+        },
+      }
+    },
+    cohost: {
+      userId: { type: Schema.Types.ObjectId, ref: "users", required: true },
+      hostId: {
+        type: mongoose.Schema.Types.ObjectId,
+        required: true,
+        refPath: "cohost.hostModel",
+      },
+      hostModel: {
+        type: String,
+        required: true,
+        enum: {
+          values: ["sellers", "dropshippers"],
+          message: `{VALUE} is invalid cohost model`,
+        },
+      }
+    },
+    status: {
+      type: String,
+      enum: ["pending", "accepted", "rejected", "cancelled", "left"],
+      default: "pending",
+      index: true
+    },
+    joinedAt: Date,
+    leftAt: Date,
+    liveStreamId: String,
+  },
+  { timestamps: true }
+);
+
+coHostInviteSchema.index({ show: 1, status: 1 });
+coHostInviteSchema.index({ "cohost.userId": 1, status: 1 });
+
+const CoHostInvite = mongoose.model("cohostinvites", coHostInviteSchema);
+
+export default CoHostInvite;

package/models/follow.model.js

@@ -0,0 +1,37 @@
+import mongoose from "mongoose";
+
+const FollowSchema = new mongoose.Schema(
+  {
+    follower: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "users",
+      required: true,
+    },
+    following: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "users",
+      required: true,
+    },
+  },
+  { timestamps: true }
+);
+
+// Prevent duplicate follows
+FollowSchema.index({ follower: 1, following: 1 }, { unique: true });
+
+// Add helpful indexes for efficient querying
+FollowSchema.index({ follower: 1 });
+FollowSchema.index({ following: 1 });
+
+FollowSchema.pre('save', function(next) {
+  if (this.follower.equals(this.following)) {
+    const err = new Error("Cannot follow yourself");
+    next(err);
+  } else {
+    next();
+  }
+});
+
+const Follow = mongoose.model("follows", FollowSchema);
+
+export default Follow;

package/models/loginlogs.model.js

@@ -0,0 +1,25 @@
+import mongoose from 'mongoose';
+
+const loginLogSchema = new mongoose.Schema({
+    userId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "users",
+        required: true,
+    },
+    ip: { type: String, required: true },
+    country: String,
+    region: String,
+    city: String,
+    location: String,
+    device: Object,
+    browser: Object,
+    os: Object,
+    loginType: String,
+    status: { type: String, enum: ['active', 'loggedOut'], default: 'active' }, // 🔥 new field
+    lastActivity: { type: Date, default: Date.now }, // 🔥 to track token refresh or other actions
+    time: { type: Date, default: Date.now }
+}, { timestamps: true });
+
+const LoginLog = mongoose.model('LoginLog', loginLogSchema);
+
+export default LoginLog;