flykup_model_production 1.0.0

package/auth.js

@@ -0,0 +1,14 @@
+import { VALID_TOKENS } from "./config.js";
+
+// console.log('VALID_TOKENS', VALID_TOKENS)
+
+
+export function verifyAccessToken(token) {
+  if (!token) {
+    throw new Error('❌ Unauthorized: Missing token for shared models');
+  }
+  if (!VALID_TOKENS.includes(token)) {
+    throw new Error('❌ Unauthorized: Invalid token for shared models');
+  }
+  console.log('✅ Token validated for shared models');
+}

package/config.js

@@ -0,0 +1 @@
+export const VALID_TOKENS = ['Flykup_backend','Flykup_bga','Flykup_tapntake','Flykup_erp','Flykup_control_backend','Flykup_livestream','Flykup_shoppablevideos','Flykup_webinar','Flykup_creatordock','Flykup_socialpulse'];

package/db_connection.js

@@ -0,0 +1,23 @@
+import mongoose from 'mongoose';
+
+let isConnected = false;
+
+export async function connectToDB(uri) {
+  if (isConnected) return;
+
+  if (!uri) {
+    throw new Error('❌ No MongoDB URI provided to connectToDB');
+  }
+
+  try {
+    await mongoose.connect(uri, {
+      maxPoolSize: 10,
+      
+    });
+    isConnected = true;
+    console.log(`✅ Shared-models DB connected`);
+  } catch (err) {
+    console.error('❌ DB connection failed:', err);
+    throw err;
+  }
+}

package/index.js

