codebase-models 2.0.4 → 2.0.6

package/src/models/ClientNote.ts

@@ -1,6 +1,8 @@
 import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
 
 export interface IClientNote extends Document {
+  iid: string;
   organizationId?: mongoose.Schema.Types.ObjectId;
   client?: mongoose.Schema.Types.ObjectId;
   viewId?: string;
@@ -14,6 +16,10 @@ export interface IClientNote extends Document {
 
 const ClientNoteSchema = new Schema<IClientNote>(
   {
+    iid: {
+      type: String,
+      trim: true,
+    },
     organizationId: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "organization",
@@ -51,9 +57,24 @@ const ClientNoteSchema = new Schema<IClientNote>(
   {
     timestamps: true,
   }
-);
+  );
 
+ClientNoteSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.clientnote.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+  next();
+});
 ClientNoteSchema.index({
+  iid: 1,
   client: 1,
   viewId: 1,
 });

package/src/models/ClientScript.ts

@@ -1,26 +1,24 @@
 import mongoose, { Document, Schema, model } from "mongoose";
-
-export interface IClientScriptSchema extends Document {
-  scriptUrl: string;
-  viewId: string;
-}
+import { generateRandomIID } from "../constant";
 
 export interface IClientScript extends Document {
+  iid: string;
   organizationId?: mongoose.Schema.Types.ObjectId;
   client?: mongoose.Schema.Types.ObjectId;
+  adhere_dnt: Boolean;
+  allow_in_iframes: Boolean;
   viewId?: string;
   clientScriptURL: string;
   jquery_include: string;
   debug: Boolean;
   restrict_debug: Boolean;
-  adhere_dnt: Boolean;
   max_cookie_lifetime: Number;
   activation_mode: string;
   use_antiflicker: Boolean;
   snippet_revision: Number;
+  snippet_version: Number;
   rules: string;
   rules_tracking: string;
-  tracker_url: string;
   asset_url: string;
   metadata_key_exp_1: mongoose.Schema.Types.Mixed;
   metadata_key_exp_2: mongoose.Schema.Types.Mixed;
@@ -28,19 +26,26 @@ export interface IClientScript extends Document {
   metadata_key_var_1: mongoose.Schema.Types.Mixed;
   metadata_key_var_2: mongoose.Schema.Types.Mixed;
   metadata_key_var_3: mongoose.Schema.Types.Mixed;
-  cookie_domain: string;
-  snippet_version: Number;
+  logDomain: string;
   storage: string;
   run_only_on_reinit: Boolean;
-  allow_in_iframes: Boolean;
   visual_editor_version: Number;
-  jscode: string;
-  csscode: string;
+  js: string;
+  css: string;
+  helper_js: string;
   is_spa: Boolean;
+  isPreview: Boolean;
+  goalsEnabled: Boolean;
+  optedOut: Boolean;
+  liveEventListenersSet: Boolean;
 }
 
 const ClientScriptSchema = new Schema<IClientScript>(
   {
+    iid: {
+      type: String,
+      trim: true,
+    },
     organizationId: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "organization",
@@ -100,10 +105,6 @@ const ClientScriptSchema = new Schema<IClientScript>(
       default: "return true;",
       trim: true,
     },
-    tracker_url: {
-      type: String,
-      trim: true,
-    },
     asset_url: {
       type: String,
       trim: true,
@@ -126,7 +127,7 @@ const ClientScriptSchema = new Schema<IClientScript>(
     metadata_key_var_3: {
       type: mongoose.Schema.Types.Mixed,
     },
-    cookie_domain: {
+    logDomain: {
       type: String,
       trim: true,
     },
@@ -149,11 +150,15 @@ const ClientScriptSchema = new Schema<IClientScript>(
     visual_editor_version: {
       type: Number,
     },
-    jscode: {
+    js: {
+      type: String,
+      trim: true,
+    },
+    css: {
       type: String,
       trim: true,
     },
-    csscode: {
+    helper_js: {
       type: String,
       trim: true,
     },
@@ -161,17 +166,48 @@ const ClientScriptSchema = new Schema<IClientScript>(
       type: Boolean,
       default: false,
     },
+    isPreview: {
+      type: Boolean,  
+      default: false,
+    },
+    goalsEnabled: {
+      type: Boolean,
+      default: false,
+    },
+    optedOut: {
+      type: Boolean,
+      default: false,
+    },
+    liveEventListenersSet: {
+      type: Boolean,
+      default: false,
+    },
   },
   {
     timestamps: true,
   }
 );
 
+ClientScriptSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.clientscript.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+  next();
+});
+
+ClientScriptSchema.index({ iid: 1 }, { unique: true });
 // Compound indexes for common query patterns
 ClientScriptSchema.index({ client: 1 });
 // Sparse indexes for optional fields
 ClientScriptSchema.index({ organisationId: 1 }, { sparse: true });
-ClientScriptSchema.index({ tracker_url: 1 }, { sparse: true });
 ClientScriptSchema.index({ asset_url: 1 }, { sparse: true });
 
 

package/src/models/ClientStrategy.ts

@@ -1,6 +1,8 @@
 import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
 
 export interface IClientStrategy extends Document {
+  iid: string;
   year: mongoose.Schema.Types.Mixed;
   month: mongoose.Schema.Types.Mixed;
   startDate?: Date;
@@ -15,6 +17,10 @@ export interface IClientStrategy extends Document {
 
 const ClientStrategySchema = new Schema<IClientStrategy>(
   {
+    iid: {
+      type: String,
+      trim: true,
+    },
     year: {
       type: mongoose.Schema.Types.Mixed,
       required: true,
@@ -55,8 +61,26 @@ const ClientStrategySchema = new Schema<IClientStrategy>(
   {
     timestamps: true,
   }
+
 );
 
+ClientStrategySchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.clientstrategy.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+  next();
+});
+
+ClientStrategySchema.index({ iid: 1 }, { unique: true });
+
 ClientStrategySchema.index({
   year: 1,
   month: 1,

package/src/models/CustomQuery.ts

@@ -0,0 +1,49 @@
+import mongoose, { Schema, model, Document } from 'mongoose';
+import { generateRandomIID } from '../constant';
+
+interface ICustomQuery extends Document {
+    iid: string;
+    organizationId?: mongoose.Schema.Types.ObjectId;
+    title: string;
+    module: string;
+    client: mongoose.Schema.Types.ObjectId;
+    query: string;
+    createdBy?: mongoose.Schema.Types.ObjectId;
+}
+
+const CustomQuerySchema = new Schema<ICustomQuery>(
+    {
+        iid: {
+            type: String,
+            trim: true,
+        },
+        organizationId: { type: mongoose.Schema.Types.ObjectId, ref: "organization", default: null },
+        title: { type: String, required: true },
+        module: { type: String, required: true },
+        client: { type: mongoose.Schema.Types.ObjectId, ref: 'client', required: true },
+        query: { type: String, required: true },
+        createdBy: { type: mongoose.Schema.Types.ObjectId, ref: 'user', default: null },
+    },
+    {
+        timestamps: true, // Automatically adds createdAt and updatedAt fields
+    }
+    );
+CustomQuerySchema.pre('save', async function(next) {
+    if (!this.iid) {
+        let unique = false;
+        while (!unique) {
+            const id = generateRandomIID();
+            const existing = await mongoose.models.customquery.findOne({ iid: id });
+            if (!existing) {
+                this.iid = id;
+                unique = true;
+            }
+        }
+    }
+    next();
+});
+
+
+const CustomQuery = model<ICustomQuery>('CustomQuery', CustomQuerySchema);
+
+export default CustomQuery;

package/src/models/Environment.ts

@@ -1,20 +1,28 @@
 import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
 
 export interface IEnvironment extends Document {
+  iid: string;
   name: string;
   rules_js?: string;
   client?: mongoose.Schema.Types.ObjectId;
   organizationId?: mongoose.Schema.Types.ObjectId;
   isActive?: boolean;
+  default?: boolean;
 }
 
 const EnvironmentSchema = new Schema<IEnvironment>({
+  iid: {
+    type: String,
+    trim: true,
+  },
   name: {
     type: String,
     required: true,
     default: 'Default',
     trim: true,
   },
+
   client: {
     type: mongoose.Schema.Types.ObjectId,
     ref: "client",
@@ -24,6 +32,10 @@ const EnvironmentSchema = new Schema<IEnvironment>({
     type: mongoose.Schema.Types.ObjectId,
     ref: "organization",
   },
+  default: {
+    type: Boolean,
+    default: false,
+  },
   rules_js: {
     type: String,
     default: "return true",
@@ -37,6 +49,21 @@ const EnvironmentSchema = new Schema<IEnvironment>({
   timestamps: true
 });
 
+EnvironmentSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.environment.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+  next();
+});
+
 // Compound indexes for common query patterns
 EnvironmentSchema.index({ client: 1, name: 1 }, { unique: true });
 EnvironmentSchema.index({ client: 1, isActive: 1 });

package/src/models/Goal.ts

@@ -1,8 +1,10 @@
 import mongoose, { Document, Schema, model } from "mongoose";
 import slug from "mongoose-slug-updater"
+import { generateRandomIID } from "../constant";
 mongoose.plugin(slug)
 
 export interface IGoal extends Document {
+  iid: string;
   name: string;
   details?: string;
   slug?: string;
@@ -19,6 +21,10 @@ export interface IGoal extends Document {
 }
 
 const GoalSchema = new Schema<IGoal>({
+  iid: {
+    type: String,
+    trim: true,
+  },
   name: {
     type: String,
     required: true,
@@ -75,12 +81,26 @@ const GoalSchema = new Schema<IGoal>({
   timestamps: true
 });
 
-// Compound indexes for common query patterns
+GoalSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.goal.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+  next();
+});
+
 GoalSchema.index({ client: 1});
 GoalSchema.index({ client: 1, isActive: 1 });
 GoalSchema.index({ organizationId: 1, client: 1 });
 GoalSchema.index({ client: 1, name: 1 }, { unique: true });
-
+GoalSchema.index({ iid: 1 }, { unique: true });
 const Goal = mongoose.models.goal || model<IGoal>("goal", GoalSchema);
 
 export default Goal;

package/src/models/Page.ts

@@ -1,14 +1,20 @@
 import mongoose, { Document, Schema, model } from "mongoose";
 import slug from "mongoose-slug-updater"
+import { generateRandomIID } from "../constant";
 mongoose.plugin(slug)
 
+// Helper function
+
+
 export interface IUrltargetings extends Document {
+  iid: string;
   type: string;
   url: string;
   url_type: string;
 }
 
 export interface IPage extends Document {
+  iid: string;
   name: string;
   client?: mongoose.Schema.Types.ObjectId;
   organizationId?: mongoose.Schema.Types.ObjectId;
@@ -23,6 +29,10 @@ export interface IPage extends Document {
 }
 
 const UrltargetingsSchema = new Schema<IUrltargetings>({
+  iid: {
+    type: String,
+    unique: true,
+  },
   type: {
     type: String,
     required: true,
@@ -41,6 +51,10 @@ const UrltargetingsSchema = new Schema<IUrltargetings>({
 });
 
 const PageSchema = new Schema<IPage>({
+  iid: {
+    type: String,
+    unique: true,
+  },
   name: {
     type: String,
     required: true,
@@ -98,6 +112,35 @@ const PageSchema = new Schema<IPage>({
   timestamps: true
 });
 
+PageSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.page.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+  for (const urltargeting of this.urltargetings) {
+    if (!urltargeting.iid) {
+      let uniqueVar = false;
+      while (!uniqueVar) {
+        const id = generateRandomIID();
+        const existingVar = await mongoose.models.page.findOne({ "urltargetings.iid": id });
+        if (!existingVar) {
+          urltargeting.iid = id;
+          uniqueVar = true;
+        }
+      }
+    }
+  }
+  next();
+});
+
+PageSchema.index({ iid: 1 }, { unique: true });
 // Compound indexes for common query patterns
 PageSchema.index({ client: 1, name: 1 }, { unique: true });
 PageSchema.index({ client: 1, isActive: 1 });

package/src/models/Report.ts

@@ -1,6 +1,8 @@
 import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
 
 export interface IReports extends Document {
+  iid: string;
   name: string;
   segmentName?: string;
   reportLink?: string;
@@ -23,6 +25,10 @@ export interface IReports extends Document {
 
 const ReportsSchema = new Schema<IReports>(
   {
+    iid: {
+      type: String,
+      trim: true,
+    },
     organizationId: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "organization",
@@ -64,6 +70,22 @@ const ReportsSchema = new Schema<IReports>(
   }
 );
 
+ReportsSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.report.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+  next();
+});
+
+
 // Add compound indexes for better query performance
 ReportsSchema.index({ client: 1, conclusion: 1 });
 ReportsSchema.index({ test: 1, to: -1 }); // For sorting reports by date

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,6 +15,10 @@ export interface IStageInCustomerJourney extends Document {
 
 const StageInCustomerJourneySchema = new Schema<IStageInCustomerJourney>(
   {
+    iid: {
+      type: String,
+      unique: true,
+    },
     name: {
       type: String,
       required: true,
@@ -53,6 +59,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;
@@ -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
@@ -202,6 +208,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 });