codebase-models 1.0.0

package/dist/src/models/User.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import mongoose, { Document } from "mongoose";
+export interface IUser extends Document {
+    name: string;
+    email: string;
+    password: string;
+    token: string;
+    role?: mongoose.Schema.Types.ObjectId[];
+    deactivated: boolean;
+    client?: mongoose.Schema.Types.ObjectId[];
+    twoFactor: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    resetLink: string;
+}
+declare const User: mongoose.Model<IUser, {}, {}, {}, mongoose.Document<unknown, {}, IUser> & IUser & {
+    _id: mongoose.Types.ObjectId;
+}, any>;
+export default User;

package/dist/src/models/User.js

@@ -0,0 +1,70 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importStar(require("mongoose"));
+const UserSchema = new mongoose_1.Schema({
+    name: String,
+    email: {
+        type: String,
+        unique: true,
+        required: true,
+    },
+    password: {
+        type: String,
+        required: true,
+    },
+    token: String,
+    role: {
+        type: [mongoose_1.default.Schema.Types.ObjectId],
+        ref: "role",
+    },
+    deactivated: {
+        type: Boolean,
+        default: false,
+    },
+    client: {
+        type: [mongoose_1.default.Schema.Types.ObjectId],
+        ref: "client",
+        default: null,
+    },
+    twoFactor: {
+        type: Boolean,
+        default: false,
+    },
+    createdAt: {
+        type: Date,
+        default: new Date(),
+    },
+    updatedAt: {
+        type: Date,
+        default: new Date(),
+    },
+    resetLink: {
+        type: String,
+        default: null,
+    },
+});
+const User = (0, mongoose_1.model)("user", UserSchema);
+exports.default = User;

package/global.d.ts

@@ -0,0 +1 @@
+declare module "mongoose-slug-updater";

package/index.ts

@@ -0,0 +1,124 @@
+import mongoose from "mongoose";
+
+import Client from "./src/models/Client";
+import ClientReportsTemp from "./src/models/ClientReportsTemp";
+import QueryLog from "./src/models/QueryLog";
+import Report from "./src/models/Report";
+import Test from "./src/models/Test";
+import TestSequentialValue from "./src/models/TestSequentialValue";
+import User from "./src/models/User";
+import Announcement from "./src/models/Announcement";
+import ClientAdditionalRevenue from "./src/models/ClientAdditionalRevenue";
+import ClientLearning from "./src/models/ClientLearning";
+import ClientLinks from "./src/models/ClientLinks";
+import ClientNextStep from "./src/models/ClientNextSteps";
+import ClientNote from "./src/models/ClientNote";
+import ClientRetention from "./src/models/ClientRetention";
+import ClientStrategy from "./src/models/ClientStrategy";
+import ClientSurvey from "./src/models/ClientSurvay";
+import CVRReport from "./src/models/CVRReport";
+import Faq from "./src/models/Faqs";
+import Feedback from "./src/models/Feedback";
+import Goal from "./src/models/Goal";
+import Hypothesis from "./src/models/Hypothesis";
+import HypothesisSheet from "./src/models/HypothesisSheet";
+import LandingPages from "./src/models/LandingPages";
+import NewIdeas from "./src/models/NewIdeas";
+import Notification from "./src/models/Notification";
+import PageElement from "./src/models/PageElement";
+import PageTestType from "./src/models/PageTestType";
+import Portfolio from "./src/models/Portfolio";
+import ReadNotification from "./src/models/ReadNotification";
+import Role from "./src/models/Role";
+import SavedSegment from "./src/models/SavedSegment";
+import Segment from "./src/models/Segment";
+import SegmentCombination from "./src/models/SegmentCombination";
+import Snippet from "./src/models/Snippet";
+import StageInCustomerJourney from "./src/models/StageInCustomerJourney";
+import Tag from "./src/models/Tag";
+import Temp from "./src/models/Temp";
+import Tier from "./src/models/Tier";
+import Trigger from "./src/models/Trigger";
+
+async function seedRoles() {
+  const checkRoles = await Role.countDocuments();
+  if (checkRoles < 5) {
+    Promise.all(
+      ["USER", "ADMIN", "EDITOR", "OPTIMIZER", "CLIENT"].map((name) => {
+        Role.bulkWrite([
+          {
+            updateOne: {
+              filter: {
+                name: name,
+              },
+              update: {
+                $set: {
+                  name,
+                },
+              },
+              upsert: true,
+            },
+          },
+        ]);
+      })
+    );
+  }
+}
+
+export async function connect(
+  uri: string,
+  options?: mongoose.ConnectOptions | undefined
+): Promise<typeof mongoose> {
+  if (uri) {
+    console.log("Connecting to the database on URI: ", uri);
+    const mongooseConnection = await mongoose.connect(uri, options);
+    if (mongooseConnection.connection.readyState === 1) {
+      await seedRoles();
+      console.log("Roles seeded successfully");
+    }
+    return mongooseConnection;
+  }
+  throw new Error("URI is required to connect to the database");
+}
+
+export {
+  Client,
+  ClientReportsTemp,
+  QueryLog,
+  Report,
+  Test,
+  TestSequentialValue,
+  User,
+  Announcement,
+  ClientAdditionalRevenue,
+  ClientLearning,
+  ClientLinks,
+  ClientNextStep,
+  ClientNote,
+  ClientRetention,
+  ClientStrategy,
+  ClientSurvey,
+  CVRReport,
+  Faq,
+  Feedback,
+  Goal,
+  Hypothesis,
+  HypothesisSheet,
+  LandingPages,
+  NewIdeas,
+  Notification,
+  PageElement,
+  PageTestType,
+  Portfolio,
+  ReadNotification,
+  Role,
+  SavedSegment,
+  Segment,
+  SegmentCombination,
+  Snippet,
+  StageInCustomerJourney,
+  Tag,
+  Temp,
+  Tier,
+  Trigger,
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "codebase-models",
+  "version": "1.0.0",
+  "description": "Common models for codebase",
+  "main": "dist/index.js",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc -d --outDir dist",
+    "prepublish": "npm run build"
+  },
+  "keywords": [],
+  "author": "Ajay Bhatia <prof.ajaybhatia@gmail.com>",
+  "license": "ISC",
+  "dependencies": {
+    "mongoose": "^8.2.3",
+    "mongoose-slug-updater": "^3.3.0"
+  },
+  "devDependencies": {
+    "@types/mongoose": "^5.11.97",
+    "@types/node": "^20.11.30",
+    "typescript": "^5.4.3"
+  },
+  "types": "./dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AcceleratedAgency/codebase-models.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AcceleratedAgency/codebase-models/issues"
+  },
+  "homepage": "https://github.com/AcceleratedAgency/codebase-models#readme"
+}

