codebase-models 2.1.23 → 3.0.0

package/src/constant.ts

@@ -1,4 +1,4 @@
-import { v4 as uuidv4 } from 'uuid';
+import { v4 as uuidv4 } from "uuid";
 
 const HypothesisSheetConstants = {
   NO: 0,
@@ -13,6 +13,15 @@ const HypothesisSheetConstants = {
   GOOD: 2,
 };
 
+const RolesConstants = [
+  "USER",
+  "ADMIN",
+  "CLIENT",
+  "EXTERNAL",
+  "QA",
+  "OPTIMIZER",
+];
+
 /**
  * Generates a random unique identifier
  * @returns A 12-character uppercase string (increased from 8 for better uniqueness)
@@ -21,11 +30,102 @@ const HypothesisSheetConstants = {
 const generateRandomIID = (): string => {
   try {
     // Take first 12 characters instead of 8 for better uniqueness
-    return uuidv4().replace(/-/g, '').substring(0, 12).toUpperCase();
+    return uuidv4().replace(/-/g, "").substring(0, 12).toUpperCase();
   } catch (error) {
-    throw new Error(`Failed to generate random IID: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    throw new Error(
+      `Failed to generate random IID: ${
+        error instanceof Error ? error.message : "Unknown error"
+      }`
+    );
   }
 };
+const PermissionsConstants = {
+  dashboard: "dashboard",
+  reporting: "reporting",
+  insights: "insights",
+  documentsAndLinks: "documentsAndLinks",
+  cvrReports: "cvrReports",
+  abTesting: "abTesting",
+  abTestingDefault: "abTestingDefault",
+  manageOrganizations: "manageOrganizations",
+  manageInvitations: "manageInvitations",
+  manageClients: "manageClients",
+};
+
+const PackageFeaturesConstants = [
+  {
+    name: "DASHBOARD",
+    value: true,
+    description: "Access to the dashboard",
+    allowedCount: null,
+  },
+  {
+    name: "REPORTING",
+    value: true,
+    description: "Access to the reporting",
+    allowedCount: null,
+  },
+  {
+    name: "INSIGHTS",
+    value: true,
+    description: "Access to the insights",
+    allowedCount: null,
+  },
+  {
+    name: "DOCUMENTSANDLINKS",
+    value: true,
+    description: "Access to the documents and links",
+    allowedCount: 5,
+  },
+  {
+    name: "CVRREPORTS",
+    value: true,
+    description: "Access to the cvr reports",
+    allowedCount: null,
+  },
+  {
+    name: "ABTESTING",
+    value: false,
+    description: "Access to the ab testing",
+    allowedCount: null,
+  },
+  {
+    name: "ABTESTINGDEFAULT",
+    value: true,
+    description: "Access to the ab testing default",
+    allowedCount: null,
+  },
+  {
+    name: "MANAGEEXPERIMENTS",
+    value: true,
+    description: "Access to the experiments",
+    allowedCount: null,
+  },
+  {
+    name: "PRECALCULATIONS",
+    value: false,
+    description: "Access to the pre calculations",
+    allowedCount: null,
+  },
+  {
+    name: "MANAGEORGANIZATIONS",
+    value: true,
+    description: "Access to the organizations",
+    allowedCount: 1,
+  },
+  {
+    name: "MANAGEINVITATIONS",
+    value: true,
+    description: "Access to the invitations",
+    allowedCount: 1,
+  },
+  {
+    name: "MANAGECLIENTS",
+    value: true,
+    description: "Access to the clients",
+    allowedCount: 3,
+  },
+];
 
-export { generateRandomIID };
+export { generateRandomIID, RolesConstants, PermissionsConstants, PackageFeaturesConstants };
 export default HypothesisSheetConstants;

package/src/models/Client.ts

@@ -18,7 +18,7 @@ const PropertySchema: Schema = new Schema<IProperty>({
 
 export interface IClient extends Document {
   iid: string;
-  organizationId?: mongoose.Schema.Types.ObjectId;
+  organization: mongoose.Schema.Types.ObjectId;
   name: string;
   slug?: string;
   viewId?: string;
@@ -42,10 +42,14 @@ const ClientSchema: Schema = new Schema<IClient>(
     iid: {
       type: String,
       trim: true,
+      unique: true,
+      default: () => generateRandomIID()
     },
-    organizationId: { type: mongoose.Schema.Types.ObjectId, 
+    organization: { type: mongoose.Schema.Types.ObjectId, 
       ref: "organization",
-      default: null },
+      default: null,
+      required: true
+    },
     name: { type: String, required: true },
     slug: { 
       type: String, 
@@ -96,10 +100,9 @@ ClientSchema.pre('save', async function(next) {
   next();
 });
 
-ClientSchema.index({ iid: 1 }, { unique: true });
 // Add compound indexes for better query performance
 ClientSchema.index({ active: 1 });
-ClientSchema.index({ organizationId: 1, active: 1 });
+ClientSchema.index({ organization: 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

package/src/models/Invitation.ts

@@ -0,0 +1,50 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
+
+export interface IInvitation extends Document {
+    iid: string;
+    email: string;
+    invitedBy: mongoose.Types.ObjectId; // user who sent the invite
+    organization: mongoose.Types.ObjectId; 
+    client?: mongoose.Types.ObjectId; // optional (invite to specific client)
+    role?: string; // optional role name
+    permissions?: mongoose.Schema.Types.Mixed;
+    token: string;
+    status: string;
+    expiresAt: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+const InvitationSchema = new Schema<IInvitation>({
+  iid: { type: String, unique: true, default: () => generateRandomIID() },
+  email: { type: String, required: true },
+  invitedBy: { type: mongoose.Schema.Types.ObjectId, ref: "user", required: true },
+  organization: { type: mongoose.Schema.Types.ObjectId, ref: "organization", required: true },
+  client: { type: mongoose.Schema.Types.ObjectId, ref: "client" },
+  role: { type: String, enum: ["owner", "admin", "member"], default: "member" },
+  permissions: { type: mongoose.Schema.Types.Mixed, required: true, default: {
+    dashboard: true,
+    reporting: false,
+    insights: false,
+    documentsAndLinks: false,
+    cvrReports: false,
+    abTesting: false,
+    abTestingDefault: true,
+    manageExperiments: false,
+    preCalculations: false,
+  } },
+  token: { type: String, unique: true, required: true },
+  status: { type: String, enum: ["pending", "accepted", "expired", "revoked"], default: "pending" },
+  expiresAt: { type: Date, default: Date.now() + 1000 * 60 * 60 * 24 * 30 },
+},
+{
+    timestamps: true
+});
+
+InvitationSchema.index({ email: 1, organization: 1 });
+InvitationSchema.index({ token: 1 }, { unique: true });
+
+const Invitation = mongoose.models.invitation || model<IInvitation>("invitation", InvitationSchema);
+
+
+export default Invitation;

package/src/models/Organization.ts

@@ -1,86 +1,31 @@
 import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
 
 export interface IOrganization extends Document {
+  iid: string;
   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;
+  ownerId: mongoose.Schema.Types.ObjectId;
+  stripeCustomerId?: string;
+  packageId?: mongoose.Schema.Types.ObjectId;
+  subscriptionId: String;
+  subscriptionStatus: String;
+  lastPaymentDate: Date;
+  currentPeriodEnd: Date;
 }
 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,
-  },
+  iid: { type: String, default: () => generateRandomIID() },
+  name: { type: String, required: true },
+  ownerId: { type: mongoose.Schema.Types.ObjectId, ref: "user", required: true },
+  stripeCustomerId: String,
+  packageId: { type: mongoose.Types.ObjectId, ref: "package" },
+  subscriptionId: String,
+  subscriptionStatus: String,
+  lastPaymentDate: Date,
+  currentPeriodEnd: Date,
 }, {
     timestamps: true
 });
 const Organization = mongoose.models.organization || model<IOrganization>("organization", OrganizationSchema);
 
-OrganizationSchema.index({ name: 1, isActive: 1 });
 
 export default Organization;

package/src/models/Package.ts

@@ -0,0 +1,24 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID, PackageFeaturesConstants } from "../constant";
+
+export interface IPackage extends Document {
+  iid: string;
+  name: string;
+  stripeProductId: string;
+  features: mongoose.Schema.Types.Mixed;
+  // userPermissions: mongoose.Schema.Types.ObjectId;
+}
+const PackageSchema = new Schema<IPackage>({
+  iid: { type: String, unique: true, default: () => generateRandomIID() },
+  name: { type: String, required: true },
+  stripeProductId: { type: String},
+  // userPermissions: { type: mongoose.Schema.Types.ObjectId, ref: "userpermission", required: true },
+  features: { type: mongoose.Schema.Types.Mixed, required: true, default: PackageFeaturesConstants },
+},
+{
+    timestamps: true
+});
+const Package = mongoose.models.package || model<IPackage>("package", PackageSchema);
+
+
+export default Package;

package/src/models/Role.ts

@@ -20,44 +20,56 @@ export interface IRole extends Document {
   };
 }
 
-const RoleSchema = new Schema<IRole>({
-  name: {
-    type: String,
-    unique: true,
-    required: true,
-    enum: ["USER", "ADMIN", "EDITOR", "COLLABORATOR", "CLIENT", "EXTERNAL"],
-    trim: true,
-    uppercase: true,
+const RoleSchema = new Schema<IRole>(
+  {
+    name: {
+      type: String,
+      unique: true,
+      required: true,
+      enum: [
+        "USER",
+        "ADMIN",
+        "EDITOR",
+        "COLLABORATOR",
+        "CLIENT",
+        "EXTERNAL",
+        "QA",
+        "OPTIMIZER",
+      ],
+      trim: true,
+      uppercase: true,
+    },
+    description: {
+      type: String,
+      trim: true,
+    },
+    organizationId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
+      default: null,
+    },
+    isActive: {
+      type: Boolean,
+      default: true,
+    },
+    defaultPermissions: {
+      abTestingDefault: { type: Boolean, default: true },
+      abTesting: { type: Boolean, default: false },
+      preCalculations: { type: Boolean, default: true },
+      reporting: { type: Boolean, default: true },
+      insights: { type: Boolean, default: true },
+      documentsAndLinks: { type: Boolean, default: true },
+      cvrReports: { type: Boolean, default: true },
+      manageExperiments: { type: Boolean, default: true },
+      dashboard: { type: Boolean, default: true },
+    },
   },
-  description: {
-    type: String,
-    trim: true,
-  },
-  organizationId: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: "organization",
-    default: null,
-  },
-  isActive: {
-    type: Boolean,
-    default: true,
-  },
-  defaultPermissions: {
-    abTestingDefault: { type: Boolean, default: true },
-    abTesting: { type: Boolean, default: false },
-    preCalculations: { type: Boolean, default: true },
-    reporting: { type: Boolean, default: true },
-    insights: { type: Boolean, default: true },
-    documentsAndLinks: { type: Boolean, default: true },
-    cvrReports: { type: Boolean, default: true },
-    manageExperiments: { type: Boolean, default: true },
-    dashboard: { type: Boolean, default: true },
+  {
+    timestamps: true,
   }
-}, {
-  timestamps: true
-});
+);
 // IF role is CLIENT then defaultPermissions should be false for all modules except reporting, insights, documentsAndLinks, cvrReports, dashboard
-RoleSchema.pre('save', function(next) {
+RoleSchema.pre("save", function (next) {
   const allTrue = {
     abTestingDefault: true,
     abTesting: true,
@@ -69,7 +81,7 @@ RoleSchema.pre('save', function(next) {
     cvrReports: true,
     dashboard: true,
   };
-  if (this.name === 'CLIENT') {
+  if (this.name === "CLIENT") {
     this.defaultPermissions = {
       ...allTrue,
       abTesting: false, // only this one is false
@@ -88,9 +100,9 @@ RoleSchema.index({ name: 1, isActive: 1 });
 RoleSchema.index({ organizationId: 1, name: 1 });
 
 // Add text index for search
-RoleSchema.index({ 
-  name: 'text',
-  description: 'text'
+RoleSchema.index({
+  name: "text",
+  description: "text",
 });
 
 const Role = mongoose.models.role || model<IRole>("role", RoleSchema);

package/src/models/Thread.ts

@@ -0,0 +1,57 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
+
+export interface IThread extends Document {
+  iid: string;
+  organization: mongoose.Schema.Types.ObjectId;
+  user: mongoose.Schema.Types.ObjectId; 
+  name: string;
+}
+
+const ThreadSchema = new Schema<IThread>(
+  {
+    iid: {
+      type: String,
+      trim: true,
+    },
+    name: {
+      type: String,
+      required: true,
+      default: "New Conversation",
+    },
+    organization: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
+      default: null,
+    },
+    user: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "user",
+      default: null,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+ThreadSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.thread.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+  next();
+});
+
+ThreadSchema.index({ iid: 1 }, { unique: true });
+
+const Thread = mongoose.models.thread || model<IThread>("thread", ThreadSchema);
+
+export default Thread;

package/src/models/ThreadMessage.ts

@@ -0,0 +1,67 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
+
+export interface IThreadMessage extends Document {
+  iid: string;
+  organization: mongoose.Schema.Types.ObjectId;
+  thread: mongoose.Schema.Types.ObjectId;
+  status: string;
+  user: mongoose.Schema.Types.ObjectId; 
+  message: mongoose.Schema.Types.Mixed;
+}
+
+const ThreadMessageSchema = new Schema<IThreadMessage>(
+  {
+    iid: {
+      type: String,
+      trim: true,
+    },
+    organization: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "organization",
+      default: null,
+    },
+    thread: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "thread",
+      default: null,
+    },
+    user: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "user",
+      default: null,
+    },
+    status: {
+      type: String,
+      enum: ["pending", "success", "failed"],
+      default: "pending",
+    },
+    message: {
+      type: mongoose.Schema.Types.Mixed,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+ThreadMessageSchema.pre('save', async function(next) {
+  if (!this.iid) {
+    let unique = false;
+    while (!unique) {
+      const id = generateRandomIID();
+      const existing = await mongoose.models.threadmessage.findOne({ iid: id });
+      if (!existing) {
+        this.iid = id;
+        unique = true;
+      }
+    }
+  }
+  next();
+});
+
+ThreadMessageSchema.index({ iid: 1 }, { unique: true });
+
+const ThreadMessage = mongoose.models.threadmessage || model<IThreadMessage>("threadmessage", ThreadMessageSchema);
+
+export default ThreadMessage;

package/src/models/User.ts

@@ -1,70 +1,48 @@
 import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID, RolesConstants } from "../constant";
 
 export interface IUser extends Document {
+  iid: string;
   name: string;
   email: string;
+  image: string;
+  client: mongoose.Schema.Types.ObjectId[];
   password: string;
   token: string;
-  role?: mongoose.Schema.Types.ObjectId[];
   deactivated: boolean;
-  client?: mongoose.Schema.Types.ObjectId[];
   twoFactor: boolean;
-  createdAt: Date;
-  updatedAt: Date;
+  emailVerified: boolean;
   resetLink: string;
-  organizationId?: mongoose.Schema.Types.ObjectId;
   bigqueryToken: string;
   expirybqToken: string;
   refreshToken: string;
+  createdAt: Date;
+  updatedAt: Date;
+  isSSOUser: boolean;
+  role: mongoose.Schema.Types.ObjectId[] | null;
 }
 
 const UserSchema = new Schema<IUser>(
   {
+    iid: { type: String, unique: true, default: () => generateRandomIID() },
     name: String,
-    email: {
-      type: String,
-      unique: true,
-      required: true,
-    },
-    password: {
-      type: String,
-      required: true,
-    },
+    email: { type: String, unique: true, required: true },
+    client: { type: [mongoose.Schema.Types.ObjectId], ref: "client", default: null },
+    password: { type: String, required: true },
+    image: String,
     token: String,
-    role: {
-      type: [mongoose.Schema.Types.ObjectId],
-      ref: "role",
-    },
-    deactivated: {
-      type: Boolean,
-      default: false,
-    },
-    client: {
-      type: [mongoose.Schema.Types.ObjectId],
-      ref: "client",
-      default: null,
-    },
-    twoFactor: {
-      type: Boolean,
-      default: false,
-    },
-    organizationId: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "organization",
-      default: null,
-    },
+    deactivated: { type: Boolean, default: false },
+    twoFactor: { type: Boolean, default: false },
+    emailVerified: { type: Boolean, default: false },
+    resetLink: String,
     bigqueryToken: String,
     expirybqToken: String,
     refreshToken: String,
+    isSSOUser: { type: Boolean, default: false },
+    role: { type: [mongoose.Schema.Types.ObjectId], ref: "role", default: null },
   },
-  {
-    timestamps: true,
-  }
+  { timestamps: true }
 );
 
-// Add compound indexes for common query patterns
-UserSchema.index({ organizationId: 1, role: 1 });
-UserSchema.index({ organizationId: 1, client: 1 });
-
 const User = mongoose.models.user || model<IUser>("user", UserSchema);
 export default User;