@@ -0,0 +1,127 @@
+import { verifyAccessToken } from './auth.js';
+import { connectToDB } from './db_connection.js';
+
+
+import Admin from './models/admin.model.js';
+import BlockedRegion from './models/blockedRegion.models.js';
+import Category from './models/category.model.js';
+import CoHostInvitation from './models/coHostInvitation.model.js';
+import Follow from './models/follow.model.js';
+import LoginLogs from './models/loginlogs.model.js';
+import Notification from './models/notification.model.js';
+import ProductListing from './models/productListing.model.js';
+import Seller from './models/seller.model.js';
+import Settings from './models/settings.model.js';
+import Shipper from './models/shipper.model.js';
+import ShoppableVideo from './models/shoppableVideo.model.js';
+import ShoppableVideoComment from './models/shoppableVideoComment.model.js';
+import ShoppableVideoLike from './models/shoppableVideoLike.model.js';
+import ShoppableVideoSave from './models/shoppableVideoSave.model.js';
+import Shows from './models/shows.model.js';
+import Stock from './models/stock.model.js';
+import User from './models/user.model.js';
+import ProductInteraction from './models/ProductInteraction.model.js';
+import Wishlist from './models/Wishlist.model.js';
+import { ChatBlock, ChatMessage, ChatRoom, ChatRoomMember } from './models/chat.model.js';
+import Order from './models/order.modal.js';
+import LiveStreamInteraction from './models/LiveStreamInteraction.model.js';
+import ProfileInteraction from './models/profileInteractions.model.js';
+import RegisterShow from './models/registerShow.model.js';
+import { Review, ReviewType } from './models/Review.model.js';
+import ShoppableVideoInteraction from './models/ShoppableInteraction.model.js';
+
+let initialized = false;
+
+export async function initializeSharedModels({ token, dbUri }) {
+  verifyAccessToken(token);
+
+  if (!dbUri) {
+    throw new Error('❌ MONGO_URI must be provided by the backend');
+  }
+
+  await connectToDB(dbUri);
+  initialized = true;
+}
+
+function ensureInitialized() {
+  if (!initialized) {
+    throw new Error('❌ Shared models not initialized. Call initializeSharedModels() first.');
+  }
+}
+
+function createModelProxy(model) {
+  return new Proxy(model, {
+    get(target, prop) {
+      ensureInitialized();
+      return target[prop];
+    }
+  });
+}
+
+
+export const AdminModel = createModelProxy(Admin);
+export const BlockedRegionModel = createModelProxy(BlockedRegion);
+export const CategoryModel = createModelProxy(Category);
+export const CoHostInvitationModel = createModelProxy(CoHostInvitation);
+export const FollowModel = createModelProxy(Follow);
+export const LoginLogsModel = createModelProxy(LoginLogs);
+export const NotificationModel = createModelProxy(Notification);
+export const ProductListingModel = createModelProxy(ProductListing);
+export const SellerModel = createModelProxy(Seller);
+export const SettingsModel = createModelProxy(Settings);
+export const ShipperModel = createModelProxy(Shipper);
+export const ShoppableVideoModel = createModelProxy(ShoppableVideo);
+export const ShoppableVideoCommentModel = createModelProxy(ShoppableVideoComment);
+export const ShoppableVideoLikeModel = createModelProxy(ShoppableVideoLike);
+export const ShoppableVideoSaveModel = createModelProxy(ShoppableVideoSave);
+export const ShowsModel = createModelProxy(Shows);
+export const StockModel = createModelProxy(Stock);
+export const UserModel = createModelProxy(User);
+export const ProductInteractionModel = createModelProxy(ProductInteraction);
+export const WishlistModel = createModelProxy(Wishlist);
+export const ChatBlockModel = createModelProxy(ChatBlock);
+export const ChatMessageModel = createModelProxy(ChatMessage);
+export const ChatRoomModel = createModelProxy(ChatRoom);
+export const ChatRoomMemberModel = createModelProxy(ChatRoomMember);
+export const OrderModel = createModelProxy(Order);
+export const LiveStreamInteractionModel = createModelProxy(LiveStreamInteraction);
+export const ProfileInteractionModel = createModelProxy(ProfileInteraction);
+export const RegisterShowModel = createModelProxy(RegisterShow);
+export const ReviewTypeModel = createModelProxy(ReviewType);
+export const ReviewModel = createModelProxy(Review);
+export const ShoppableVideoInteractionModel = createModelProxy(ShoppableVideoInteraction);
+
+
+export {
+  AdminModel as Admin,
+  BlockedRegionModel as BlockedRegion,
+  CategoryModel as Category,
+  CoHostInvitationModel as CoHostInvitation,
+  FollowModel as Follow,
+  LoginLogsModel as LoginLogs,
+  NotificationModel as Notification,
+  ProductListingModel as ProductListing,
+  SellerModel as Seller,
+  SettingsModel as Settings,
+  ShipperModel as Shipper,
+  ShoppableVideoModel as ShoppableVideo,
+  ShoppableVideoCommentModel as ShoppableVideoComment,
+  ShoppableVideoLikeModel as ShoppableVideoLike,
+  ShoppableVideoSaveModel as ShoppableVideoSave,
+  ShowsModel as Shows,
+  StockModel as Stock,
+  UserModel as User,
+  ProductInteractionModel as ProductInteraction,
+  WishlistModel as Wishlist,
+  ChatBlockModel as ChatBlock,
+  ChatRoomModel as ChatRoom,
+  ChatMessageModel as ChatMessage,
+  ChatRoomMemberModel as ChatRoomMember,
+  OrderModel as Order,
+  LiveStreamInteractionModel as LiveStreamInteraction,
+  ProfileInteractionModel as ProfileInteraction,
+  RegisterShowModel as RegisterShow,
+  ReviewModel as Review,
+  ReviewTypeModel as ReviewType,
+  ShoppableVideoInteractionModel as ShoppableVideoInteraction
+};

package/info.txt

@@ -0,0 +1 @@
+publish command : npm publish --access public

package/models/AdminEmail.model.js

@@ -0,0 +1,36 @@
+import { Schema, model } from 'mongoose';
+
+const AdminEmailSchema = new Schema({
+  email: {
+    type: String,
+    required: true,
+    unique: true,
+    lowercase: true,
+    trim: true
+  },
+  isActive: {
+    type: Boolean,
+    default: true
+  },
+  permissions: {
+    shoppableVideo: {
+      type: Boolean,
+      default: false
+    },
+    productAccess: {
+      type: Boolean,
+      default: false
+    },
+    totalAccess: {
+      type: Boolean,
+      default: false
+    }
+  }
+}, {
+  timestamps: true
+});
+
+// Index for faster querying
+AdminEmailSchema.index({ email: 1, isActive: 1 });
+
+export default model('AdminEmail', AdminEmailSchema);

package/models/LiveStreamInteraction.model.js

