database-connector 2.0.4 → 2.1.1

package/CHANGELOG.md

@@ -1,6 +1,187 @@
 # Changelog - Database Connector Models Refactoring
 
-## 2025-12-08
+## Database Indexes Optimization
+
+### Added
+
+#### Database Indexes for Performance Optimization
+
+After comprehensive analysis of model usage across all microservices (AuthService, CartService, CategoryService, NotificationService, OfferService, OrderService, ProductService, SalesAnalyticsService, SearchExplorationService, StoreService, SubscriptionService, and UserService), the following database indexes have been added to optimize query performance:
+
+**1. User Model** (`User.js`)
+- **Indexes Added:**
+  - `email` (sparse): For login authentication by email in AuthService
+  - `phone` (sparse): For login authentication by phone in AuthService
+  - `role`: For filtering users by role (admin, seller, manager, etc.)
+  - `storeSubs`: For finding users subscribed to specific stores (ProductService notifications)
+- **Justification:** AuthService performs frequent lookups by email, phone, and username. The sparse indexes on email and phone allow for null values while optimizing lookups. Role-based queries are common in user management.
+
+**2. Cart Model** (`Cart.js`)
+- **Indexes Added:**
+  - `userId` (unique): Already existed, ensures one cart per user
+  - `items.productId`: For querying carts containing specific products
+- **Justification:** CartService frequently queries carts by userId and needs to find items by productId for cart operations.
+
+**3. Product Model** (`Product.js`)
+- **Indexes Added:**
+  - `storeId, deleted` (compound): For fetching active products by store
+  - `sellerId`: For seller-specific product queries in SellerRecommendationEngine
+  - `categoryId`: For category-based filtering
+  - `storeCategoryId`: For store category navigation
+  - `deleted`: For filtering deleted products
+  - `numberOfSales` (descending): For top-selling products
+  - `numberOfViews` (descending): For most-viewed products
+  - `averageRating` (descending): For highest-rated products sorting
+  - `createdAt` (descending): For newest products first
+  - `price`: For price range filtering
+  - `tags`: For tag-based search
+  - `variants._id`: For variant-specific queries in OrderService
+- **Justification:** ProductService has extensive query patterns including filtering by store, category, deletion status, and sorting by sales/views/ratings. SearchExplorationService uses price and tag filters. The compound index on storeId+deleted optimizes the most common query pattern.
+
+**4. Store Model** (`Store.js`)
+- **Indexes Added:**
+  - `location` (2dsphere): For geospatial proximity queries
+  - `sellerId`: For finding stores by seller
+  - `address.city`: For city-based store searches
+  - `isActive`: For filtering active stores
+  - `activated`: For filtering activated stores
+  - `storeCategorieIds`: For category-based store filtering
+  - `ratingSum, ratingCount` (compound descending): For sorting stores by rating
+- **Justification:** StoreService performs geospatial queries for nearby stores, city-based searches, and seller-specific queries. The 2dsphere index enables efficient location-based searches. Rating-based sorting is common in store listings.
+
+**5. Order Model** (`Order.js`)
+- **Indexes Added:**
+  - `clientId`: For user order history
+  - `storeId`: For store order management
+  - `status`: For filtering orders by status
+  - `paymentId`: For payment-related order lookups
+  - `shippingStatus`: For shipping status filtering
+  - `paymentStatus`: For payment status filtering
+  - `createdAt` (descending): For recent orders first
+  - `clientId, storeId` (compound): For user orders at specific store
+  - `storeId, status` (compound): For store orders by status
+- **Justification:** OrderService queries orders by client, store, various statuses, and payment ID. GDPR service exports user order data. Compound indexes optimize common filtering combinations.
+
+**6. Notification Model** (`Notification.js`)
+- **Indexes Added:**
+  - `owner_id, createdAt` (compound descending): For user notifications sorted by date
+  - `owner_id, seend` (compound): For filtering read/unread notifications
+  - `owner_id, seendInList` (compound): For list view status
+  - `type`: For filtering by notification type
+  - `sub_type`: For filtering by notification sub-type
+- **Justification:** NotificationService queries notifications by owner with sorting by date and filtering by read status. Compound indexes optimize these common query patterns.
+
+**7. Sale Model** (`Sale.js`)
+- **Indexes Added:**
+  - `sellerId, date` (compound descending): For seller sales analytics
+  - `storeId, date` (compound descending): For store sales analytics
+  - `productId, date` (compound descending): For product sales analytics
+  - `date` (descending): For time-based analytics
+  - `region`: For regional sales analysis
+- **Justification:** SalesAnalyticsService aggregates sales by seller, store, product, and time periods. Compound indexes with date optimize time-series analytics queries.
+
+**8. View Model** (`View.js`)
+- **Indexes Added:**
+  - `sellerId, date` (compound descending): For seller view analytics
+  - `storeId, date` (compound descending): For store view analytics
+  - `productId, date` (compound descending): For product view analytics
+  - `clientId, date` (compound descending): For user browsing history
+  - `date` (descending): For time-based view analytics
+  - `region`: For regional view analysis
+- **Justification:** SalesAnalyticsService aggregates views by seller, store, product, client, and time periods. These indexes support the analytics aggregation pipelines.
+
+**9. Payment Model** (`Payment.js`)
+- **Indexes Added:**
+  - `userId, createdAt` (compound descending): For user payment history
+  - `sellerId, createdAt` (compound descending): For seller payment tracking
+  - `paymentStatus`: For filtering by payment status
+  - `token`: For payment token lookups
+  - `gateway`: For filtering by payment gateway
+  - `paymentDate` (descending): For date-based payment queries
+- **Justification:** Payment tracking requires efficient queries by user, seller, status, and token. Date-based sorting is common in payment history.
+
+**10. Bill Model** (`Bill.js`)
+- **Indexes Added:**
+  - `userId, createdAt` (compound descending): For user billing history
+  - `storeId, createdAt` (compound descending): For store billing records
+  - `paymentStatus`: For payment status filtering
+  - `shippingStatus`: For shipping status filtering
+  - `refundStatus`: For refund status filtering
+  - `paymentId`: For payment-bill relationship
+  - `userId, storeId` (compound): For user bills at specific store
+- **Justification:** Bill management requires queries by user, store, various statuses, and payment associations. Compound indexes optimize common query patterns.
+
+**11. Offer Model** (`Offer.js`)
+- **Indexes Added:**
+  - `sellerId, offerStatus` (compound): For seller offers by status
+  - `storeId, offerStatus` (compound): For store offers by status
+  - `productId`: For product-specific offers
+  - `offerStatus`: For filtering active/expired offers
+  - `offerExpiration`: For expiration-based queries
+  - `createdAt` (descending): For newest offers first
+  - `offerDeleted`: For filtering deleted offers
+- **Justification:** OfferService queries offers by seller, store, product, and status. Compound indexes optimize seller and store offer listings with status filtering.
+
+**12. Subscription Model** (`Subscription.js`)
+- **Indexes Added:**
+  - `storeId`: For store subscription lookup
+  - `status`: For filtering by subscription status
+  - `endDate`: For expiration checks
+  - `startDate`: For activation tracking
+  - `planId`: For plan-based queries
+  - `paymentManagerId`: For payment manager tracking
+  - `storeId, status` (compound): For store subscription status
+  - `status, endDate` (compound): For active subscription expiration monitoring
+- **Justification:** SubscriptionService queries subscriptions by store, status, and expiration dates. Compound indexes optimize active subscription monitoring and store subscription management.
+
+**13. UserAction Model** (`UserAction.js`)
+- **Indexes Added:**
+  - `userId, timestamp` (compound descending): For user activity timeline
+  - `type`: For filtering by action type
+  - `sessionId`: For session-based analytics
+  - `deviceId`: For device-based tracking
+  - `timestamp` (descending): For recent activity queries
+- **Justification:** UserService tracks user actions for analytics and GDPR data export. Compound index on userId+timestamp optimizes user activity timeline queries.
+
+**14. ResetPassword Model** (`ResetPassword.js`)
+- **Indexes Added:**
+  - `userId`: For user password reset lookups
+  - `token`: For token verification
+  - `createAt` (TTL index, expires: 3600s): Automatic cleanup of expired tokens
+- **Justification:** AuthService looks up reset tokens by userId and token. TTL index automatically removes expired reset tokens after 1 hour, maintaining database hygiene.
+
+### Performance Impact
+
+**Query Performance Improvements:**
+- **Single-field indexes:** Reduce query time from O(n) to O(log n) for exact matches
+- **Compound indexes:** Optimize queries filtering by multiple fields simultaneously
+- **Geospatial index (Store):** Enable efficient proximity searches for nearby stores
+- **Descending indexes:** Optimize sorted queries (newest first, highest rated, etc.)
+- **Sparse indexes (User email/phone):** Allow null values while optimizing lookups
+- **TTL index (ResetPassword):** Automatic cleanup reduces manual maintenance
+
+**Index Strategy:**
+- Compound indexes placed on most frequent query combinations
+- Sort direction matches common query patterns (descending for dates, ratings, views)
+- Sparse indexes used for optional fields to reduce index size
+- Array field indexes support multi-valued queries
+
+### Maintenance Notes
+
+**Index Monitoring:**
+- Monitor index usage with MongoDB's `db.collection.aggregate([{$indexStats:{}}])`
+- Review slow query logs to identify missing indexes
+- Update indexes as query patterns evolve
+
+**Index Size Considerations:**
+- Each index consumes disk space and memory
+- Indexes slow down write operations slightly
+- Compound indexes can serve queries on their prefix fields
+- Consider removing unused indexes based on monitoring data
+
+---
+
+## Initial Refactoring
 
 ### Added
 

