codebase-models 1.0.7 → 2.0.1

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 = mongoose.models.organization || model<IOrganization>("organization", OrganizationSchema);
+
+OrganizationSchema.index({ name: 1, isActive: 1 });
+
+export default Organization;

package/src/models/Page.ts

@@ -1,6 +1,7 @@
 import mongoose, { Document, Schema, model } from "mongoose";
 import slug from "mongoose-slug-updater"
 mongoose.plugin(slug)
+
 export interface IUrltargetings extends Document {
   type: string;
   url: string;
@@ -10,24 +11,32 @@ export interface IUrltargetings extends Document {
 export interface IPage extends Document {
   name: string;
   client?: mongoose.Schema.Types.ObjectId;
+  organizationId?: mongoose.Schema.Types.ObjectId;
   trigger: string;
   trigger_js: string;
   api_name: string;
   poll_on_rules: Boolean;
   deactivation_mode: string;
   rules_js: string;
-  urltargetings: IUrltargetings;
+  urltargetings: IUrltargetings[];
+  isActive?: boolean;
 }
 
 const UrltargetingsSchema = new Schema<IUrltargetings>({
   type: {
     type: String,
+    required: true,
+    trim: true,
   },
   url: {
     type: String,
+    required: true,
+    trim: true,
   },
   url_type: {
     type: String,
+    required: true,
+    trim: true,
   },
 });
 
@@ -35,35 +44,83 @@ const PageSchema = new Schema<IPage>({
   name: {
     type: String,
     required: true,
+    trim: true,
+    index: true,
   },
   trigger: {
     type: String,
-    default: "direct"
+    default: "direct",
+    trim: true,
+    index: true,
+  },
+  organizationId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "organization",
+    default: null,
+    index: true,
   },
   client: {
     type: mongoose.Schema.Types.ObjectId,
     ref: "client",
+    required: true,
+    index: true,
   },
   trigger_js: {
     type: String,
-    default: ""
+    default: "",
+    trim: true,
+  },
+  api_name: { 
+    type: String, 
+    slug: ["name"], 
+    slugPaddingSize: 4,  
+    unique: true,
+    trim: true,
   },
-  api_name: { type: String, slug: ["name"], slugPaddingSize: 4,  unique: true },
   poll_on_rules: {
     type: Boolean,
     default: false,
+    index: true,
   },
   deactivation_mode: {
     type: String,
     default: "reset",
+    trim: true,
   },
   rules_js: {
     type: String,
-    default:"return true"
+    default: "return true",
+    trim: true,
   },
   urltargetings: [UrltargetingsSchema],
+  isActive: {
+    type: Boolean,
+    default: true,
+    index: true,
+  }
+}, {
+  timestamps: true
 });
 
-const Page = model<IPage>("page", PageSchema);
+// Compound indexes for common query patterns
+PageSchema.index({ client: 1, name: 1 }, { unique: true });
+PageSchema.index({ client: 1, isActive: 1 });
+PageSchema.index({ organizationId: 1, client: 1 });
+PageSchema.index({ organizationId: 1, name: 1 });
+
+// Text index for full-text search
+// PageSchema.index({ 
+//   name: 'text',
+//   trigger_js: 'text',
+//   rules_js: 'text'
+// }, {
+//   weights: {
+//     name: 10,
+//     trigger_js: 5,
+//     rules_js: 5
+//   }
+// });
+
+const Page = mongoose.models.page || model<IPage>("page", PageSchema);
 
 export default Page;

package/src/models/PageElement.ts

@@ -1,8 +1,13 @@
 import mongoose, { Document, Schema, model } from "mongoose";
+import slug from "mongoose-slug-updater"
+mongoose.plugin(slug)
 
 export interface IPageElement extends Document {
   name: string;
   slug?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
+  client?: mongoose.Schema.Types.ObjectId;
+  isActive?: boolean;
   createdAt?: Date;
   updatedAt?: Date;
 }
@@ -11,20 +16,46 @@ const PageElementSchema = new Schema<IPageElement>({
   name: {
     type: String,
     required: true,
+    trim: true,
+    index: true,
   },
   slug: {
-    type: String,
+    type: String, 
+    slug: ["name"], 
+    slugPaddingSize: 4,  
+    unique: true,
+    trim: true,
   },
-  createdAt: {
-    type: Date,
-    default: new Date(),
+  organizationId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "organization",
+    index: true,
+    default: null,
   },
-  updatedAt: {
-    type: Date,
-    default: new Date(),
+  client: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "client",
+    required: true,
+    index: true,
   },
+  isActive: {
+    type: Boolean,
+    default: true,
+    index: true,
+  }
+}, {
+  timestamps: true
 });
 
-const PageElement = model<IPageElement>("pageelement", PageElementSchema);
+// Compound indexes for common query patterns
+PageElementSchema.index({ client: 1, name: 1 }, { unique: true });
+PageElementSchema.index({ client: 1, isActive: 1 });
+PageElementSchema.index({ organizationId: 1, client: 1 });
+PageElementSchema.index({ organizationId: 1, name: 1 });
+
+// Text index for full-text search
+PageElementSchema.index({ name: 'text' });
+
+const PageElement = mongoose.models.pageelement || model<IPageElement>("pageelement", PageElementSchema);
 
 export default PageElement;

package/src/models/PageTestType.ts

@@ -3,30 +3,47 @@ import mongoose, { Document, Schema, model } from "mongoose";
 export interface IPageTestType extends Document {
   name: string;
   details?: string;
+  isActive?: boolean;
   createdAt?: Date;
   updatedAt?: Date;
+  organizationId?: mongoose.Schema.Types.ObjectId;
 }
 
 const PageTestTypeSchema = new Schema<IPageTestType>({
+  organizationId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "organization",
+    default: null,
+  },
   name: {
     type: String,
     required: true,
     unique: true,
+    trim: true,
+    index: true,
   },
   details: {
     type: String,
     default: "",
+    trim: true,
   },
   createdAt: {
     type: Date,
     default: new Date(),
   },
-  updatedAt: {
-    type: Date,
-    default: new Date(),
-  },
+  isActive: {
+    type: Boolean,
+    default: true,
+    index: true,
+  }
+}, {
+  timestamps: true
 });
 
