codebase-models 2.0.5 → 2.0.7

package/src/models/StageInCustomerJourney.ts

@@ -1,8 +1,10 @@
 import mongoose, { Document, Mongoose, Schema, model } from "mongoose";
 import slug from "mongoose-slug-updater"
+import { generateRandomIID } from "../constant";
 mongoose.plugin(slug)
 
 export interface IStageInCustomerJourney extends Document {
+  iid: string;
   name?: string;
   stages?: string;
   slug?: string;
@@ -13,11 +15,14 @@ export interface IStageInCustomerJourney extends Document {
 
 const StageInCustomerJourneySchema = new Schema<IStageInCustomerJourney>(
   {
+    iid: {
+      type: String,
+      unique: true,
+    },
     name: {
       type: String,
       required: true,
       trim: true,
-      index: true,
     },
     stages: {
       type: String,
@@ -35,17 +40,14 @@ const StageInCustomerJourneySchema = new Schema<IStageInCustomerJourney>(
       type: mongoose.Schema.Types.ObjectId,
       default: null,
       ref: "organization",
-      index: true,
     },
     client: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "client",
-      index: true,
     },
     isActive: {
       type: Boolean,
       default: true,
-      index: true,
     }
   },
   {
@@ -53,6 +55,22 @@ const StageInCustomerJourneySchema = new Schema<IStageInCustomerJourney>(
   }
 );
 
+StageInCustomerJourneySchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.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.models.stageincustomerjourney || model<IStageInCustomerJourney>(

package/src/models/Test.ts

@@ -1,6 +1,8 @@
 import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
 
 export interface IVariations extends Document {
+  iid: string;
   name: string;
   css_code: string;
   baseline: boolean;
@@ -17,6 +19,7 @@ export interface IVariations extends Document {
 export interface ITest extends Document {
   // Core test properties
   organizationId?: mongoose.Schema.Types.ObjectId;
+  iid: string;
   status: string;
   name: string;
   traffic_allocation: number;
@@ -47,7 +50,6 @@ export interface ITest extends Document {
   hypothesis?: mongoose.Schema.Types.ObjectId;
   trigger?: mongoose.Schema.Types.ObjectId[];
   stageincustomerjourney?: mongoose.Schema.Types.ObjectId;
-  
   // Test configuration
   property?: mongoose.Schema.Types.Mixed;
   platform: string;
@@ -63,6 +65,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[];
@@ -76,6 +79,7 @@ export interface ITest extends Document {
 }
 
 const VariationsSchema = new Schema<IVariations>({
+  iid: { type: String, unique: true },
   name: { type: String, required: true },
   css_code: { type: String, default: "" },
   baseline: { type: Boolean, default: false },
@@ -91,6 +95,7 @@ const VariationsSchema = new Schema<IVariations>({
 
 const TestSchema = new Schema<ITest>(
   {
+    iid: { type: String, unique: true },
     organizationId: { 
       type: mongoose.Schema.Types.ObjectId, 
       ref: "organization",
@@ -99,7 +104,7 @@ const TestSchema = new Schema<ITest>(
     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 },
@@ -160,7 +165,7 @@ const TestSchema = new Schema<ITest>(
     },
     hypothesis: { 
       type: mongoose.Schema.Types.ObjectId, 
-      ref: "hypos" 
+      ref: "hypos"
     },
     trigger: { 
       type: [mongoose.Schema.Types.ObjectId], 
@@ -169,7 +174,8 @@ const TestSchema = new Schema<ITest>(
     },
     stageincustomerjourney: { 
       type: mongoose.Schema.Types.ObjectId, 
-      ref: "stageincustomerjourney" 
+      ref: "stageincustomerjourney", 
+      default: null
     },
     
     // Test configuration
@@ -187,6 +193,7 @@ const TestSchema = new Schema<ITest>(
     testid: { type: String, default: null },
     testtool: { type: String, default: "" },
     personalization: { type: Boolean, default: false },
+    qaMode: { type: Boolean, default: false },
     kameleoontestdetails: { type: mongoose.Schema.Types.Mixed, default: null },
     vwotestdetails: { type: mongoose.Schema.Types.Mixed, default: null },
     triggerevents: { type: [], default: [] },
@@ -202,6 +209,37 @@ const TestSchema = new Schema<ITest>(
     timestamps: true
   }
 );
+TestSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.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 = generateRandomIID();
+        const existingVar = await mongoose.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/src/models/TestTimeline.ts

@@ -0,0 +1,61 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
+
+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: {},
+  };
+}
+const TestTimelineSchema = new Schema<ITestTimeline>({
+  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.Schema.Types.ObjectId,
+    ref: "organization",
+    default: null,
+  },
+  client: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "client",
+  },
+  test: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "test",
+  },
+  user: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "user",
+  },
+  changes: {
+    type: mongoose.Schema.Types.Mixed,
+      default: {},
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+TestTimelineSchema.pre("save", async function (next) {
+  if (!this.iid) {
+    this.iid = generateRandomIID();
+  }
+  next();
+});
+
+
+const TestTimeline = mongoose.models.testTimeline || model<ITestTimeline>("testTimeline", TestTimelineSchema);
+
+export default TestTimeline;