package/models/Bill.js

@@ -173,6 +173,15 @@ const BillSchema = new mongoose.Schema(
 	}
 );
 
+// Indexes for performance optimization
+BillSchema.index({ userId: 1, createdAt: -1 });
+BillSchema.index({ storeId: 1, createdAt: -1 });
+BillSchema.index({ paymentStatus: 1 });
+BillSchema.index({ shippingStatus: 1 });
+BillSchema.index({ refundStatus: 1 });
+BillSchema.index({ paymentId: 1 });
+BillSchema.index({ userId: 1, storeId: 1 });
+
 // Virtual: calculate amount that needs to be paid
 BillSchema.virtual('needToBePay').get(function () {
 	if (this.paymentStatus === 'pending') {

package/models/Cart.js

@@ -105,4 +105,8 @@ cartSchema.virtual('totalPriceForAllProducts').get(function () {
 	}, 0);
 });
 
+// Indexes for performance optimization
+cartSchema.index({ userId: 1 }, { unique: true });
+cartSchema.index({ 'items.productId': 1 });
+
 module.exports = model('Cart', cartSchema);

package/models/Notification.js

@@ -91,4 +91,11 @@ const NotificationSchema = new mongoose.Schema(
 	{ timestamps: true }
 );
 
+// Indexes for performance optimization
+NotificationSchema.index({ owner_id: 1, createdAt: -1 });
+NotificationSchema.index({ owner_id: 1, seend: 1 });
+NotificationSchema.index({ owner_id: 1, seendInList: 1 });
+NotificationSchema.index({ type: 1 });
+NotificationSchema.index({ sub_type: 1 });
+
 module.exports = mongoose.model('Notification', NotificationSchema);

package/models/Offer.js

@@ -146,4 +146,13 @@ OfferSchema.virtual('active').get(function () {
 	return this.offerExpiration > Date.now();
 });
 
+// Indexes for performance optimization
+OfferSchema.index({ sellerId: 1, offerStatus: 1 });
+OfferSchema.index({ storeId: 1, offerStatus: 1 });
+OfferSchema.index({ productId: 1 });
+OfferSchema.index({ offerStatus: 1 });
+OfferSchema.index({ offerExpiration: 1 });
+OfferSchema.index({ createdAt: -1 });
+OfferSchema.index({ offerDeleted: 1 });
+
 module.exports = mongoose.model('Offer', OfferSchema);

package/models/Order.js

@@ -67,7 +67,9 @@ const { policySchema } = require('./Policy');
  *           properties:
  *             totalAmount:
  *               type: number
- *             paymentMethodeId:
+ *             paymentMethodId:
+ *               type: number
+ *             paymentIntentId:
  *               type: number
  *         pickUp:
  *           type: boolean
@@ -80,7 +82,7 @@ const { policySchema } = require('./Policy');
  *           description: Whether order is canceled
  *         status:
  *           type: string
- *           enum: [Pending, InPreparation, LoadingDelivery, OnTheWay, Delivered, AwaitingRecovery, Recovered, Reserved, WaitingForReturn, Returned, UnderRefund, Refunded, succeeded]
+ *           enum: [Pending, Payed, InPreparation, LoadingDelivery, OnTheWay, Delivered, AwaitingRecovery, Recovered, Reserved, WaitingForReturn, Returned, UnderRefund, Refunded, succeeded]
  *           default: Pending
  *           description: Order status
  *         createdAt:
@@ -250,18 +252,8 @@ const orderSchema = new mongoose.Schema(
 
 		paymentInfos: {
 			totalAmount: { type: Number, required: true },
-			paymentMethodeId: { type: Number, required: true, },
-			card: {
-				cardNumber: { type: String, default: null },
-				ccv: { type: String, default: null },
-				expdate: { type: String, default: null },
-				name: { type: String, required: true },
-				phone: { type: String, required: true },
-				postalCode: { type: String, required: true },
-				address_city: { type: String, required: true },
-				address_line1: { type: String, required: true },
-				address_line2: { type: String, default: "" },
-			},
+			paymentMethodId: { type: Number, required: true, },
+			paymentIntentId: { type: Number, required: false, default: null }
 		},
 		pickUp: { type: Boolean, required: true, default: null },
 		delivery: { type: Boolean, required: true, default: null },
@@ -278,6 +270,7 @@ const orderSchema = new mongoose.Schema(
 		status: {
 			type: String, required: true, enum: [
 				'Pending',
+				'Payed',
 				'InPreparation',
 				'LoadingDelivery',
 				'OnTheWay',
@@ -314,4 +307,16 @@ orderSchema.post('save', async function (doc) {
 		console.error('Error creating sale records:', error);
 	}
 });
+
+// Indexes for performance optimization
+orderSchema.index({ clientId: 1 });
+orderSchema.index({ storeId: 1 });
+orderSchema.index({ status: 1 });
+orderSchema.index({ paymentId: 1 });
+orderSchema.index({ shippingStatus: 1 });
+orderSchema.index({ paymentStatus: 1 });
+orderSchema.index({ createdAt: -1 });
+orderSchema.index({ clientId: 1, storeId: 1 });
+orderSchema.index({ storeId: 1, status: 1 });
+
 module.exports = mongoose.model('Order', orderSchema);

package/models/Payment.js

@@ -191,4 +191,12 @@ const paymentSchema = new mongoose.Schema(
 	{ timestamps: true }
 );
 
+// Indexes for performance optimization
+paymentSchema.index({ userId: 1, createdAt: -1 });
+paymentSchema.index({ sellerId: 1, createdAt: -1 });
+paymentSchema.index({ paymentStatus: 1 });
+paymentSchema.index({ token: 1 });
+paymentSchema.index({ gateway: 1 });
+paymentSchema.index({ paymentDate: -1 });
+
 module.exports = mongoose.model('Payment', paymentSchema);

package/models/Product.js

@@ -295,4 +295,18 @@ productSchema.virtual('variantImages').get(function () {
 	}
 });
 
+// Indexes for performance optimization
+productSchema.index({ storeId: 1, deleted: 1 });
+productSchema.index({ sellerId: 1 });
+productSchema.index({ categoryId: 1 });
+productSchema.index({ storeCategoryId: 1 });
+productSchema.index({ deleted: 1 });
+productSchema.index({ numberOfSales: -1 });
+productSchema.index({ numberOfViews: -1 });
+productSchema.index({ averageRating: -1 });
+productSchema.index({ createdAt: -1 });
+productSchema.index({ price: 1 });
+productSchema.index({ tags: 1 });
+productSchema.index({ 'variants._id': 1 });
+
 module.exports = mongoose.model('Product', productSchema);

package/models/ResetPassword.js

@@ -49,4 +49,9 @@ const resetPasswordSchema = new mongoose.Schema(
 	{ toJSON: { virtuals: true } }
 );
 
+// Indexes for performance optimization
+resetPasswordSchema.index({ userId: 1 });
+resetPasswordSchema.index({ token: 1 });
+resetPasswordSchema.index({ createAt: 1 }, { expireAfterSeconds: 3600 });
+
 module.exports = mongoose.model('ResetPassword', resetPasswordSchema);

package/models/Sale.js

@@ -44,4 +44,11 @@ const Sale = new mongoose.Schema({
 	region: { type: String }
 });
 
+// Indexes for performance optimization (analytics queries)
+Sale.index({ sellerId: 1, date: -1 });
+Sale.index({ storeId: 1, date: -1 });
+Sale.index({ productId: 1, date: -1 });
+Sale.index({ date: -1 });
+Sale.index({ region: 1 });
+
 module.exports = mongoose.model('Sale', Sale);

package/models/Store.js

@@ -357,7 +357,14 @@ storeSchema.virtual('rating').get(function () {
 	}
 	return 0;
 });
-//creat index for location
+
+// Indexes for performance optimization
 storeSchema.index({ location: '2dsphere' });
+storeSchema.index({ sellerId: 1 });
+storeSchema.index({ 'address.city': 1 });
+storeSchema.index({ isActive: 1 });
+storeSchema.index({ activated: 1 });
+storeSchema.index({ storeCategorieIds: 1 });
+storeSchema.index({ ratingSum: -1, ratingCount: -1 });
 
 module.exports = mongoose.model('Store', storeSchema);

package/models/Subscription.js

@@ -189,4 +189,14 @@ const subscriptionSchema = new mongoose.Schema(
 	{ toJSON: { virtuals: true } }
 );
 
+// Indexes for performance optimization
+subscriptionSchema.index({ storeId: 1 });
+subscriptionSchema.index({ status: 1 });
+subscriptionSchema.index({ endDate: 1 });
+subscriptionSchema.index({ startDate: 1 });
+subscriptionSchema.index({ planId: 1 });
+subscriptionSchema.index({ paymentManagerId: 1 });
+subscriptionSchema.index({ storeId: 1, status: 1 });
+subscriptionSchema.index({ status: 1, endDate: 1 });
+
 module.exports = mongoose.model('Subscription', subscriptionSchema);

package/models/User.js

@@ -330,5 +330,11 @@ const userSchema = new mongoose.Schema(
 	{ timestamps: true }
 );
 
+// Indexes for performance optimization
 userSchema.index({ username: 1 }, { unique: true });
+userSchema.index({ email: 1 }, { sparse: true });
+userSchema.index({ phone: 1 }, { sparse: true });
+userSchema.index({ role: 1 });
+userSchema.index({ storeSubs: 1 });
+
 module.exports = mongoose.model('User', userSchema);

package/models/UserAction.js

@@ -67,6 +67,13 @@ const UserActionSchema = new mongoose.Schema({
     }
 });
 
+// Indexes for performance optimization
+UserActionSchema.index({ userId: 1, timestamp: -1 });
+UserActionSchema.index({ type: 1 });
+UserActionSchema.index({ sessionId: 1 });
+UserActionSchema.index({ deviceId: 1 });
+UserActionSchema.index({ timestamp: -1 });
+
 const UserAction = mongoose.model("UserAction", UserActionSchema);
 
 module.exports = UserAction;

package/models/View.js

@@ -49,6 +49,14 @@ const viewsSchema = new mongoose.Schema({
 	region: { type: String }
 });
 
+// Indexes for performance optimization (analytics queries)
+viewsSchema.index({ sellerId: 1, date: -1 });
+viewsSchema.index({ storeId: 1, date: -1 });
+viewsSchema.index({ productId: 1, date: -1 });
+viewsSchema.index({ clientId: 1, date: -1 });
+viewsSchema.index({ date: -1 });
+viewsSchema.index({ region: 1 });
+
 module.exports = mongoose.model('View', viewsSchema);
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "database-connector",
-  "version": "2.0.4",
+  "version": "2.1.1",
   "description": "MongoDB models package with Mongoose schemas for e-commerce applications. Includes User, Product, Store, Order and more with built-in validation and virtual properties.",
   "main": "models/index.js",
   "scripts": {