-const PageTestType = model<IPageTestType>("pagetesttype", PageTestTypeSchema);
+// Compound indexes for common query patterns
+PageTestTypeSchema.index({ name: 1, isActive: 1 });
+
+
+const PageTestType = mongoose.models.pagetesttype || model<IPageTestType>("pagetesttype", PageTestTypeSchema);
 
 export default PageTestType;

package/src/models/Portfolio.ts

@@ -3,6 +3,7 @@ import mongoose, { Document, Schema, model } from "mongoose";
 export interface IPortfolio extends Document {
   portfoliokey: mongoose.Schema.Types.Mixed;
   portfolioData?: mongoose.Schema.Types.Mixed;
+  organizationId?: mongoose.Schema.Types.ObjectId;
 }
 
 const PortfolioSchema = new Schema<IPortfolio>(
@@ -15,12 +16,17 @@ const PortfolioSchema = new Schema<IPortfolio>(
       type: mongoose.Schema.Types.Mixed,
       default: null,
     },
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
+      default: null,
+    },
   },
   {
     timestamps: true,
   }
 );
 
-const Portfolio = model<IPortfolio>("portfolio", PortfolioSchema);
+const Portfolio = mongoose.models.portfolio || model<IPortfolio>("portfolio", PortfolioSchema);
 
 export default Portfolio;

package/src/models/PrecalculationFilters.ts

