codebase-models 2.1.24 → 3.0.1

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

@@ -100,7 +100,7 @@ ClientRetentionSchema.index(
 ClientRetentionSchema.index({ "retentions.retainerValue": -1 });
 
 const ClientRetention = mongoose.models.clientretention || model<IClientRetention>(
-  "ClientRetention",
+  "clientretention",
   ClientRetentionSchema
 );
 

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/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;

package/src/models/UserIdentity.ts

@@ -0,0 +1,26 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID } from "../constant";
+
+export interface IUserIdentity extends Document {
+    iid: string;
+    user: mongoose.Schema.Types.ObjectId;
+    provider: "google" | "microsoft" | "github" | "facebook" | "apple";
+    providerUserId: string; 
+    email: string;
+    metadata?: any;
+}
+
+const UserIdentitySchema = new Schema<IUserIdentity>(
+  {
+    iid: { type: String, unique: true, default: () => generateRandomIID() },
+    user: { type: mongoose.Schema.Types.ObjectId, ref: "user", required: true },
+    email: { type: String, unique: true, required: true },
+    providerUserId: { type: String, required: true },
+    provider: { type: String, enum: ["google", "microsoft", "github", "facebook", "apple"], required: true },
+    metadata: { type: mongoose.Schema.Types.Mixed, default: {} },
+  },
+  { timestamps: true }
+);
+
+const UserIdentity = mongoose.models.useridentity || model<IUserIdentity>("useridentity", UserIdentitySchema);
+export default UserIdentity;

package/src/models/UserOrganization.ts

@@ -0,0 +1,23 @@
+import mongoose, { model, Schema } from "mongoose";
+import { generateRandomIID } from "../constant";
+
+export interface IUserOrganization extends Document {
+    iid: string;
+    user: mongoose.Schema.Types.ObjectId;
+    organization: mongoose.Schema.Types.ObjectId;
+    role: string;
+}
+  
+  const UserOrganizationSchema = new Schema<IUserOrganization>(
+    {
+      iid: { type: String, unique: true, default: () => generateRandomIID() },
+      user: { type: mongoose.Schema.Types.ObjectId, ref: "user", required: true },
+      organization: { type: mongoose.Schema.Types.ObjectId, ref: "organization", required: true },
+      role: { type: String, enum: ["owner", "admin", "member"], default: "member" }
+    },
+    { timestamps: true }
+  );
+  
+  UserOrganizationSchema.index({ user: 1, organization: 1 }, { unique: true });
+  const UserOrganization = mongoose.models.userorganization || model<IUserOrganization>("userorganization", UserOrganizationSchema);
+  export default UserOrganization;

package/src/models/UserPermission.ts

@@ -1,24 +1,23 @@
 import mongoose, { Document, Schema, model } from "mongoose";
+import { generateRandomIID, PackageFeaturesConstants } from "../constant";
 
 export interface IUserPermission extends Document {
+  iid: string;
   userId: mongoose.Schema.Types.ObjectId;
   clientId: mongoose.Schema.Types.ObjectId;
-  permissions: {
-    dashboard: boolean;
-    reporting: boolean;
-    insights: boolean;
-    documentsAndLinks: boolean;
-    cvrReports: boolean;
-    abTesting: boolean;
-    abTestingDefault: boolean;
-    manageExperiments: boolean;
-    preCalculations: boolean;
-  }
+  organizationId: mongoose.Schema.Types.ObjectId;
+  role: string;
+  permissions: mongoose.Schema.Types.Mixed;
   createdAt: Date;
   updatedAt: Date;
 }
 
 const UserPermissionSchema = new Schema<IUserPermission>({
+  iid: {
+    type: String,
+    unique: true,
+    default: () => generateRandomIID()
+  },
   userId: {
     type: mongoose.Schema.Types.ObjectId,
     ref: "user",
@@ -29,17 +28,28 @@ const UserPermissionSchema = new Schema<IUserPermission>({
     ref: "client",
     required: true,
   },
-  permissions: {
-    abTestingDefault: { type: Boolean, default: true },
-    abTesting: { type: Boolean, default: false },
-    preCalculations: { type: Boolean, default: false },
-    reporting: { type: Boolean, default: true },
-    insights: { type: Boolean, default: true },
-    documentsAndLinks: { type: Boolean, default: true },
-    cvrReports: { type: Boolean, default: true },
-    manageExperiments: { type: Boolean, default: false },
-    dashboard: { type: Boolean, default: true },
+  role: {
+    type: String,
+    enum: ["member", "admin", "owner"],
+    default: "member",
+  },
+  organizationId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "organization",
+    required: true,
   },
+  permissions: { type: mongoose.Schema.Types.Mixed, required: true, default: PackageFeaturesConstants },
+  // permissions: {
+  //   abTestingDefault: { type: Boolean, default: true },
+  //   abTesting: { type: Boolean, default: false },
+  //   preCalculations: { type: Boolean, default: false },
+  //   reporting: { type: Boolean, default: true },
+  //   insights: { type: Boolean, default: true },
+  //   documentsAndLinks: { type: Boolean, default: true },
+  //   cvrReports: { type: Boolean, default: true },
+  //   manageExperiments: { type: Boolean, default: false },
+  //   dashboard: { type: Boolean, default: true },
+  // },
 },
   {
     timestamps: true,

package/src/models/QueryLog.ts

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

package/src/models/Segment.ts

@@ -1,50 +0,0 @@
-import mongoose, { Document, Schema, model } from "mongoose";
-
-export interface ISegment extends Document {
-  name?: string;
-  key?: string;
-  values?: string;
-  segmentType?: string;
-  client?: mongoose.Schema.Types.ObjectId;
-  published?: boolean;
-  organizationId?: mongoose.Schema.Types.ObjectId;
-}
-
-const SegmentSchema = new Schema<ISegment>(
-  {
-    organizationId: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "organization",
-      default: null,
-    },
-    name: {
-      type: String,
-    },
-    key: {
-      type: String,
-    },
-    values: {
-      type: String,
-    },
-    segmentType: {
-      type: String,
-      default: "general",
-    },
-    client: {
-      type: [mongoose.Schema.Types.ObjectId],
-      ref: "client",
-      default: null,
-    },
-    published: {
-      type: Boolean,
-      default: true,
-    },
-  },
-  {
-    timestamps: true,
-  }
-);
-
-const Segment = mongoose.models.segment || model<ISegment>("segment", SegmentSchema);
-
-export default Segment;