codebase-models 1.0.7 → 2.0.0

package/src/models/Announcement.ts

@@ -2,48 +2,71 @@ import mongoose, { Document, Schema, model } from "mongoose";
 
 export interface IAnnouncement extends Document {
   title: string;
-  description?: String;
-  active?: Boolean;
-  forRoles?: mongoose.Schema.Types.ObjectId;
-  forUsers?: mongoose.Schema.Types.ObjectId;
-  readBy?: mongoose.Schema.Types.ObjectId;
+  description?: string;
+  active?: boolean;
+  forRoles?: mongoose.Schema.Types.ObjectId[];
+  forUsers?: mongoose.Schema.Types.ObjectId[];
+  readBy?: mongoose.Schema.Types.ObjectId[];
+  organizationId?: mongoose.Schema.Types.ObjectId;
 }
 
 const AnnouncementSchema = new Schema<IAnnouncement>(
   {
-    title: {
-      type: String,
-      required: true,
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
+      default: null,
     },
-    description: {
-      type: String,
-      required: false,
+    title: { 
+      type: String, 
+      required: true,
+      trim: true 
     },
-    active: {
-      type: Boolean,
-      default: true,
+    description: { 
+      type: String, 
+      trim: true 
     },
-    forRoles: {
-      type: [mongoose.Schema.Types.ObjectId],
-      required: true,
-      ref: "role",
+    active: { 
+      type: Boolean, 
+      default: true 
     },
-    forUsers: {
-      type: [mongoose.Schema.Types.ObjectId],
-      required: false,
-      ref: "user",
+    forRoles: { 
+      type: [mongoose.Schema.Types.ObjectId], 
+      required: true, 
+      ref: "role" 
     },
-    readBy: {
-      type: [mongoose.Schema.Types.ObjectId],
-      required: false,
-      ref: "user",
+    forUsers: { 
+      type: [mongoose.Schema.Types.ObjectId], 
+      ref: "user" 
     },
+    readBy: { 
+      type: [mongoose.Schema.Types.ObjectId], 
+      ref: "user" 
+    }
   },
   {
-    timestamps: true,
+    timestamps: true
   }
 );
 
+// Add compound indexes for better query performance
+AnnouncementSchema.index({ active: 1, createdAt: -1 }); // For active announcements sorted by date
+AnnouncementSchema.index({ forRoles: 1, active: 1 }); // For role-based announcements
+AnnouncementSchema.index({ forUsers: 1, active: 1 }); // For user-specific announcements
+AnnouncementSchema.index({ readBy: 1 }); // For tracking read status
+AnnouncementSchema.index({ title: 1 }, { collation: { locale: 'en', strength: 2 } }); // Case-insensitive title search
+
+// Add text index for full-text search
+// AnnouncementSchema.index({ 
+//   title: 'text', 
+//   description: 'text' 
+// }, { 
+//   weights: { 
+//     title: 10, 
+//     description: 5 
+//   } 
+// });
+
 const Announcement = model<IAnnouncement>("announcement", AnnouncementSchema);
 
 export default Announcement;

package/src/models/Audience.ts

@@ -1,6 +1,7 @@
 import mongoose, { Document, Schema, model } from "mongoose";
 
 export interface IAudience extends Document {
+  organizationId?: mongoose.Schema.Types.ObjectId;
   name: string;
   rules_js?: string;
   client?: mongoose.Schema.Types.ObjectId;
@@ -8,6 +9,11 @@ export interface IAudience extends Document {
 
 const AudienceSchema = new Schema<IAudience>(
   {
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
+      default: null,
+    },
     name: {
       type: String,
       required: true,

package/src/models/BqPreCompiledData.ts

@@ -0,0 +1,62 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IBqPreCompiledData extends Document {
+  title: string;
+  organizationId: mongoose.Schema.Types.ObjectId;
+  client: mongoose.Schema.Types.ObjectId;
+  test: mongoose.Schema.Types.ObjectId;
+  from: Date;
+  to: Date;
+  filters: any;
+  otherFilters: any;
+  cloudurl: string;
+}
+
+const BqPreCompiledDataSchema = new Schema<IBqPreCompiledData>({
+  title: {
+    type: String,
+    default: null,
+  },
+  organizationId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "organization",
+    default: null,
+  },
+  client: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "client",
+    default: null,
+  },
+  test: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "test",
+    default: null,
+  },
+  from: {
+    type: Date,
+    default: null,
+  },
+  filters: {
+    type: Object,
+    default: null,
+  },
+  to: {
+    type: Date,
+    default: null,
+  },
+  otherFilters: {
+    type: Object,
+    default: null,
+  },
+  cloudurl: {
+    type: String,
+    default: null,
+  },
+}, {
+    timestamps: true
+});
+
+BqPreCompiledDataSchema.index({ organizationId: 1, client: 1 });
+const BqPreCompiledData = model<IBqPreCompiledData>("bqprecompileddata", BqPreCompiledDataSchema);
+
+export default BqPreCompiledData;

package/src/models/CVRReport.ts

@@ -1,19 +1,27 @@
 import mongoose, { Document, Schema, model } from "mongoose";
 
 export interface ICVRReport extends Document {
+  organizationId?: mongoose.Schema.Types.ObjectId;
   reportLink?: string;
   client?: mongoose.Schema.Types.ObjectId;
 }
 
 const CVRReportSchema = new Schema<ICVRReport>(
   {
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
+      default: null,
+    },
     reportLink: {
       type: String,
       default: null,
+      trim: true,
     },
     client: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "client",
+      index: true,
     },
   },
   {
@@ -21,5 +29,14 @@ const CVRReportSchema = new Schema<ICVRReport>(
   }
 );
 
+// Compound index for client and reportLink
+CVRReportSchema.index({ client: 1 });
+
+// Sparse index for reportLink
+CVRReportSchema.index({ reportLink: 1 }, { sparse: true });
+
+// TTL index for automatic cleanup of old reports (1 year)
+CVRReportSchema.index({ createdAt: 1 }, { expireAfterSeconds: 31536000 });
+
 const CVRReport = model<ICVRReport>("cvrreport", CVRReportSchema);
 export default CVRReport;

package/src/models/Client.ts

@@ -12,11 +12,11 @@ export interface IProperty extends Document {
 const PropertySchema: Schema = new Schema<IProperty>({
   propertyname: { type: String, required: true },
   viewId: { type: String, required: true },
-  platform: { type: String, required: false, default: "UA" },
+  platform: { type: String, default: "GA4" }
 });
 
 export interface IClient extends Document {
-  organisationId?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
   name: string;
   slug?: string;
   viewId?: string;
@@ -37,71 +37,51 @@ export interface IClient extends Document {
 
 const ClientSchema: Schema = new Schema<IClient>(
   {
-    organisationId: {
-      type: String,
-      default: null,
-    },
-    name: {
-      type: String,
-      required: true,
-    },
-    slug: { type: String, slug: ["name"], slugPaddingSize: 4, unique: true },
-    viewId: {
-      type: String,
-    },
-    portfolioClient: {
-      type: Boolean,
-      default: false,
+    organizationId: { type: mongoose.Schema.Types.ObjectId, 
+      ref: "organization",
+      default: null },
+    name: { type: String, required: true },
+    slug: { 
+      type: String, 
+      slug: ["name"], 
+      slugPaddingSize: 4, 
+      unique: true 
     },
+    viewId: { type: String },
+    portfolioClient: { type: Boolean, default: false },
     gaproperties: [PropertySchema],
-    tier: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "tier",
-      default: null,
-    },
-    active: {
-      type: Boolean,
-      default: true,
-    },
-    currency: {
-      type: String,
-      default: "USD",
-    },
-    logo: {
-      type: String,
-      default: "",
-    },
-    createdBy: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "user",
-      default: null,
-    },
-    onboardDate: {
-      type: Date,
-      default: new Date(),
-    },
-    bqClientId: {
-      type: String,
-      default: null,
-    },
-    defaultDataSet: {
-      type: String,
-    },
-    NDAStatus: {
-      type: Boolean,
-      default: false,
-    },
-    retainerValue: {
-      type: Number,
+    tier: { 
+      type: mongoose.Schema.Types.ObjectId, 
+      ref: "tier", 
+      default: null 
     },
-    useIntraDayTable: {
-      type: Boolean,
+    active: { type: Boolean, default: true },
+    currency: { type: String, default: "USD" },
+    logo: { type: String, default: "" },
+    createdBy: { 
+      type: mongoose.Schema.Types.ObjectId, 
+      ref: "user", 
+      default: null 
     },
+    onboardDate: { type: Date, default: Date.now },
+    bqClientId: { type: String, default: null },
+    defaultDataSet: { type: String },
+    NDAStatus: { type: Boolean, default: false },
+    retainerValue: { type: Number },
+    useIntraDayTable: { type: Boolean }
   },
-  { timestamps: true }
+  { 
+    timestamps: true 
+  }
 );
 
+// Add compound indexes for better query performance
 ClientSchema.index({ active: 1 });
+ClientSchema.index({ organizationId: 1, active: 1 });
+ClientSchema.index({ name: 1 }, { collation: { locale: 'en', strength: 2 } }); // Case-insensitive search
+ClientSchema.index({ tier: 1, active: 1 }); // For tier-based queries
+ClientSchema.index({ onboardDate: 1 }); // For date-based queries
+ClientSchema.index({ portfolioClient: 1, active: 1 }); // For portfolio client queries
 
 const Client = model<IClient>("client", ClientSchema);
 

package/src/models/ClientAdditionalRevenue.ts

@@ -1,7 +1,7 @@
 import mongoose, { Document, Schema, model } from "mongoose";
 
 export interface IClientAdditionalRevenue extends Document {
-  organisationId?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
   client?: mongoose.Schema.Types.ObjectId;
   additionalRevenueForTests: IAdditionalRevenue;
   createdBy?: mongoose.Schema.Types.ObjectId;
@@ -36,8 +36,9 @@ const AdditionalRevenueSchema = new Schema<IAdditionalRevenue>({
 
 const ClientAdditionalRevenueSchema = new Schema<IClientAdditionalRevenue>(
   {
-    organisationId: {
-      type: String,
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
       default: null,
     },
     client: {

package/src/models/ClientLearning.ts

@@ -2,7 +2,7 @@ import mongoose, { Document, Schema, model } from "mongoose";
 
 export interface IClientLearning extends Document {
   name: string;
-  organisationId?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
   client?: mongoose.Schema.Types.ObjectId;
   viewId?: string;
   createdBy?: mongoose.Schema.Types.ObjectId;
@@ -13,9 +13,11 @@ const ClientLearningSchema = new Schema<IClientLearning>(
     name: {
       type: String,
       required: true,
+      trim: true,
     },
-    organisationId: {
-      type: String,
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
       default: null,
     },
     client: {
@@ -35,10 +37,12 @@ const ClientLearningSchema = new Schema<IClientLearning>(
   }
 );
 
-ClientLearningSchema.index({
-  client: 1,
-  viewId: 1,
-});
+// Compound indexes for common query patterns
+ClientLearningSchema.index({ client: 1 });
+// Sparse indexes for optional fields
+ClientLearningSchema.index({ organisationId: 1 }, { sparse: true });
+// Case-insensitive index for name
+ClientLearningSchema.index({ name: 1 }, { collation: { locale: 'en', strength: 2 } });
 
 const ClientLearning = model<IClientLearning>(
   "clientlearning",

package/src/models/ClientLinks.ts

@@ -1,7 +1,7 @@
 import mongoose, { Document, Schema, model } from "mongoose";
 
 export interface IClientLinks extends Document {
-  organisationId?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
   title: string;
   description?: string;
   link?: string;
@@ -13,20 +13,24 @@ export interface IClientLinks extends Document {
 
 const ClientLinksSchema = new Schema<IClientLinks>(
   {
-    organisationId: {
-      type: String,
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
       default: null,
     },
     title: {
       type: String,
       required: true,
+      trim: true,
     },
     description: {
       type: String,
+      trim: true,
     },
     link: {
       type: String,
       required: true,
+      trim: true,
     },
     client: {
       type: mongoose.Schema.Types.ObjectId,
@@ -49,10 +53,17 @@ const ClientLinksSchema = new Schema<IClientLinks>(
   }
 );
 
-ClientLinksSchema.index({
-  client: 1,
-  viewId: 1,
-});
+// Compound indexes for common query patterns
+ClientLinksSchema.index({ client: 1 });
+ClientLinksSchema.index({ client: 1, private: 1 });
+ClientLinksSchema.index({ client: 1, createdAt: -1 });
+
+// Sparse indexes for optional fields
+ClientLinksSchema.index({ viewId: 1 }, { sparse: true });
+ClientLinksSchema.index({ organisationId: 1 }, { sparse: true });
+
+// Case-insensitive indexes
+ClientLinksSchema.index({ title: 1 }, { collation: { locale: 'en', strength: 2 } });
 
 const ClientLinks = model<IClientLinks>("clientlink", ClientLinksSchema);
 export default ClientLinks;

package/src/models/ClientNextSteps.ts

@@ -2,7 +2,7 @@ import mongoose, { Document, Schema, model } from "mongoose";
 
 export interface IClientNextSteps extends Document {
   name: string;
-  organisationId?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
   client?: mongoose.Schema.Types.ObjectId;
   viewId?: string;
   createdBy?: mongoose.Schema.Types.ObjectId;
@@ -14,8 +14,9 @@ const ClientNextStepsSchema = new Schema<IClientNextSteps>(
       type: String,
       required: true,
     },
-    organisationId: {
-      type: String,
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
       default: null,
     },
     client: {

package/src/models/ClientNote.ts

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

package/src/models/ClientReportsTemp.ts

@@ -1,7 +1,7 @@
 import mongoose, { Schema, model } from "mongoose";
 
 export interface IClientReportsTemp extends Document {
-  organisationId?: string;
+  organizationId?: mongoose.Schema.Types.ObjectId;
   client?: mongoose.Schema.Types.ObjectId;
   viewId?: string;
   test?: mongoose.Schema.Types.ObjectId;
@@ -15,8 +15,9 @@ export interface IClientReportsTemp extends Document {
 
 const ClientReportsTempSchema = new Schema<IClientReportsTemp>(
   {
-    organisationId: {
-      type: String,
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
       default: null,
     },
     client: {
@@ -32,12 +33,15 @@ const ClientReportsTempSchema = new Schema<IClientReportsTemp>(
     },
     filters: {
       type: String,
+      trim: true,
     },
     metricsFilters: {
       type: String,
+      trim: true,
     },
     date: {
       type: Date,
+      index: true,
     },
     report: {
       type: mongoose.Schema.Types.Mixed,
@@ -45,6 +49,7 @@ const ClientReportsTempSchema = new Schema<IClientReportsTemp>(
     deactivated: {
       type: Boolean,
       default: false,
+      index: true,
     },
     createdBy: {
       type: mongoose.Schema.Types.ObjectId,
@@ -56,6 +61,22 @@ const ClientReportsTempSchema = new Schema<IClientReportsTemp>(
   }
 );
 
+// Compound indexes for common query patterns
+ClientReportsTempSchema.index({ client: 1 });
+ClientReportsTempSchema.index({ client: 1, test: 1 });
+ClientReportsTempSchema.index({ client: 1, deactivated: 1 });
+ClientReportsTempSchema.index({ client: 1, date: -1 });
+ClientReportsTempSchema.index({ createdBy: 1, date: -1 });
+ClientReportsTempSchema.index({ organisationId: 1, client: 1 });
+
+// Sparse indexes for optional fields
+ClientReportsTempSchema.index({ viewId: 1 }, { sparse: true });
+ClientReportsTempSchema.index({ organisationId: 1 }, { sparse: true });
+ClientReportsTempSchema.index({ test: 1 }, { sparse: true });
+
+// TTL index for automatic cleanup of old reports
+ClientReportsTempSchema.index({ date: 1 }, { expireAfterSeconds: 86400 }); // 24 hours
+
 const ClientReportsTemp = model<IClientReportsTemp>(
   "clientreportstemp",
   ClientReportsTempSchema

package/src/models/ClientRetention.ts

@@ -1,6 +1,7 @@
 import mongoose, { Document, Schema, model } from "mongoose";
 
 export interface IClientRetention extends Document {
+  organizationId?: mongoose.Schema.Types.ObjectId;
   client?: mongoose.Schema.Types.ObjectId;
   viewId?: string;
   year: Number;
@@ -16,10 +17,16 @@ export interface IClientRetention extends Document {
 
 const ClientRetentionSchema = new Schema<IClientRetention>(
   {
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
+      default: null,
+    },
     client: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "client",
       required: true,
+      index: true,
     },
     viewId: {
       type: String,
@@ -29,6 +36,7 @@ const ClientRetentionSchema = new Schema<IClientRetention>(
       type: Number,
       required: true,
       default: new Date().getFullYear(),
+      index: true,
     },
     retentions: {
       type: [
@@ -59,7 +67,7 @@ const ClientRetentionSchema = new Schema<IClientRetention>(
           retainerValue: {
             type: Number,
             required: true,
-            default:0,
+            default: 0,
           },
           otherPayments: {
             type: Number,
@@ -75,6 +83,24 @@ const ClientRetentionSchema = new Schema<IClientRetention>(
   }
 );
 
+// Compound indexes for common query patterns
+ClientRetentionSchema.index({ client: 1, year: 1 });
+ClientRetentionSchema.index({ client: 1, viewId: 1 });
+ClientRetentionSchema.index({ year: 1, "retentions.month": 1 });
+ClientRetentionSchema.index({ client: 1, "retentions.active": 1 });
+
+// Sparse indexes for optional fields
+ClientRetentionSchema.index({ viewId: 1 }, { sparse: true });
+
+// Partial index for active retentions
+ClientRetentionSchema.index(
+  { "retentions.active": 1 },
+  { partialFilterExpression: { "retentions.active": true } }
+);
+
+// Index for sorting by retainer value
+ClientRetentionSchema.index({ "retentions.retainerValue": -1 });
+
 const ClientRetention = model<IClientRetention>(
   "ClientRetention",
   ClientRetentionSchema