package/src/constant.ts

@@ -0,0 +1,14 @@
+const HypothesisSheetConstants = {
+  NO: 0,
+  YES: 1,
+  YES_2: 2,
+  //
+  MORE: 0,
+  DAYS_2: 1,
+  //
+  LOW: 0,
+  MEDIUM: 1,
+  GOOD: 2,
+};
+
+export default HypothesisSheetConstants;

package/src/models/Announcement.ts

@@ -0,0 +1,49 @@
+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;
+}
+
+const AnnouncementSchema = new Schema<IAnnouncement>(
+  {
+    title: {
+      type: String,
+      required: true,
+    },
+    description: {
+      type: String,
+      required: false,
+    },
+    active: {
+      type: Boolean,
+      default: true,
+    },
+    forRoles: {
+      type: [mongoose.Schema.Types.ObjectId],
+      required: true,
+      ref: "role",
+    },
+    forUsers: {
+      type: [mongoose.Schema.Types.ObjectId],
+      required: false,
+      ref: "user",
+    },
+    readBy: {
+      type: [mongoose.Schema.Types.ObjectId],
+      required: false,
+      ref: "user",
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const Announcement = model<IAnnouncement>("announcement", AnnouncementSchema);
+
+export default Announcement;

package/src/models/CVRReport.ts

@@ -0,0 +1,25 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface ICVRReport extends Document {
+  reportLink?: string;
+  client?: mongoose.Schema.Types.ObjectId;
+}
+
+const CVRReportSchema = new Schema<ICVRReport>(
+  {
+    reportLink: {
+      type: String,
+      default: null,
+    },
+    client: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "client",
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const CVRReport = model<ICVRReport>("cvrreport", CVRReportSchema);
+export default CVRReport;

package/src/models/Client.ts

@@ -0,0 +1,100 @@
+import mongoose, { Schema, Document, model } from "mongoose";
+import slug from "mongoose-slug-updater";
+
+mongoose.plugin(slug);
+
+export interface IProperty extends Document {
+  propertyname: string;
+  viewId: string;
+  platform?: string;
+}
+
+const PropertySchema: Schema = new Schema<IProperty>({
+  propertyname: { type: String, required: true },
+  viewId: { type: String, required: true },
+  platform: { type: String, required: false, default: "UA" },
+});
+
+export interface IClient extends Document {
+  organisationId?: string;
+  name: string;
+  slug?: string;
+  viewId?: string;
+  portfolioClient?: boolean;
+  gaproperties?: IProperty[];
+  tier?: mongoose.Schema.Types.ObjectId;
+  active: boolean;
+  currency?: string;
+  logo?: string;
+  createdBy?: mongoose.Schema.Types.ObjectId;
+  onboardDate?: Date;
+  bqClientId?: string;
+  defaultDataSet?: string;
+  NDAStatus?: boolean;
+}
+
+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,
+    },
+    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,
+    },
+  },
+  { timestamps: true }
+);
+
+ClientSchema.index({ active: 1 });
+
+const Client = model<IClient>("client", ClientSchema);
+
+export default Client;

package/src/models/ClientAdditionalRevenue.ts

@@ -0,0 +1,67 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IClientAdditionalRevenue extends Document {
+  organisationId?: string;
+  client?: mongoose.Schema.Types.ObjectId;
+  additionalRevenueForTests: IAdditionalRevenue;
+  createdBy?: mongoose.Schema.Types.ObjectId;
+}
+
+export interface IAdditionalRevenue extends Document {
+  segmentName: string;
+  lastDate?: Date;
+  test?: mongoose.Schema.Types.ObjectId;
+  data_to_project?: mongoose.Schema.Types.Mixed;
+}
+
+const AdditionalRevenueSchema = new Schema<IAdditionalRevenue>({
+  // add_rev: {
+  //   type: Number,
+  // },
+  segmentName: {
+    type: String,
+    required: true,
+  },
+  lastDate: {
+    type: Date,
+  },
+  test: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "test",
+  },
+  data_to_project: {
+    type: mongoose.Schema.Types.Mixed,
+  },
+});
+
+const ClientAdditionalRevenueSchema = new Schema<IClientAdditionalRevenue>(
+  {
+    organisationId: {
+      type: String,
+      default: null,
+    },
+    client: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "client",
+      required: true,
+    },
+    additionalRevenueForTests: [AdditionalRevenueSchema],
+    createdBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "user",
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+ClientAdditionalRevenueSchema.index({
+  client: 1,
+});
+
+const ClientAdditionalRevenue = model<IClientAdditionalRevenue>(
+  "clientadditionalrevenue",
+  ClientAdditionalRevenueSchema
+);
+export default ClientAdditionalRevenue;

package/src/models/ClientLearning.ts

@@ -0,0 +1,48 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IClientLearning extends Document {
+  name: string;
+  organisationId?: string;
+  client?: mongoose.Schema.Types.ObjectId;
+  viewId?: string;
+  createdBy?: mongoose.Schema.Types.ObjectId;
+}
+
+const ClientLearningSchema = new Schema<IClientLearning>(
+  {
+    name: {
+      type: String,
+      required: true,
+    },
+    organisationId: {
+      type: String,
+      default: null,
+    },
+    client: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "client",
+    },
+    viewId: {
+      type: String,
+    },
+    createdBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "user",
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+ClientLearningSchema.index({
+  client: 1,
+  viewId: 1,
+});
+
+const ClientLearning = model<IClientLearning>(
+  "clientlearning",
+  ClientLearningSchema
+);
+
+export default ClientLearning;

package/src/models/ClientLinks.ts

@@ -0,0 +1,58 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IClientLinks extends Document {
+  organisationId?: string;
+  title: string;
+  description?: string;
+  link?: string;
+  client?: mongoose.Schema.Types.ObjectId;
+  private?: boolean;
+  viewId?: string;
+  createdBy?: mongoose.Schema.Types.ObjectId;
+}
+
+const ClientLinksSchema = new Schema<IClientLinks>(
+  {
+    organisationId: {
+      type: String,
+      default: null,
+    },
+    title: {
+      type: String,
+      required: true,
+    },
+    description: {
+      type: String,
+    },
+    link: {
+      type: String,
+      required: true,
+    },
+    client: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "client",
+    },
+    private: {
+      type: Boolean,
+      default: false,
+    },
+    viewId: {
+      type: String,
+    },
+    createdBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "user",
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+ClientLinksSchema.index({
+  client: 1,
+  viewId: 1,
+});
+
+const ClientLinks = model<IClientLinks>("clientlink", ClientLinksSchema);
+export default ClientLinks;

package/src/models/ClientNextSteps.ts

@@ -0,0 +1,47 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IClientNextSteps extends Document {
+  name: string;
+  organisationId?: string;
+  client?: mongoose.Schema.Types.ObjectId;
+  viewId?: string;
+  createdBy?: mongoose.Schema.Types.ObjectId;
+}
+
+const ClientNextStepsSchema = new Schema<IClientNextSteps>(
+  {
+    name: {
+      type: String,
+      required: true,
+    },
+    organisationId: {
+      type: String,
+      default: null,
+    },
+    client: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "client",
+    },
+    viewId: {
+      type: String,
+    },
+    createdBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "user",
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+ClientNextStepsSchema.index({
+  client: 1,
+  viewId: 1,
+});
+
+const ClientNextStep = model<IClientNextSteps>(
+  "clientnextstep",
+  ClientNextStepsSchema
+);
+export default ClientNextStep;