codebase-models 1.0.0

package/src/models/Notification.ts

@@ -0,0 +1,47 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface INotification extends Document {
+  title?: string;
+  body?: string;
+  users?: mongoose.Schema.Types.ObjectId;
+  createdBy?: mongoose.Schema.Types.ObjectId;
+  archive?: boolean;
+  module?: string;
+  moduleData?: string;
+}
+
+const NotificationSchema = new Schema<INotification>(
+  {
+    title: {
+      type: String,
+    },
+    body: {
+      type: String,
+    },
+    users: {
+      type: [Schema.Types.ObjectId],
+      ref: "user",
+    },
+    createdBy: {
+      type: Schema.Types.ObjectId,
+      ref: "user",
+    },
+    archive: {
+      type: Boolean,
+      default: false,
+    },
+    module: {
+      type: String,
+    },
+    moduleData: {
+      type: String,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const Notification = model<INotification>("notification", NotificationSchema);
+
+export default Notification;

package/src/models/PageElement.ts

@@ -0,0 +1,30 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IPageElement extends Document {
+  name: string;
+  slug?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+const PageElementSchema = new Schema<IPageElement>({
+  name: {
+    type: String,
+    required: true,
+  },
+  slug: {
+    type: String,
+  },
+  createdAt: {
+    type: Date,
+    default: new Date(),
+  },
+  updatedAt: {
+    type: Date,
+    default: new Date(),
+  },
+});
+
+const PageElement = model<IPageElement>("pageelement", PageElementSchema);
+
+export default PageElement;

package/src/models/PageTestType.ts

@@ -0,0 +1,32 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IPageTestType extends Document {
+  name: string;
+  details?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+const PageTestTypeSchema = new Schema<IPageTestType>({
+  name: {
+    type: String,
+    required: true,
+    unique: true,
+  },
+  details: {
+    type: String,
+    default: "",
+  },
+  createdAt: {
+    type: Date,
+    default: new Date(),
+  },
+  updatedAt: {
+    type: Date,
+    default: new Date(),
+  },
+});
+
+const PageTestType = model<IPageTestType>("pagetesttype", PageTestTypeSchema);
+
+export default PageTestType;

package/src/models/Portfolio.ts

@@ -0,0 +1,26 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IPortfolio extends Document {
+  portfoliokey: mongoose.Schema.Types.Mixed;
+  portfolioData?: mongoose.Schema.Types.Mixed;
+}
+
+const PortfolioSchema = new Schema<IPortfolio>(
+  {
+    portfoliokey: {
+      type: mongoose.Schema.Types.Mixed,
+      required: true,
+    },
+    portfolioData: {
+      type: mongoose.Schema.Types.Mixed,
+      default: null,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const Portfolio = model<IPortfolio>("portfolio", PortfolioSchema);
+
+export default Portfolio;

package/src/models/QueryLog.ts

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

package/src/models/ReadNotification.ts

@@ -0,0 +1,34 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IReadNotification extends Document {
+  notification?: mongoose.Schema.Types.ObjectId;
+  user?: mongoose.Schema.Types.ObjectId;
+  read?: boolean;
+}
+
+const ReadNotificationSchema = new Schema<IReadNotification>(
+  {
+    notification: {
+      type: Schema.Types.ObjectId,
+      ref: "notification",
+    },
+    user: {
+      type: Schema.Types.ObjectId,
+      ref: "user",
+    },
+    read: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const ReadNotification = model<IReadNotification>(
+  "readnotification",
+  ReadNotificationSchema
+);
+
+export default ReadNotification;

package/src/models/Report.ts

@@ -0,0 +1,87 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IReports extends Document {
+  name: string;
+  segmentName?: string;
+  reportLink?: string;
+  conclusion?: string;
+  variant?: string;
+  client?: mongoose.Schema.Types.ObjectId;
+  viewId?: string;
+  test?: mongoose.Schema.Types.ObjectId;
+  gaTestId?: string;
+  reportDetails?: mongoose.Schema.Types.Mixed;
+  learnings?: mongoose.Schema.Types.Mixed;
+  from?: Date;
+  to?: Date;
+  createdBy?: mongoose.Schema.Types.ObjectId;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+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",
+  },
+  createdAt: {
+    type: Date,
+    default: new Date(),
+  },
+  updatedAt: {
+    type: Date,
+    default: new Date(),
+  },
+});
+
+ReportsSchema.index({
+  client: 1,
+  conclusion: 1,
+});
+
+const Report = model<IReports>("report", ReportsSchema);
+
+export default Report;

package/src/models/Role.ts

@@ -0,0 +1,28 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IRole extends Document {
+  name: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+const RoleSchema = new Schema<IRole>({
+  name: {
+    type: String,
+    unique: true,
+    required: true,
+    enum: ["USER", "ADMIN", "EDITOR", "COLLABORATOR", "CLIENT"],
+  },
+  createdAt: {
+    type: Date,
+    default: new Date(),
+  },
+  updatedAt: {
+    type: Date,
+    default: new Date(),
+  },
+});
+
+const Role = model<IRole>("role", RoleSchema);
+
+export default Role;

package/src/models/SavedSegment.ts

@@ -0,0 +1,31 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface ISavedSegment extends Document {
+  test?: mongoose.Schema.Types.ObjectId;
+  segment?: mongoose.Schema.Types.ObjectId;
+  segmentFilters?: mongoose.Schema.Types.Mixed;
+}
+
+const SavedSegmentSchema = new Schema<ISavedSegment>(
+  {
+    test: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "test",
+    },
+    segment: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "segmentcombination",
+    },
+    segmentFilters: {
+      type: mongoose.Schema.Types.Mixed,
+      default: null,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const SavedSegment = model<ISavedSegment>("savedsegment", SavedSegmentSchema);
+
+export default SavedSegment;

package/src/models/Segment.ts

@@ -0,0 +1,44 @@
+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;
+}
+
+const SegmentSchema = new Schema<ISegment>(
+  {
+    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 = model<ISegment>("segment", SegmentSchema);
+
+export default Segment;

package/src/models/SegmentCombination.ts

@@ -0,0 +1,62 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface ISegmentCombination extends Document {
+  name?: string;
+  combination?: [];
+  gagroup?: string;
+  secondaryFilters?: [];
+  segmentType?: string;
+  client?: mongoose.Schema.Types.ObjectId[];
+  published?: boolean;
+  order?: Number;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+const SegmentSchema = new Schema<ISegmentCombination>({
+  name: {
+    type: String,
+  },
+  combination: {
+    type: [],
+  },
+  gagroup: {
+    typr: String,
+  },
+  secondaryFilters: {
+    type: [],
+    default: null,
+  },
+  segmentType: {
+    type: String,
+    default: "general",
+  },
+  client: {
+    type: [mongoose.Schema.Types.ObjectId],
+    ref: "client",
+    default: null,
+  },
+  published: {
+    type: Boolean,
+    default: true,
+  },
+  order: {
+    type: Number,
+    default: 1,
+  },
+  createdAt: {
+    type: Date,
+    default: new Date(),
+  },
+  updatedAt: {
+    type: Date,
+    default: new Date(),
+  },
+});
+
+const SegmentCombination = model<ISegmentCombination>(
+  "segmentcombination",
+  SegmentSchema
+);
+
+export default SegmentCombination;

package/src/models/Snippet.ts

@@ -0,0 +1,78 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface ISnippet extends Document {
+  organisationId?: string;
+  name?: string;
+  pageelement?: mongoose.Schema.Types.ObjectId[];
+  client?: mongoose.Schema.Types.ObjectId;
+  details?: string;
+  figmaUrl?: string;
+  tags?: mongoose.Schema.Types.ObjectId[];
+  htmlcode?: string;
+  csscode?: string;
+  jscode?: string;
+  test?: mongoose.Schema.Types.ObjectId;
+  status?: string;
+}
+
+const SnippetSchema = new Schema<ISnippet>(
+  {
+    organisationId: {
+      type: String,
+      default: null,
+    },
+    name: {
+      type: String,
+      required: true,
+      unique: true,
+    },
+    pageelement: {
+      type: [mongoose.Schema.Types.ObjectId],
+      ref: "pageelement",
+      default: [],
+    },
+    client: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "client",
+    },
+    details: {
+      type: String,
+      default: "",
+    },
+    figmaUrl: {
+      type: String,
+    },
+    tags: {
+      type: [mongoose.Schema.Types.ObjectId],
+      ref: "tag",
+      default: [],
+    },
+    htmlcode: {
+      type: String,
+      default: "",
+    },
+    csscode: {
+      type: String,
+    },
+    jscode: {
+      type: String,
+      default: "",
+    },
+    test: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "test",
+    },
+    status: {
+      type: String,
+      default: "live",
+      enum: ["live", "draft"],
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const Snippet = model<ISnippet>("snippet", SnippetSchema);
+
+export default Snippet;

package/src/models/StageInCustomerJourney.ts

@@ -0,0 +1,35 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IStageInCustomerJourney extends Document {
+  name?: string;
+  stages?: string;
+  slug?: string;
+  organizationId?: string;
+}
+
+const StateInCustomerJourney = new Schema<IStageInCustomerJourney>(
+  {
+    name: {
+      type: String,
+    },
+    stages: {
+      type: String,
+    },
+    slug: {
+      type: String,
+    },
+    organizationId: {
+      type: String,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const StageInCustomerJourney = model<IStageInCustomerJourney>(
+  "stageincustomerjourney",
+  StateInCustomerJourney
+);
+
+export default StageInCustomerJourney;

package/src/models/Tag.ts

@@ -0,0 +1,27 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface ITag extends Document {
+  name: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+const TagSchema = new Schema<ITag>({
+  name: {
+    type: String,
+    unique: true,
+    required: true,
+  },
+  createdAt: {
+    type: Date,
+    default: new Date(),
+  },
+  updatedAt: {
+    type: Date,
+    default: new Date(),
+  },
+});
+
+const Tag = model<ITag>("tag", TagSchema);
+
+export default Tag;

package/src/models/Temp.ts

@@ -0,0 +1,30 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface ITemp extends Document {
+  secret?: string;
+  userId: string;
+  enabled?: boolean;
+  createdAt?: Date;
+}
+
+const TempSchema = new Schema<ITemp>({
+  secret: {
+    type: String,
+  },
+  userId: {
+    type: String,
+    required: true,
+  },
+  enabled: {
+    type: Boolean,
+    default: false,
+  },
+  createdAt: {
+    type: Date,
+    default: new Date(),
+  },
+});
+
+const Temp = model<ITemp>("temp", TempSchema);
+
+export default Temp;