@@ -0,0 +1,68 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IPrecalculationFilters extends Document {
+  title: string;
+  organizationId: mongoose.Schema.Types.ObjectId;
+  client: mongoose.Schema.Types.ObjectId;
+  filters: any;
+  otherFilters: any;
+}
+
+const PrecalculationFiltersSchema = new Schema<IPrecalculationFilters>({
+    title: {
+        type: String,
+        trim: true,
+    },
+    organizationId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "organization",
+    },
+    client: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "client",
+    },
+    filters: {
+        type: Object,
+        required: true,
+    },
+    otherFilters: {
+        type: Object,
+        required: true,
+    },
+}, {
+    timestamps: true
+});
+
+// Pre-save middleware to generate title from filters
+// PrecalculationFiltersSchema.pre('save', function(next) {
+//     if (!this.title) {
+//         // Generate title from filters object
+//         const filterValues = Object.values(this.filters);
+//         const otherFilterValues = Object.values(this.otherFilters);
+        
+//         // Combine all values and create a title
+//         const allValues = [...filterValues, ...otherFilterValues]
+//             .filter(value => value !== null && value !== undefined)
+//             .map(value => {
+//                 if (typeof value === 'object') {
+//                     return Object.values(value).join(' ');
+//                 }
+//                 return value.toString();
+//             })
+//             .join(' ');
+        
+//         // Truncate if too long and add ellipsis
+//         this.title = allValues.length > 50 
+//             ? allValues.substring(0, 47) + '...' 
+//             : allValues;
+//     }
+//     next();
+// });
+
+PrecalculationFiltersSchema.index({ organizationId: 1, test: 1 });
+PrecalculationFiltersSchema.index({ organizationId: 1, client: 1 });
+
+// Check if model is already registered
+const PrecalculationFilters = mongoose.models.precalculationfilter || model<IPrecalculationFilters>("precalculationfilter", PrecalculationFiltersSchema);
+
+export default PrecalculationFilters;

package/src/models/QueryLog.ts

