codebase-models 2.0.5 → 2.0.7

package/dist/src/models/StageInCustomerJourney.js

@@ -22,19 +22,32 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const mongoose_1 = __importStar(require("mongoose"));
 const mongoose_slug_updater_1 = __importDefault(require("mongoose-slug-updater"));
+const constant_1 = require("../constant");
 mongoose_1.default.plugin(mongoose_slug_updater_1.default);
 const StageInCustomerJourneySchema = new mongoose_1.Schema({
+    iid: {
+        type: String,
+        unique: true,
+    },
     name: {
         type: String,
         required: true,
         trim: true,
-        index: true,
     },
     stages: {
         type: String,
@@ -52,21 +65,35 @@ const StageInCustomerJourneySchema = new mongoose_1.Schema({
         type: mongoose_1.default.Schema.Types.ObjectId,
         default: null,
         ref: "organization",
-        index: true,
     },
     client: {
         type: mongoose_1.default.Schema.Types.ObjectId,
         ref: "client",
-        index: true,
     },
     isActive: {
         type: Boolean,
         default: true,
-        index: true,
     }
 }, {
     timestamps: true,
 });
+StageInCustomerJourneySchema.pre('save', function (next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.iid) {
+            let unique = false;
+            while (!unique) {
+                const id = (0, constant_1.generateRandomIID)();
+                const existing = yield mongoose_1.default.models.stageincustomerjourney.findOne({ iid: id });
+                if (!existing) {
+                    this.iid = id;
+                    unique = true;
+                }
+            }
+        }
+        next();
+    });
+});
+StageInCustomerJourneySchema.index({ iid: 1 }, { unique: true });
 // Compound indexes for common query patterns
 // StageInCustomerJourneySchema.index({ client: 1, slug: 1 });
 const StageInCustomerJourney = mongoose_1.default.models.stageincustomerjourney || (0, mongoose_1.model)("stageincustomerjourney", StageInCustomerJourneySchema);

package/dist/src/models/Test.d.ts