@@ -0,0 +1,93 @@
+import mongoose from 'mongoose';
+import crypto from 'crypto';
+
+const liveStreamInteractionSchema = new mongoose.Schema({
+    show: { 
+        type: mongoose.Schema.Types.ObjectId, 
+        ref: 'shows', 
+        required: true 
+    },
+    user: { 
+        type: mongoose.Schema.Types.ObjectId, 
+        ref: 'User', 
+        index: true 
+    },
+    sessionIdentifier: {
+        type: String,
+        index: true
+    },
+    host: { 
+        type: mongoose.Schema.Types.ObjectId, 
+        refPath: 'hostModel',
+        required: true 
+    },
+    hostModel: {
+        type: String,
+        required: true,
+        enum: ['sellers', 'dropshippers']
+    },
+    location: {
+        city: String,
+        region: String,
+        country: String
+    },
+    platform: { 
+        type: String, 
+        enum: ['web', 'mobile', 'unknown'], 
+        default: 'unknown' 
+    },
+    device: { 
+        type: String, 
+        enum: ['mobile', 'desktop', 'tablet', 'other', 'unknown'],
+        default: 'unknown'
+    },
+    browser: String,
+    os: String,
+    ip: { 
+        type: String, 
+        required: true 
+    },
+    watchDuration: {
+        type: Number,
+        default: 0
+    },
+    lastSeenAt: Date,
+    hasLiked: {
+        type: Boolean,
+        default: false
+    },
+    buyNowClicked: [{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'productlistings'
+    }],
+    auctionBidded: [{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'productlistings'
+    }],
+    giveawayEntered: [{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'productlistings'
+    }],
+}, { 
+    timestamps: true 
+});
+
+// Unique indexes
+liveStreamInteractionSchema.index({ show: 1, user: 1 }, { 
+    unique: true, 
+    partialFilterExpression: { user: { $exists: true } } 
+});
+
+liveStreamInteractionSchema.index({ show: 1, sessionIdentifier: 1 }, { 
+    unique: true, 
+    partialFilterExpression: { sessionIdentifier: { $exists: true } } 
+});
+
+liveStreamInteractionSchema.index({ show: 1, createdAt: -1 });
+
+const LiveStreamInteraction = mongoose.model(
+    'LiveStreamInteraction', 
+    liveStreamInteractionSchema
+);
+
+export default LiveStreamInteraction;

package/models/ProductInteraction.model.js

@@ -0,0 +1,42 @@
+import mongoose from 'mongoose';
+
+const productInteractionSchema = new mongoose.Schema({
+    product: { type: mongoose.Schema.Types.ObjectId, ref: 'Product', required: true },
+    user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', index: true },
+    seller: { type: mongoose.Schema.Types.ObjectId, ref: 'Seller', required: true },
+    location: {
+        city: String,
+        region: String,
+        country: String
+    },
+    // --- NEW FIELD ---
+    platform: { type: String, enum: ['web', 'mobile', 'unknown'], default: 'mobile' }, 
+    device: { type: String, enum: ['mobile', 'desktop', 'tablet', 'other'] },
+    browser: String,
+    os: String,
+    ip: { type: String, required: true },
+    isIndianRegion: { type: Boolean, default: false },
+     rating: {
+        type: Number,
+        min: 1,
+        max: 5,
+        validate: {
+            validator: Number.isInteger,
+            message: '{VALUE} is not an integer value'
+        }
+    },
+    review: {
+        type: String,
+        maxlength: 500
+    }
+}, { timestamps: true });
+
+// Ensures a user's view is counted only once per product
+productInteractionSchema.index({ product: 1, user: 1 }, { unique: true, partialFilterExpression: { user: { $exists: true } } });
+
+// Additional indexes for performance
+productInteractionSchema.index({ createdAt: -1 });
+
+const ProductInteraction = mongoose.model('ProductInteraction', productInteractionSchema);
+
+export default ProductInteraction;

package/models/Review.model.js