@@ -1,7 +1,7 @@
 import mongoose, { Document, Schema, model } from "mongoose";
 
 export interface IQueryLog extends Document {
-  organisationId?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
   query: string;
   timeTaken: number;
   user?: mongoose.Schema.Types.ObjectId;
@@ -9,8 +9,9 @@ export interface IQueryLog extends Document {
 
 const QueryLogSchema = new Schema<IQueryLog>(
   {
-    organisationId: {
-      type: String,
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
       default: null,
     },
     query: {
@@ -29,6 +30,6 @@ const QueryLogSchema = new Schema<IQueryLog>(
   }
 );
 
-const QueryLog = model<IQueryLog>("querylog", QueryLogSchema);
+const QueryLog = mongoose.models.querylog || model<IQueryLog>("querylog", QueryLogSchema);
 
 export default QueryLog;

package/src/models/ReadNotification.ts

@@ -4,10 +4,16 @@ export interface IReadNotification extends Document {
   notification?: mongoose.Schema.Types.ObjectId;
   user?: mongoose.Schema.Types.ObjectId;
   read?: boolean;
+  organizationId?: mongoose.Schema.Types.ObjectId;
 }
 
 const ReadNotificationSchema = new Schema<IReadNotification>(
   {
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
+      default: null,
+    },
     notification: {
       type: Schema.Types.ObjectId,
       ref: "notification",
@@ -26,7 +32,7 @@ const ReadNotificationSchema = new Schema<IReadNotification>(
   }
 );
 
-const ReadNotification = model<IReadNotification>(
+const ReadNotification = mongoose.models.readnotification || model<IReadNotification>(
   "readnotification",
   ReadNotificationSchema
 );

package/src/models/Report.ts

@@ -15,78 +15,66 @@ export interface IReports extends Document {
   from?: Date;
   to?: Date;
   createdBy?: mongoose.Schema.Types.ObjectId;
-  excludedFromCalculations?: Boolean;
+  excludedFromCalculations?: boolean;
   createdAt?: Date;
   updatedAt?: Date;
+  organizationId?: mongoose.Schema.Types.ObjectId;
 }
 
-const ReportsSchema = new Schema<IReports>({
-  name: {
-    type: String,
-    required: true,
-  },
-  segmentName: {
-    type: String,
-  },
-  reportLink: {
-    type: String,
-  },
-  conclusion: {
-    type: String,
-  },
-  variant: {
-    type: String,
-  },
-  client: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: "client",
-  },
-  viewId: {
-    type: String,
-  },
-  test: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: "test",
-  },
-  gaTestId: {
-    type: String,
-  },
-  reportDetails: {
-    type: mongoose.Schema.Types.Mixed,
-  },
-  learnings: {
-    type: mongoose.Schema.Types.Mixed,
-    default: [],
-  },
-  from: {
-    type: Date,
-  },
-  to: {
-    type: Date,
-  },
-  createdBy: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: "user",
-  },
-  excludedFromCalculations: {
-    type: Boolean,
-    default: false
-  },
-  createdAt: {
-    type: Date,
-    default: new Date(),
-  },
-  updatedAt: {
-    type: Date,
-    default: new Date(),
-  },
-});
+const ReportsSchema = new Schema<IReports>(
+  {
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
+      default: null,
+    },
+    name: { type: String, required: true },
+    segmentName: { type: String },
+    reportLink: { type: String },
+    conclusion: { type: String },
+    variant: { type: String },
+    client: { 
+      type: mongoose.Schema.Types.ObjectId, 
+      ref: "client" 
+    },
+    viewId: { type: String },
+    test: { 
+      type: mongoose.Schema.Types.ObjectId, 
+      ref: "test" 
+    },
+    gaTestId: { type: String },
+    reportDetails: { type: mongoose.Schema.Types.Mixed },
+    learnings: { 
+      type: mongoose.Schema.Types.Mixed, 
+      default: [] 
+    },
+    from: { type: Date },
+    to: { type: Date },
+    createdBy: { 
+      type: mongoose.Schema.Types.ObjectId, 
+      ref: "user" 
+    },
+    excludedFromCalculations: { 
+      type: Boolean, 
+      default: false 
+    }
+  },
+  {
+    timestamps: true
+  }
+);
 
-ReportsSchema.index({
-  client: 1,
-  conclusion: 1,
-});
+// Add compound indexes for better query performance
+ReportsSchema.index({ client: 1, conclusion: 1 });
+ReportsSchema.index({ test: 1, to: -1 }); // For sorting reports by date
+ReportsSchema.index({ client: 1, test: 1 }); // For client-specific test reports
+ReportsSchema.index({ from: 1, to: 1 }); // For date range queries
+ReportsSchema.index({ client: 1, "reportDetails.implementedStatus": 1 }); // For implemented status queries
+ReportsSchema.index({ client: 1, "reportDetails.conclusionFactorStatusAll": 1 }); // For conclusion factor queries
+ReportsSchema.index({ client: 1, gaTestId: 1 }); // For GA test ID lookups
+ReportsSchema.index({ createdBy: 1, to: -1 }); // For user's reports
+ReportsSchema.index({ client: 1, excludedFromCalculations: 1 }); // For calculation exclusions
 
-const Report = model<IReports>("report", ReportsSchema);
+const Report = mongoose.models.report || model<IReports>("report", ReportsSchema);
 
 export default Report;

package/src/models/Role.ts

@@ -2,6 +2,9 @@ import mongoose, { Document, Schema, model } from "mongoose";
 
 export interface IRole extends Document {
   name: string;
+  description?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
+  isActive?: boolean;
   createdAt?: Date;
   updatedAt?: Date;
 }
@@ -12,17 +15,39 @@ const RoleSchema = new Schema<IRole>({
     unique: true,
     required: true,
     enum: ["USER", "ADMIN", "EDITOR", "COLLABORATOR", "CLIENT"],
+    trim: true,
+    index: true,
+    uppercase: true,
   },
-  createdAt: {
-    type: Date,
-    default: new Date(),
+  description: {
+    type: String,
+    trim: true,
   },
-  updatedAt: {
-    type: Date,
-    default: new Date(),
+  organizationId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "organization",
+    index: true,
+    default: null,
   },
+  isActive: {
+    type: Boolean,
+    default: true,
+    index: true,
+  }
+}, {
+  timestamps: true
+});
+
+// Compound indexes for common query patterns
+RoleSchema.index({ name: 1, isActive: 1 });
+RoleSchema.index({ organizationId: 1, name: 1 });
+
+// Add text index for search
+RoleSchema.index({ 
+  name: 'text',
+  description: 'text'
 });
 
-const Role = model<IRole>("role", RoleSchema);
+const Role = mongoose.models.role || model<IRole>("role", RoleSchema);
 
 export default Role;