@@ -24,6 +24,7 @@
 /// <reference types="mongoose/types/inferschematype" />
 import mongoose, { Document } from "mongoose";
 export interface IVariations extends Document {
+    iid: string;
     name: string;
     css_code: string;
     baseline: boolean;
@@ -38,6 +39,7 @@ export interface IVariations extends Document {
 }
 export interface ITest extends Document {
     organizationId?: mongoose.Schema.Types.ObjectId;
+    iid: string;
     status: string;
     name: string;
     traffic_allocation: number;
@@ -76,6 +78,7 @@ export interface ITest extends Document {
     testid: string;
     testtool: string;
     personalization: boolean;
+    qaMode: boolean;
     kameleoontestdetails: mongoose.Schema.Types.Mixed;
     vwotestdetails: mongoose.Schema.Types.Mixed;
     triggerevents: any[];

package/dist/src/models/Test.js

@@ -22,9 +22,20 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const mongoose_1 = __importStar(require("mongoose"));
+const constant_1 = require("../constant");
 const VariationsSchema = new mongoose_1.Schema({
+    iid: { type: String, unique: true },
     name: { type: String, required: true },
     css_code: { type: String, default: "" },
     baseline: { type: Boolean, default: false },
@@ -38,6 +49,7 @@ const VariationsSchema = new mongoose_1.Schema({
     changesets: { type: String, default: "[]" }
 });
 const TestSchema = new mongoose_1.Schema({
+    iid: { type: String, unique: true },
     organizationId: {
         type: mongoose_1.default.Schema.Types.ObjectId,
         ref: "organization",
@@ -46,7 +58,7 @@ const TestSchema = new mongoose_1.Schema({
     status: {
         type: String,
         default: "draft",
-        enum: ["live", "draft", "ended", "paused", "preview", "running"]
+        enum: ["live", "draft", "ended", "paused", "preview", "running", "discard"]
     },
     name: { type: String, required: true },
     traffic_allocation: { type: Number, default: 100 },
@@ -113,7 +125,8 @@ const TestSchema = new mongoose_1.Schema({
     },
     stageincustomerjourney: {
         type: mongoose_1.default.Schema.Types.ObjectId,
-        ref: "stageincustomerjourney"
+        ref: "stageincustomerjourney",
+        default: null
     },
     // Test configuration
     property: { type: mongoose_1.default.Schema.Types.Mixed, default: null },
@@ -130,6 +143,7 @@ const TestSchema = new mongoose_1.Schema({
     testid: { type: String, default: null },
     testtool: { type: String, default: "" },
     personalization: { type: Boolean, default: false },
+    qaMode: { type: Boolean, default: false },
     kameleoontestdetails: { type: mongoose_1.default.Schema.Types.Mixed, default: null },
     vwotestdetails: { type: mongoose_1.default.Schema.Types.Mixed, default: null },
     triggerevents: { type: [], default: [] },
@@ -143,6 +157,37 @@ const TestSchema = new mongoose_1.Schema({
 }, {
     timestamps: true
 });
+TestSchema.pre('save', function (next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.iid) {
+            let unique = false;
+            while (!unique) {
+                const id = (0, constant_1.generateRandomIID)();
+                const existing = yield mongoose_1.default.models.test.findOne({ iid: id });
+                if (!existing) {
+                    this.iid = id;
+                    unique = true;
+                }
+            }
+        }
+        // For each Variation inside Test
+        for (const variation of this.variations) {
+            if (!variation.iid) {
+                let uniqueVar = false;
+                while (!uniqueVar) {
+                    const id = (0, constant_1.generateRandomIID)();
+                    const existingVar = yield mongoose_1.default.models.test.findOne({ "variations.iid": id });
+                    if (!existingVar) {
+                        variation.iid = id;
+                        uniqueVar = true;
+                    }
+                }
+            }
+        }
+        next();
+    });
+});
+TestSchema.index({ iid: 1 }, { unique: true });
 // Add compound indexes for better query performance
 TestSchema.index({ client: 1, status: 1 });
 TestSchema.index({ client: 1, status: 1, livedate: 1 });

package/dist/src/models/TestTimeline.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import mongoose, { Document } from "mongoose";
+export interface ITestTimeline extends Document {
+    iid: string;
+    organizationId?: mongoose.Schema.Types.ObjectId;
+    test: mongoose.Schema.Types.ObjectId;
+    event: string;
+    client: mongoose.Schema.Types.ObjectId;
+    user: mongoose.Schema.Types.ObjectId;
+    changes: {
+        type: mongoose.Schema.Types.Mixed;
+        default: {};
+    };
+}
+declare const TestTimeline: mongoose.Model<any, {}, {}, {}, any, any>;
+export default TestTimeline;

package/dist/src/models/TestTimeline.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importStar(require("mongoose"));
+const constant_1 = require("../constant");
+const TestTimelineSchema = new mongoose_1.Schema({
+    iid: {
+        type: String,
+        unique: true,
+    },
+    event: {
+        type: String,
+        enum: ["test_created", "test_updated", "test_status_changed", "test_deleted", "variant_created", "variant_updated", "variant_deleted"],
+    },
+    organizationId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "organization",
+        default: null,
+    },
+    client: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "client",
+    },
+    test: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "test",
+    },
+    user: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "user",
+    },
+    changes: {
+        type: mongoose_1.default.Schema.Types.Mixed,
+        default: {},
+    },
+}, {
+    timestamps: true,
+});
+TestTimelineSchema.pre("save", function (next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.iid) {
+            this.iid = (0, constant_1.generateRandomIID)();
+        }
+        next();
+    });
+});
+const TestTimeline = mongoose_1.default.models.testTimeline || (0, mongoose_1.model)("testTimeline", TestTimelineSchema);
+exports.default = TestTimeline;

package/index.ts

@@ -48,7 +48,8 @@ import Environment from "./src/models/Environment";
 import PrecalculationFilters from "./src/models/PrecalculationFilters";
 import BqPreCompiledData from "./src/models/BqPreCompiledData";
 import CustomQuery from "./src/models/CustomQuery";
-
+import { generateRandomIID } from "./src/constant";
+import TestTimeline from "./src/models/TestTimeline";
 async function seedRoles() {
   const checkRoles = await Role.countDocuments();
   if (checkRoles < 5) {
@@ -97,6 +98,7 @@ export async function connect(
 }
 
 export {
+  generateRandomIID,
   Client,
   ClientReportsTemp,
   QueryLog,
@@ -131,6 +133,7 @@ export {
   Role,
   CustomQuery,
   SavedSegment,
+  TestTimeline,
   Segment,
   SegmentCombination,
   Snippet,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebase-models",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "Common models for codebase",
   "main": "dist/index.js",
   "scripts": {
@@ -13,7 +13,8 @@
   "license": "ISC",
   "dependencies": {
     "mongoose": "^8.2.3",
-    "mongoose-slug-updater": "^3.3.0"
+    "mongoose-slug-updater": "^3.3.0",
+    "uuid": "^11.1.0"
   },
   "devDependencies": {
     "@types/mongoose": "^5.11.97",

package/src/constant.ts

@@ -1,3 +1,5 @@
+import { v4 as uuidv4 } from 'uuid';
+
 const HypothesisSheetConstants = {
   NO: 0,
   YES: 1,
@@ -11,4 +13,19 @@ const HypothesisSheetConstants = {
   GOOD: 2,
 };
 
+/**
+ * Generates a random unique identifier
+ * @returns A 12-character uppercase string (increased from 8 for better uniqueness)
+ * @throws Error if UUID generation fails
+ */
+const generateRandomIID = (): string => {
+  try {
+    // Take first 12 characters instead of 8 for better uniqueness
+    return uuidv4().replace(/-/g, '').substring(0, 12).toUpperCase();
+  } catch (error) {
+    throw new Error(`Failed to generate random IID: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+};
+
+export { generateRandomIID };
 export default HypothesisSheetConstants;

package/src/models/Announcement.ts

@@ -1,6 +1,8 @@
 import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
 
 export interface IAnnouncement extends Document {
+  iid: string;
   title: string;
   description?: string;
   active?: boolean;
@@ -12,6 +14,10 @@ export interface IAnnouncement extends Document {
 
 const AnnouncementSchema = new Schema<IAnnouncement>(
   {
+    iid: {
+      type: String,
+      trim: true,
+    },
     organizationId: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "organization",
@@ -49,6 +55,22 @@ const AnnouncementSchema = new Schema<IAnnouncement>(
   }
 );
 
+AnnouncementSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.announcement.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+  next();
+});
+
+AnnouncementSchema.index({ iid: 1 }, { unique: true });
 // Add compound indexes for better query performance
 AnnouncementSchema.index({ active: 1, createdAt: -1 }); // For active announcements sorted by date
 AnnouncementSchema.index({ forRoles: 1, active: 1 }); // For role-based announcements

package/src/models/Audience.ts

@@ -1,6 +1,8 @@
 import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
 
 export interface IAudience extends Document {
+  iid: string;
   organizationId?: mongoose.Schema.Types.ObjectId;
   name: string;
   rules_js?: string;
@@ -9,6 +11,10 @@ export interface IAudience extends Document {
 
 const AudienceSchema = new Schema<IAudience>(
   {
+    iid: {
+      type: String,
+      trim: true,
+    },
     organizationId: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "organization",
@@ -31,6 +37,23 @@ const AudienceSchema = new Schema<IAudience>(
   }
 );
 
+AudienceSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.audience.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+  next();
+});
+
+AudienceSchema.index({ iid: 1 }, { unique: true });
+
 const Audience = mongoose.models.audience || model<IAudience>("audience", AudienceSchema);
 
 export default Audience;

package/src/models/BqPreCompiledData.ts

@@ -1,6 +1,8 @@
 import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
 
 export interface IBqPreCompiledData extends Document {
+  iid: string;
   title: string;
   organizationId: mongoose.Schema.Types.ObjectId;
   client: mongoose.Schema.Types.ObjectId;
@@ -13,6 +15,10 @@ export interface IBqPreCompiledData extends Document {
 }
 
 const BqPreCompiledDataSchema = new Schema<IBqPreCompiledData>({
+  iid: {
+    type: String,
+    trim: true,
+  },
   title: {
     type: String,
     default: null,
@@ -56,6 +62,22 @@ const BqPreCompiledDataSchema = new Schema<IBqPreCompiledData>({
     timestamps: true
 });
 
+BqPreCompiledDataSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.bqprecompileddata.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+  next();
+});
+
+BqPreCompiledDataSchema.index({ iid: 1 }, { unique: true });
 BqPreCompiledDataSchema.index({ organizationId: 1, client: 1 });
 const BqPreCompiledData = mongoose.models.bqprecompileddata || model<IBqPreCompiledData>("bqprecompileddata", BqPreCompiledDataSchema);
 

package/src/models/Client.ts

@@ -1,5 +1,6 @@
 import mongoose, { Schema, Document, model } from "mongoose";
 import slug from "mongoose-slug-updater";
+import { generateRandomIID } from "../constant";
 
 mongoose.plugin(slug);
 
@@ -16,6 +17,7 @@ const PropertySchema: Schema = new Schema<IProperty>({
 });
 
 export interface IClient extends Document {
+  iid: string;
   organizationId?: mongoose.Schema.Types.ObjectId;
   name: string;
   slug?: string;
@@ -37,6 +39,10 @@ export interface IClient extends Document {
 
 const ClientSchema: Schema = new Schema<IClient>(
   {
+    iid: {
+      type: String,
+      trim: true,
+    },
     organizationId: { type: mongoose.Schema.Types.ObjectId, 
       ref: "organization",
       default: null },
@@ -75,6 +81,22 @@ const ClientSchema: Schema = new Schema<IClient>(
   }
 );
 
+ClientSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.client.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  } 
+  next();
+});
+
+ClientSchema.index({ iid: 1 }, { unique: true });
 // Add compound indexes for better query performance
 ClientSchema.index({ active: 1 });
 ClientSchema.index({ organizationId: 1, active: 1 });

package/src/models/ClientAdditionalRevenue.ts

@@ -1,13 +1,16 @@
 import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
 
 export interface IClientAdditionalRevenue extends Document {
+  iid: string;
   organizationId?: mongoose.Schema.Types.ObjectId;
   client?: mongoose.Schema.Types.ObjectId;
-  additionalRevenueForTests: IAdditionalRevenue;
+  additionalRevenueForTests: IAdditionalRevenue[];
   createdBy?: mongoose.Schema.Types.ObjectId;
 }
 
 export interface IAdditionalRevenue extends Document {
+  iid: string;
   segmentName: string;
   lastDate?: Date;
   test?: mongoose.Schema.Types.ObjectId;
@@ -15,6 +18,10 @@ export interface IAdditionalRevenue extends Document {
 }
 
 const AdditionalRevenueSchema = new Schema<IAdditionalRevenue>({
+  iid: {
+    type: String,
+    trim: true,
+  },
   // add_rev: {
   //   type: Number,
   // },
@@ -34,8 +41,13 @@ const AdditionalRevenueSchema = new Schema<IAdditionalRevenue>({
   },
 });
 
+
 const ClientAdditionalRevenueSchema = new Schema<IClientAdditionalRevenue>(
   {
+    iid: {
+      type: String,
+      trim: true,
+    },
     organizationId: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "organization",
@@ -57,6 +69,35 @@ const ClientAdditionalRevenueSchema = new Schema<IClientAdditionalRevenue>(
   }
 );
 
+ClientAdditionalRevenueSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.clientadditionalrevenue.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+    // For each Variation inside Test
+    for (const additionalRevenue of this.additionalRevenueForTests) {
+      if (!additionalRevenue.iid) {
+        let uniqueVar = false;
+        while (!uniqueVar) {
+          const id = generateRandomIID();
+          const existingVar = await mongoose.models.clientadditionalrevenue.findOne({ "additionalRevenueForTests.iid": id });
+          if (!existingVar) {
+            additionalRevenue.iid = id;
+            uniqueVar = true;
+          }
+        }
+      }
+    }
+  next();
+});
+
 ClientAdditionalRevenueSchema.index({
   client: 1,
 });

package/src/models/ClientLearning.ts

@@ -1,6 +1,8 @@
 import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
 
 export interface IClientLearning extends Document {
+  iid: string;
   name: string;
   organizationId?: mongoose.Schema.Types.ObjectId;
   client?: mongoose.Schema.Types.ObjectId;
@@ -10,6 +12,10 @@ export interface IClientLearning extends Document {
 
 const ClientLearningSchema = new Schema<IClientLearning>(
   {
+    iid: {
+      type: String,
+      trim: true,
+    },
     name: {
       type: String,
       required: true,
@@ -37,6 +43,22 @@ const ClientLearningSchema = new Schema<IClientLearning>(
   }
 );
 
+ClientLearningSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.clientlearning.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+  next();
+});
+
+ClientLearningSchema.index({ iid: 1 }, { unique: true });
 // Compound indexes for common query patterns
 ClientLearningSchema.index({ client: 1 });
 // Sparse indexes for optional fields