@@ -0,0 +1,121 @@
+import mongoose from "mongoose";
+const { Schema } = mongoose;
+
+// Define the ReviewType enum
+const ReviewType = {
+  PRODUCT: "product",
+  SELLER: "seller"
+};
+
+const ReviewSchema = new Schema(
+  {
+    userId: { 
+      type: Schema.Types.ObjectId, 
+      ref: "users",
+      required: true 
+    },
+    reviewType: {
+      type: String,
+      enum: Object.values(ReviewType),
+      required: true
+    },
+    productId: {
+      type: Schema.Types.ObjectId,
+      ref: "productlistings",
+      required: function() {
+        return this.reviewType === ReviewType.PRODUCT;
+      }
+    },
+    sellerId: {
+      type: Schema.Types.ObjectId,
+      ref: "sellers",
+      required: function() {
+        return this.reviewType === ReviewType.SELLER;
+      }
+    },
+    rating: {
+      type: Number,
+      required: true,
+      min: 1,
+      max: 5
+    },
+    content: {
+      type: String,
+      required: true,
+      trim: true,
+      maxlength: 1000
+    },
+    helpfulVotes: {
+      type: [{
+        userId: { 
+          type: Schema.Types.ObjectId, 
+          ref: "users",
+          required: true 
+        },
+        voteType: { 
+          type: String, 
+          enum: ["helpful", "not_helpful"],
+          required: true
+        },
+        createdAt: {
+          type: Date,
+          default: Date.now
+        }
+      }],
+      default: []
+    },
+    
+    helpfulCount: { 
+      type: Number, 
+      default: 0,
+      min: 0
+    },
+    notHelpfulCount: { 
+      type: Number, 
+      default: 0,
+      min: 0
+    },
+    images: {
+      type: [String], // Array of image URLs
+      default: [],
+      validate: {
+        validator: function(array) {
+          return array.length <= 5;
+        },
+        message: 'Cannot upload more than 5 images per review'
+      }
+    }
+  },
+  { 
+    timestamps: true,
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true }
+  }
+);
+
+// Indexes
+ReviewSchema.index({ productId: 1 });
+ReviewSchema.index({ sellerId: 1 });
+ReviewSchema.index({ userId: 1 });
+ReviewSchema.index({ reviewType: 1 });
+ReviewSchema.index({ "helpfulVotes.userId": 1 });
+
+// Virtual for total feedback count
+ReviewSchema.virtual('totalFeedback').get(function() {
+  return this.helpfulCount + this.notHelpfulCount;
+});
+
+// Method to check if a user has voted
+ReviewSchema.methods.hasUserVoted = function(userId) {
+  return this.helpfulVotes.some(vote => vote.userId.equals(userId));
+};
+
+// Method to get user's vote type
+ReviewSchema.methods.getUserVoteType = function(userId) {
+  const vote = this.helpfulVotes.find(vote => vote.userId.equals(userId));
+  return vote ? vote.voteType : null;
+};
+
+const Review = mongoose.model("reviews", ReviewSchema);
+
+export { Review, ReviewType };

package/models/SearchAnalytics.js

@@ -0,0 +1,22 @@
+import mongoose from "mongoose";
+
+const searchAnalyticsSchema = new mongoose.Schema({
+  searchTerm: { type: String, required: true, trim: true },
+  category: { 
+    type: String, 
+    enum: ["shows", "videos", "products", "users", "all"], 
+    default: "all" 
+  },
+  userId: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: false },
+  resultCount: { type: Number, default: 0 },
+  ipAddress: { type: String },
+  deviceInfo: { type: String },
+  location: {
+    city: { type: String },
+    region: { type: String },
+    country: { type: String }
+  },
+  createdAt: { type: Date, default: Date.now }
+});
+
+export default mongoose.model("SearchAnalytics", searchAnalyticsSchema);

package/models/ShoppableInteraction.model.js

@@ -0,0 +1,89 @@
+import mongoose from 'mongoose';
+import crypto from 'crypto';
+
+const shoppableVideoInteractionSchema = new mongoose.Schema({
+    video: { 
+        type: mongoose.Schema.Types.ObjectId, 
+        ref: 'ShoppableVideo', // Reference the correct model name
+        required: true 
+    },
+    user: { 
+        type: mongoose.Schema.Types.ObjectId, 
+        ref: 'User', 
+        index: true 
+    },
+    // Used to identify anonymous users by hashing their IP and User-Agent
+    sessionIdentifier: {
+        type: String,
+        index: true
+    },
+    host: { 
+        type: mongoose.Schema.Types.ObjectId, 
+        refPath: 'hostModel',
+        required: true 
+    },
+    hostModel: {
+        type: String,
+        required: true,
+        enum: ['sellers', 'dropshippers']
+    },
+    location: {
+        city: String,
+        region: String,
+        country: String
+    },
+    platform: { 
+        type: String, 
+        enum: ['web', 'mobile', 'unknown'], 
+        default: 'unknown' 
+    },
+    device: { 
+        type: String, 
+        enum: ['mobile', 'desktop', 'tablet', 'other', 'unknown'],
+        default: 'unknown'
+    },
+    browser: String,
+    os: String,
+    ip: { 
+        type: String, 
+        required: true 
+    },
+    watchDuration: { // Total seconds the user watched across sessions
+        type: Number,
+        default: 0
+    },
+    completionPercentage: { // The maximum percentage of the video watched
+        type: Number,
+        min: 0,
+        max: 100,
+        default: 0
+    },
+    productsClicked: [{ // Unique list of products clicked by this user for this video
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'productlistings'
+    }]
+}, { 
+    timestamps: true 
+});
+
+// Ensures a unique interaction record per logged-in user per video.
+shoppableVideoInteractionSchema.index({ video: 1, user: 1 }, { 
+    unique: true, 
+    partialFilterExpression: { user: { $exists: true } } 
+});
+
+// Ensures a unique interaction record per anonymous session per video.
+shoppableVideoInteractionSchema.index({ video: 1, sessionIdentifier: 1 }, { 
+    unique: true, 
+    partialFilterExpression: { sessionIdentifier: { $exists: true } } 
+});
+
+// Additional indexes for fast analytic queries
+shoppableVideoInteractionSchema.index({ video: 1, createdAt: -1 });
+
+const ShoppableVideoInteraction = mongoose.model(
+    'ShoppableVideoInteraction', 
+    shoppableVideoInteractionSchema
+);
+
+export default ShoppableVideoInteraction;

