codebase-models 1.0.7 → 2.0.0

package/src/models/ClientScript.ts

@@ -6,7 +6,7 @@ export interface IClientScriptSchema extends Document {
 }
 
 export interface IClientScript extends Document {
-  organisationId?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
   client?: mongoose.Schema.Types.ObjectId;
   viewId?: string;
   clientScriptURL: string;
@@ -41,23 +41,28 @@ export interface IClientScript extends Document {
 
 const ClientScriptSchema = new Schema<IClientScript>(
   {
-    organisationId: {
-      type: String,
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
       default: null,
     },
     client: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "client",
+      index: true,
     },
     viewId: {
       type: String,
+      index: true,
     },
     clientScriptURL: {
       type: String,
+      trim: true,
     },
     jquery_include: {
       type: String,
       default: "false",
+      trim: true,
     },
     debug: {
       type: Boolean,
@@ -76,6 +81,7 @@ const ClientScriptSchema = new Schema<IClientScript>(
     },
     activation_mode: {
       type: String,
+      trim: true,
     },
     use_antiflicker: {
       type: Boolean,
@@ -87,17 +93,21 @@ const ClientScriptSchema = new Schema<IClientScript>(
     },
     rules: {
       type: String,
-      default: "return true;"
+      default: "return true;",
+      trim: true,
     },
     rules_tracking: {
       type: String,
-      default: "return true;"
+      default: "return true;",
+      trim: true,
     },
     tracker_url: {
       type: String,
+      trim: true,
     },
     asset_url: {
       type: String,
+      trim: true,
     },
     metadata_key_exp_1: {
       type: mongoose.Schema.Types.Mixed,
@@ -119,6 +129,7 @@ const ClientScriptSchema = new Schema<IClientScript>(
     },
     cookie_domain: {
       type: String,
+      trim: true,
     },
     snippet_version: {
       type: Number,
@@ -126,6 +137,7 @@ const ClientScriptSchema = new Schema<IClientScript>(
     storage: {
       type: String,
       default: "default",
+      trim: true,
     },
     run_only_on_reinit: {
       type: Boolean,
@@ -140,9 +152,11 @@ const ClientScriptSchema = new Schema<IClientScript>(
     },
     jscode: {
       type: String,
+      trim: true,
     },
     csscode: {
       type: String,
+      trim: true,
     },
     is_spa: {
       type: Boolean,
@@ -154,10 +168,13 @@ const ClientScriptSchema = new Schema<IClientScript>(
   }
 );
 
-ClientScriptSchema.index({
-  client: 1,
-  viewId: 1,
-});
+// 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 });
+
 
 const ClientScript = model<IClientScript>("clientscript", ClientScriptSchema);
 

package/src/models/ClientStrategy.ts

@@ -6,7 +6,7 @@ export interface IClientStrategy extends Document {
   startDate?: Date;
   endDate?: Date;
   strategies?: mongoose.Schema.Types.Mixed;
-  organisationId?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
   client?: mongoose.Schema.Types.ObjectId;
   learningsoftime?: mongoose.Schema.Types.Mixed;
   viewId?: string;
@@ -32,8 +32,9 @@ const ClientStrategySchema = new Schema<IClientStrategy>(
     strategies: {
       type: mongoose.Schema.Types.Mixed,
     },
-    organisationId: {
-      type: String,
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
       default: null,
     },
     client: {

package/src/models/ClientSurvay.ts

@@ -3,6 +3,7 @@ import mongoose, { Document, Schema, model } from "mongoose";
 export interface IClientSurvay extends Document {
   responses: IResponce;
   user?: mongoose.Schema.Types.ObjectId;
+  organizationId?: mongoose.Schema.Types.ObjectId;
 }
 
 export interface IResponce extends Document {
@@ -26,6 +27,11 @@ const ClientSurveySchema = new Schema<IClientSurvay>(
       type: mongoose.Schema.Types.ObjectId,
       ref: "user",
     },
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
+      default: null,
+    },
   },
   {
     timestamps: true,

package/src/models/Environment.ts

@@ -4,26 +4,54 @@ export interface IEnvironment extends Document {
   name: string;
   rules_js?: string;
   client?: mongoose.Schema.Types.ObjectId;
+  organizationId?: mongoose.Schema.Types.ObjectId;
+  isActive?: boolean;
 }
 
 const EnvironmentSchema = new Schema<IEnvironment>({
   name: {
     type: String,
     required: true,
-    default: 'Default'
+    default: 'Default',
+    trim: true,
+    index: true,
   },
   client: {
     type: mongoose.Schema.Types.ObjectId,
     ref: "client",
+    required: true,
+    index: true,
+  },
+  organizationId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "organization",
+    index: true,
   },
   rules_js: {
     type: String,
-    default: "return true"
+    default: "return true",
+    trim: true,
   },
-},{
+  isActive: {
+    type: Boolean,
+    default: true,
+    index: true,
+  }
+}, {
   timestamps: true
 });
 
+// Compound indexes for common query patterns
+EnvironmentSchema.index({ client: 1, name: 1 }, { unique: true });
+EnvironmentSchema.index({ client: 1, isActive: 1 });
+EnvironmentSchema.index({ organizationId: 1, client: 1 });
+EnvironmentSchema.index({ organizationId: 1, name: 1 }, {
+  sparse: true,
+});
+
+// Text index for full-text search
+EnvironmentSchema.index({ name: 'text' });
+
 const Environment = model<IEnvironment>("environment", EnvironmentSchema);
 
 export default Environment;

package/src/models/Faqs.ts

@@ -6,6 +6,7 @@ export interface IFaqs extends Document {
   keywords?: mongoose.Schema.Types.Array;
   createdAt?: Date;
   updatedAt?: Date;
+  organizationId?: mongoose.Schema.Types.ObjectId;
 }
 
 const FaqSchema = new Schema<IFaqs>({
@@ -26,6 +27,11 @@ const FaqSchema = new Schema<IFaqs>({
     type: Date,
     default: new Date(),
   },
+  organizationId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "organization",
+    default: null,
+  },
 });
 
 const Faq = model<IFaqs>("faq", FaqSchema);

package/src/models/Feedback.ts

@@ -5,7 +5,7 @@ export interface IFeedback extends Document {
   details?: string;
   client?: mongoose.Schema.Types.ObjectId;
   thread?: mongoose.Schema.Types.Mixed;
-  organisationId?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
   createdAt?: Date;
   updatedAt?: Date;
 }
@@ -27,8 +27,9 @@ const FeedbackSchema = new Schema<IFeedback>({
     type: mongoose.Schema.Types.Mixed,
     default: [],
   },
-  organisationId: {
-    type: String,
+  organizationId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "organization",
     default: null,
   },
   createdAt: {

package/src/models/Goal.ts

@@ -6,13 +6,14 @@ export interface IGoal extends Document {
   name: string;
   details?: string;
   slug?: string;
-  organisationId?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
   client?: mongoose.Schema.Types.ObjectId;
   type: string;
   counting_method: string;
   css_selector: string;
   api_name: string;
   rules_js: string;
+  isActive?: boolean;
   createdAt?: Date;
   updatedAt?: Date;
 }
@@ -21,45 +22,68 @@ const GoalSchema = new Schema<IGoal>({
   name: {
     type: String,
     required: true,
+    trim: true,
+    index: true,
   },
   details: {
     type: String,
     default: "",
+    trim: true,
   },
   slug: {
     type: String,
+    unique: true,
+    sparse: true,
   },
-  organisationId: {
-    type: String,
+  organizationId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "organization",
     default: null,
+    index: true,
   },
   client: {
     type: mongoose.Schema.Types.ObjectId,
     ref: "client",
+    index: true,
   },
   type: {
     type: String,
+    trim: true,
   },
   counting_method: {
     type: String,
+    trim: true,
   },
   css_selector: {
     type: String,
+    trim: true,
+  },
+  api_name: { 
+    type: String, 
+    slug: ["name"], 
+    slugPaddingSize: 4,  
+    unique: true,
+    trim: true,
   },
-  api_name: { type: String, slug: ["name"], slugPaddingSize: 4,  unique: true },
   rules_js: {
     type: String,
+    trim: true,
   },
-  createdAt: {
-    type: Date,
-    default: new Date(),
-  },
-  updatedAt: {
-    type: Date,
-    default: new Date(),
-  },
+  isActive: {
+    type: Boolean,
+    default: true,
+    index: true,
+  }
+}, {
+  timestamps: true
 });
 
+// Compound indexes for common query patterns
+GoalSchema.index({ client: 1});
+GoalSchema.index({ client: 1, isActive: 1 });
+GoalSchema.index({ organizationId: 1, client: 1 });
+GoalSchema.index({ client: 1, name: 1 }, { unique: true });
+
 const Goal = model<IGoal>("goal", GoalSchema);
 
 export default Goal;

package/src/models/Hypothesis.ts

@@ -1,50 +1,71 @@
 import mongoose, { Document, Schema, model } from "mongoose";
 
 export interface IHypothesis extends Document {
+  organizationId?: mongoose.Schema.Types.ObjectId;
   hypothesisNumber?: string;
   name: string;
   action: string;
   result: string;
   expectation: string;
   tagged?: string;
+  isActive?: boolean;
   createdAt?: Date;
   updatedAt?: Date;
 }
 
 const HypothesisSchema = new Schema<IHypothesis>({
+  organizationId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "organization",
+    default: null,
+  },
   hypothesisNumber: {
     type: String,
+    trim: true,
+    index: true,
   },
   name: {
     type: String,
     required: true,
+    trim: true,
+    index: true,
   },
   action: {
     type: String,
     required: true,
+    trim: true,
   },
   result: {
     type: String,
     required: true,
+    trim: true,
   },
   expectation: {
     type: String,
     required: true,
+    trim: true,
   },
   tagged: {
     type: String,
     default: "General Purpose",
+    trim: true,
+    index: true,
   },
-  createdAt: {
-    type: Date,
-    default: new Date(),
-  },
-  updatedAt: {
-    type: Date,
-    default: new Date(),
-  },
+  isActive: {
+    type: Boolean,
+    default: true,
+    index: true,
+  }
+}, {
+  timestamps: true
 });
 
+// Compound indexes for common query patterns
+HypothesisSchema.index({ hypothesisNumber: 1, isActive: 1 });
+HypothesisSchema.index({ tagged: 1, isActive: 1 });
+HypothesisSchema.index({ name: 1, isActive: 1 });
+
+
 const Hypothesis = model<IHypothesis>("hypos", HypothesisSchema);
 
 export default Hypothesis;

package/src/models/HypothesisSheet.ts

@@ -2,7 +2,7 @@ import mongoose, { Document, Schema, model } from "mongoose";
 import HypothesisSheetConstants from "../constant";
 
 export interface IHypothesisSheet extends Document {
-  organizationId?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
   client?: mongoose.Schema.Types.ObjectId;
   viewId?: string;
   pageelement?: mongoose.Schema.Types.ObjectId;
@@ -25,8 +25,9 @@ export interface IHypothesisSheet extends Document {
 const HypothesisSheetSchema = new Schema<IHypothesisSheet>(
   {
     organizationId: {
-      type: String,
+      type: mongoose.Schema.Types.ObjectId,
       default: null,
+      ref: "organization",
     },
     client: {
       type: Schema.Types.ObjectId,

package/src/models/LandingPages.ts

@@ -2,19 +2,29 @@ import mongoose, { Document, Schema, model } from "mongoose";
 
 export interface ILandingPagesData extends Document {
   conversionRate?: Number;
+  lastUpdated?: Date;
 }
 
 const LandingPageDataSchema = new Schema<ILandingPagesData>({
   conversionRate: {
     type: Number,
+    min: 0,
+    max: 100,
+    index: true,
   },
+  lastUpdated: {
+    type: Date,
+    default: Date.now,
+  }
 });
 
 export interface ILandingPages extends Document {
   title: string;
   client?: mongoose.Schema.Types.ObjectId;
+  organizationId?: mongoose.Schema.Types.ObjectId;
   screenshot?: string;
   dataPoints?: ILandingPagesData;
+  isActive?: boolean;
 }
 
 const LandingPagesSchema = new Schema<ILandingPages>(
@@ -22,25 +32,49 @@ const LandingPagesSchema = new Schema<ILandingPages>(
     title: {
       type: String,
       required: true,
+      trim: true,
+      index: true,
     },
     client: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "client",
       required: true,
+      index: true,
+    },
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
+      index: true,
     },
     screenshot: {
       type: String,
       default: null,
+      trim: true,
     },
     dataPoints: {
       type: LandingPageDataSchema,
       default: {},
     },
+    isActive: {
+      type: Boolean,
+      default: true,
+      index: true,
+    }
   },
   {
     timestamps: true,
   }
 );
 
+// Compound indexes for common query patterns
+LandingPagesSchema.index({ client: 1, title: 1 }, { unique: true });
+LandingPagesSchema.index({ client: 1, isActive: 1 });
+LandingPagesSchema.index({ organizationId: 1, client: 1 });
+LandingPagesSchema.index({ organizationId: 1, title: 1 });
+LandingPagesSchema.index({ client: 1, 'dataPoints.conversionRate': -1 });
+
+// Text index for full-text search
+LandingPagesSchema.index({ title: 'text' });
+
 const LandingPages = model<ILandingPages>("LandingPages", LandingPagesSchema);
 export default LandingPages;

package/src/models/NewIdeas.ts

@@ -1,7 +1,7 @@
 import mongoose, { Document, Schema, model } from "mongoose";
 
 export interface INewIdeas extends Document {
-  organisationId?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
   ideaName: string;
   client?: mongoose.Schema.Types.ObjectId;
   hypothesis?: mongoose.Schema.Types.ObjectId;
@@ -14,8 +14,9 @@ export interface INewIdeas extends Document {
 
 const NewIdeasSchema = new Schema<INewIdeas>(
   {
-    organisationId: {
-      type: String,
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
       default: null,
     },
     ideaName: {

package/src/models/Notification.ts

@@ -8,10 +8,16 @@ export interface INotification extends Document {
   archive?: boolean;
   module?: string;
   moduleData?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
 }
 
 const NotificationSchema = new Schema<INotification>(
   {
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
+      default: null,
+    },
     title: {
       type: String,
     },

package/src/models/Organization.ts

@@ -0,0 +1,86 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IOrganization extends Document {
+  name: string;
+  description: string;
+  adminEmail: string;
+  adminContact: string;
+  createdBy: mongoose.Schema.Types.ObjectId;
+  address: string;
+  city: string;
+  state: string;
+  zip: string;
+  country: string;
+  phone: string;
+  logo: string;
+  website: string;
+  createdAt: Date;
+  updatedAt: Date;
+  isActive: boolean;
+}
+const OrganizationSchema = new Schema<IOrganization>({
+  name: {
+    type: String,
+    required: true,
+    unique: true,
+  },
+  description: {
+    type: String,
+    required: true,
+  },
+  adminEmail: {
+    type: String,
+    required: true,
+  },
+  adminContact: {
+    type: String,
+    required: true,
+  },
+  createdBy: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "user",
+    },
+  address: {
+    type: String,
+    required: true,
+  },
+  city: {
+    type: String,
+    required: true,
+  },
+  state: {
+    type: String,
+    required: true,
+  },
+  zip: {
+    type: String,
+    required: true,
+  },
+  country: {
+    type: String,
+    required: true,
+    },
+  phone: {
+    type: String,
+    required: true,
+  },
+  logo: {
+    type: String,
+    required: true,
+  },
+  website: {
+    type: String,
+    required: true,
+  },
+  isActive: {
+    type: Boolean,
+    default: true,
+  },
+}, {
+    timestamps: true
+});
+const Organization = model<IOrganization>("organization", OrganizationSchema);
+
+OrganizationSchema.index({ name: 1, isActive: 1 });
+
+export default Organization;