codebase-models 2.0.5 → 2.0.7

package/src/models/ClientLinks.ts

@@ -1,6 +1,7 @@
 import mongoose, { Document, Schema, model } from "mongoose";
-
+import { generateRandomIID } from "../constant";
 export interface IClientLinks extends Document {
+  iid: string;
   organizationId?: mongoose.Schema.Types.ObjectId;
   title: string;
   description?: string;
@@ -13,6 +14,10 @@ export interface IClientLinks extends Document {
 
 const ClientLinksSchema = new Schema<IClientLinks>(
   {
+    iid: {
+      type: String,
+      trim: true,
+    },
     organizationId: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "organization",
@@ -51,8 +56,24 @@ const ClientLinksSchema = new Schema<IClientLinks>(
   {
     timestamps: true,
   }
-);
+  );
+
+ClientLinksSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.clientlink.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+  next();
+});
 
+ClientLinksSchema.index({ iid: 1 }, { unique: true });
 // Compound indexes for common query patterns
 ClientLinksSchema.index({ client: 1 });
 ClientLinksSchema.index({ client: 1, private: 1 });

package/src/models/ClientNextSteps.ts

@@ -1,6 +1,8 @@
 import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
 
 export interface IClientNextSteps extends Document {
+  iid: string;
   name: string;
   organizationId?: mongoose.Schema.Types.ObjectId;
   client?: mongoose.Schema.Types.ObjectId;
@@ -10,6 +12,10 @@ export interface IClientNextSteps extends Document {
 
 const ClientNextStepsSchema = new Schema<IClientNextSteps>(
   {
+    iid: {
+      type: String,
+      trim: true,
+    },
     name: {
       type: String,
       required: true,
@@ -36,6 +42,20 @@ const ClientNextStepsSchema = new Schema<IClientNextSteps>(
   }
 );
 
+ClientNextStepsSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.clientnextstep.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+  next();
+});
 ClientNextStepsSchema.index({
   client: 1,
   viewId: 1,

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",
@@ -52,7 +57,6 @@ const ClientScriptSchema = new Schema<IClientScript>(
     },
     viewId: {
       type: String,
-      index: true,
     },
     clientScriptURL: {
       type: String,
@@ -100,10 +104,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 +126,7 @@ const ClientScriptSchema = new Schema<IClientScript>(
     metadata_key_var_3: {
       type: mongoose.Schema.Types.Mixed,
     },
-    cookie_domain: {
+    logDomain: {
       type: String,
       trim: true,
     },
@@ -149,11 +149,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 +165,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

@@ -1,6 +1,8 @@
 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;
@@ -11,6 +13,10 @@ interface ICustomQuery extends Document {
 
 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 },
@@ -21,8 +27,22 @@ const CustomQuerySchema = new Schema<ICustomQuery>(
     {
         timestamps: true, // Automatically adds createdAt and updatedAt fields
     }
-);
-CustomQuerySchema.index({ module: 1, client: 1 }, { unique: true });
+    );
+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);
 

package/src/models/Environment.ts

@@ -1,20 +1,29 @@
 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;
+  qa?: 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 +33,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",
@@ -32,11 +45,30 @@ const EnvironmentSchema = new Schema<IEnvironment>({
   isActive: {
     type: Boolean,
     default: true,
-}
+  },
+  qa: {
+    type: Boolean,
+    default: false,
+  }
 }, {
   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,11 +21,14 @@ export interface IGoal extends Document {
 }
 
 const GoalSchema = new Schema<IGoal>({
+  iid: {
+    type: String,
+    trim: true,
+  },
   name: {
     type: String,
     required: true,
     trim: true,
-    index: true,
   },
   details: {
     type: String,
@@ -75,12 +80,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/PageElement.ts

@@ -28,7 +28,6 @@ const PageElementSchema = new Schema<IPageElement>({
   organizationId: {
     type: mongoose.Schema.Types.ObjectId,
     ref: "organization",
-    index: true,
     default: null,
   },
   client: {

package/src/models/PageTestType.ts

@@ -20,7 +20,6 @@ const PageTestTypeSchema = new Schema<IPageTestType>({
     required: true,
     unique: true,
     trim: true,
-    index: true,
   },
   details: {
     type: String,
@@ -34,7 +33,6 @@ const PageTestTypeSchema = new Schema<IPageTestType>({
   isActive: {
     type: Boolean,
     default: true,
-    index: true,
   }
 }, {
   timestamps: true

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/Role.ts

@@ -16,7 +16,6 @@ const RoleSchema = new Schema<IRole>({
     required: true,
     enum: ["USER", "ADMIN", "EDITOR", "COLLABORATOR", "CLIENT"],
     trim: true,
-    index: true,
     uppercase: true,
   },
   description: {
@@ -26,13 +25,12 @@ const RoleSchema = new Schema<IRole>({
   organizationId: {
     type: mongoose.Schema.Types.ObjectId,
     ref: "organization",
-    index: true,
     default: null,
   },
   isActive: {
     type: Boolean,
     default: true,
-    index: true,
+
   }
 }, {
   timestamps: true

package/src/models/Snippet.ts

@@ -22,20 +22,18 @@ const SnippetSchema = new Schema<ISnippet>(
       type: mongoose.Schema.Types.ObjectId,
       ref: "organization",
       default: null,
-      index: true,
+
     },
     name: {
       type: String,
       required: true,
       unique: true,
       trim: true,
-      index: true,
     },
     pageelement: {
       type: [mongoose.Schema.Types.ObjectId],
       ref: "pageelement",
       default: [],
-      index: true,
     },
     client: {
       type: mongoose.Schema.Types.ObjectId,
@@ -73,7 +71,6 @@ const SnippetSchema = new Schema<ISnippet>(
     test: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "test",
-      index: true,
     },
     status: {
       type: String,