package/models/Wishlist.model.js

@@ -0,0 +1,30 @@
+// backend/models/Wishlist.js
+import mongoose from "mongoose";
+const { Schema } = mongoose;
+
+const WishlistSchema = new Schema(
+  {
+    userId: { 
+      type: Schema.Types.ObjectId, 
+      ref: "users",
+      required: true 
+    },
+    productId: { 
+      type: Schema.Types.ObjectId, 
+      ref: "productlistings",
+      required: true 
+    },
+    addedAt: {
+      type: Date,
+      default: Date.now
+    }
+  },
+  { timestamps: true }
+);
+
+// Add compound index to prevent duplicate entries
+WishlistSchema.index({ userId: 1, productId: 1 }, { unique: true });
+
+const Wishlist = mongoose.model("wishlists", WishlistSchema);
+
+export default Wishlist;

package/models/admin.model.js

@@ -0,0 +1,27 @@
+import mongoose from 'mongoose';
+
+const AdminSchema = new mongoose.Schema(
+    {
+        name: { type: String, required: true },
+        role: { type: String, required: true, default: "admin" },
+        email: { type: String, required: true, unique: true },
+        mobileNumber: { type: String, required: true },
+        password: { type: String, required: true },
+        profilePicture: { type: String, default: "https://img.freepik.com/free-vector/blue-circle-with-white-user_78370-4707.jpg" },
+
+        contentAccess: {
+            users: { readOnly: Boolean, edit: Boolean },
+            pendingSellers: { readOnly: Boolean, edit: Boolean },
+            sellers: { readOnly: Boolean, edit: Boolean },
+            orders: { readOnly: Boolean, edit: Boolean },
+            category: { readOnly: Boolean, edit: Boolean },
+            // settings: { readOnly: Boolean, edit: Boolean },
+            // admins: { readOnly: Boolean, edit: Boolean },
+        },
+        maskingSwitch: { type: Boolean, default: false },
+    },
+    { timestamps: true }
+);
+
+const Admin = mongoose.model('Admin', AdminSchema);
+export default Admin;

package/models/appUpdate.model.js

@@ -0,0 +1,18 @@
+import { Schema, model } from 'mongoose';
+
+const updateSchema = new Schema({
+  platform: { type: String, enum: ['android', 'ios'], required: true },
+  currentVersion: { type: String, required: true },
+  minVersion: { type: String, required: true }, // Minimum supported version
+  isForceUpdate: { type: Boolean, default: false },
+  releaseDate: { type: Date, default: Date.now },
+  features: [{
+    title: String,
+    description: String
+  }],
+  releaseNotes: String,
+  downloadUrl: String,
+  createdAt: { type: Date, default: Date.now }
+});
+
+export default model('Update', updateSchema);

package/models/assets.model.js

@@ -0,0 +1,32 @@
+// models/Asset.js
+
+import mongoose from 'mongoose';
+import mongoosePaginate from 'mongoose-paginate-v2';
+
+const assetSchema = new mongoose.Schema({
+  title: {
+    type: String,
+    required: true
+  },
+  key: {
+    type: String,
+    required: true,
+    unique: true
+  },
+  type: {
+    type: String,
+    required: true,
+    enum: ['video', 'image', 'pdf', 'other']
+  },
+  url: {
+    type: String,
+    required: true
+  }
+}, {
+  timestamps: true
+});
+
+assetSchema.plugin(mongoosePaginate);
+
+// Changed to a named export 'AssetsModel'
+export const AssetsModel = mongoose.model('Asset', assetSchema);