codebase-models 1.0.0 → 1.0.2

package/dist/src/models/Test.js

@@ -24,15 +24,102 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const mongoose_1 = __importStar(require("mongoose"));
-const TestSchema = new mongoose_1.Schema({
+const VariationsSchema = new mongoose_1.Schema({
     name: {
         type: String,
-        required: true,
     },
+    css_code: {
+        type: String,
+    },
+    baseline: {
+        type: Boolean,
+    },
+    traffic_allocation: {
+        type: Number,
+    },
+    metadata_1: {
+        type: mongoose_1.default.Schema.Types.Mixed,
+    },
+    metadata_2: {
+        type: mongoose_1.default.Schema.Types.Mixed,
+    },
+    metadata_3: {
+        type: mongoose_1.default.Schema.Types.Mixed,
+    },
+    jscode: {
+        type: String,
+    },
+    reset_js: {
+        type: String,
+    },
+    csscode: {
+        type: String,
+    },
+    changesets: {
+        type: String,
+        default: "[]",
+    },
+});
+const TestSchema = new mongoose_1.Schema({
     organisationId: {
         type: String,
         default: null,
     },
+    status: {
+        type: String,
+        default: "draft",
+        enum: ["live", "draft", "ended", "paused", "preview"], // running is live
+    },
+    name: {
+        type: String,
+        required: true,
+    },
+    traffic_allocation: {
+        type: Number,
+        default: 100,
+    },
+    audiences_match_type: {
+        type: String,
+        default: "all",
+    },
+    metadata_1: {
+        type: mongoose_1.default.Schema.Types.Mixed,
+    },
+    metadata_2: {
+        type: mongoose_1.default.Schema.Types.Mixed,
+    },
+    metadata_3: {
+        type: mongoose_1.default.Schema.Types.Mixed,
+    },
+    integrations_run_mode: {
+        type: mongoose_1.default.Schema.Types.Mixed,
+    },
+    jscode: {
+        type: String,
+        default: "",
+    },
+    reset_js: {
+        type: String,
+    },
+    csscode: {
+        type: String,
+    },
+    audiences: {
+        type: [mongoose_1.default.Schema.Types.ObjectId],
+        ref: "audience",
+        default: [],
+    },
+    pages: {
+        type: [mongoose_1.default.Schema.Types.ObjectId],
+        ref: "page",
+        default: [],
+    },
+    variations: [VariationsSchema],
+    environments: {
+        type: [mongoose_1.default.Schema.Types.ObjectId],
+        ref: "environment",
+        default: [],
+    },
     pageelement: {
         type: [mongoose_1.default.Schema.Types.ObjectId],
         ref: "pageelement",
@@ -47,7 +134,7 @@ const TestSchema = new mongoose_1.Schema({
     },
     platform: {
         type: String,
-        default: "UA",
+        default: "BQ",
     },
     viewId: {
         type: String,
@@ -81,10 +168,12 @@ const TestSchema = new mongoose_1.Schema({
         default: null,
     },
     //  Action , Posibility, Hypothesis
+    // Check if we need anymore
     urltargeting: {
         type: [],
         default: [],
     },
+    // Check if we need anymore
     pageaudience: {
         type: String,
         default: null,
@@ -109,13 +198,6 @@ const TestSchema = new mongoose_1.Schema({
         type: String,
         default: "",
     },
-    csscode: {
-        type: String,
-    },
-    jscode: {
-        type: String,
-        default: "",
-    },
     testid: {
         type: String,
         default: null,
@@ -162,11 +244,6 @@ const TestSchema = new mongoose_1.Schema({
         type: Number,
         default: null,
     },
-    status: {
-        type: String,
-        default: "draft",
-        enum: ["live", "draft", "ended"],
-    },
     livedate: {
         type: Date,
         default: null,

package/index.ts

@@ -7,6 +7,7 @@ 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 AppEvent from "./src/models/AppEvent";
 import Announcement from "./src/models/Announcement";
 import ClientAdditionalRevenue from "./src/models/ClientAdditionalRevenue";
 import ClientLearning from "./src/models/ClientLearning";
@@ -17,6 +18,7 @@ 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 Experiments from "./src/models/Experiments";
 import Faq from "./src/models/Faqs";
 import Feedback from "./src/models/Feedback";
 import Goal from "./src/models/Goal";
@@ -25,6 +27,7 @@ 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 Page from "./src/models/Page";
 import PageElement from "./src/models/PageElement";
 import PageTestType from "./src/models/PageTestType";
 import Portfolio from "./src/models/Portfolio";
@@ -39,6 +42,10 @@ import Tag from "./src/models/Tag";
 import Temp from "./src/models/Temp";
 import Tier from "./src/models/Tier";
 import Trigger from "./src/models/Trigger";
+import ClientScript from "./src/models/ClientScript";
+import ClientExperiment from "./src/models/ClientExperiment";
+import Audience from "./src/models/Audience";
+import Environment from "./src/models/Environment";
 
 async function seedRoles() {
   const checkRoles = await Role.countDocuments();
@@ -62,6 +69,7 @@ async function seedRoles() {
         ]);
       })
     );
+    console.log("Roles seeded successfully");
   }
 }
 
@@ -70,13 +78,18 @@ export async function connect(
   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");
+    if (mongoose.connection.readyState === 1) {
+      // Already connected
+      console.log("Already connected to the database");
+      return mongoose;
+    } else {
+      console.log("Connecting to the database on URI: ", uri);
+      const mongooseConnection = await mongoose.connect(uri, options);
+      if (mongooseConnection.connection.readyState === 1) {
+        await seedRoles();
+      }
+      return mongooseConnection;
     }
-    return mongooseConnection;
   }
   throw new Error("URI is required to connect to the database");
 }
@@ -89,6 +102,7 @@ export {
   Test,
   TestSequentialValue,
   User,
+  AppEvent,
   Announcement,
   ClientAdditionalRevenue,
   ClientLearning,
@@ -99,6 +113,7 @@ export {
   ClientStrategy,
   ClientSurvey,
   CVRReport,
+  Experiments,
   Faq,
   Feedback,
   Goal,
@@ -107,6 +122,7 @@ export {
   LandingPages,
   NewIdeas,
   Notification,
+  Page,
   PageElement,
   PageTestType,
   Portfolio,
@@ -121,4 +137,8 @@ export {
   Temp,
   Tier,
   Trigger,
+  ClientScript,
+  ClientExperiment,
+  Audience,
+  Environment,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebase-models",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Common models for codebase",
   "main": "dist/index.js",
   "scripts": {

package/src/models/AppEvent.ts

@@ -0,0 +1,81 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IPerformanceMetrics extends Document {
+  pageLoadTime?: string;
+  serverResponseTime?: string;
+}
+export interface IEngagementMetrics extends Document {
+  bounceRate?: string;
+  sessionDuration?: string;
+  returnVisits?: string;
+}
+export interface IBrowser extends Document {
+  browserName: string;
+  browserVersion?: string;
+}
+
+export interface IOs extends Document {
+  osName: string;
+  osVersion?: string;
+}
+
+export interface IAppEvent extends Document {
+  clientId?: mongoose.Schema.Types.ObjectId;
+  variant?: string;
+  viewId?: boolean;
+  browser?: IBrowser;
+  os?: IOs;
+  eventName?: string;
+  performanceMetrics?: IPerformanceMetrics;
+  engagementMetrics?: IEngagementMetrics;
+}
+
+const PerformanceMetricsSchema: Schema = new Schema<IBrowser>({
+  browserName: mongoose.Schema.Types.String,
+  browserVersion: mongoose.Schema.Types.String,
+});
+
+const EngagementMetricsSchema: Schema = new Schema<IBrowser>({
+  browserName: mongoose.Schema.Types.String,
+  browserVersion: mongoose.Schema.Types.String,
+});
+
+const browserSchema: Schema = new Schema<IBrowser>({
+  browserName: mongoose.Schema.Types.String,
+  browserVersion: mongoose.Schema.Types.String,
+});
+
+const osSchema: Schema = new Schema<IOs>({
+  osName: mongoose.Schema.Types.String,
+  osVersion: mongoose.Schema.Types.String,
+});
+
+const AppEventsSchema = new Schema<IAppEvent>(
+  {
+    clientId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "client",
+      required: true,
+    },
+    variant: {
+      type: mongoose.Schema.Types.String,
+    },
+    viewId: {
+      type: String,
+    },
+    eventName: {
+      type: String,
+    },
+    performanceMetrics: PerformanceMetricsSchema,
+    engagementMetrics: EngagementMetricsSchema,
+    browser: browserSchema,
+    os: osSchema,
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const AppEvent = model<IAppEvent>("appevent", AppEventsSchema);
+
+export default AppEvent;

package/src/models/Audience.ts

@@ -0,0 +1,27 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IAudience extends Document {
+  name: string;
+  rules_js?: string;
+  client: mongoose.Schema.Types.ObjectId;
+}
+
+const AudienceSchema = new Schema<IAudience>({
+  name: {
+    type: String,
+    required: true,
+  },
+  rules_js: {
+    type: String,
+  },
+  client: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "client",
+  }
+}, {
+  timestamps: true,
+});
+
+const Audience = model<IAudience>("audience", AudienceSchema);
+
+export default Audience;

package/src/models/ClientExperiment.ts

@@ -0,0 +1,113 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IPageTargeting extends Document {
+  condition: string;
+  routes: mongoose.Schema.Types.Mixed;
+}
+
+export interface IAudienceTargeting extends Document {
+  javascript: string;
+}
+
+export interface IVariants extends Document {
+  name: string;
+  javascript?: string;
+  css?: string;
+  traffic_allocation?: string;
+  slug?: string;
+}
+
+export interface IClientExperiment extends Document {
+  organisationId?: string;
+  client?: mongoose.Schema.Types.ObjectId;
+  viewId?: string;
+  javascript: string;
+  css: string;
+  name?: string;
+  status?: string;
+  experimentUrl: string;
+  pageTargeting: IPageTargeting;
+  audienceTargeting: IAudienceTargeting;
+  variants: IVariants;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+const PageTargetingSchema = new Schema<IPageTargeting>({
+  condition: {
+    type: String,
+    default: null,
+  },
+  routes: {
+    type: mongoose.Schema.Types.Mixed,
+  },
+});
+
+const AudienceTargetingSchema = new Schema<IAudienceTargeting>({
+  javascript: {
+    type: String,
+    default: "return true",
+  },
+});
+
+const VariantsSchema = new Schema<IVariants>({
+  name: {
+    type: String,
+    default: null,
+  },
+  traffic_allocation: {
+    type: Number,
+    default: null,
+  },
+  javascript: {
+    type: String,
+    default: null,
+  },
+  css: {
+    type: String,
+    default: null,
+  },
+  slug: {
+    type: String,
+    default: null,
+  },
+});
+
+const ClientExperimentSchema = new Schema<IClientExperiment>(
+  {
+    organisationId: {
+      type: String,
+      default: null,
+    },
+    name: String,
+    status: {
+      type: String,
+      default: "draft",
+    },
+    experimentUrl: String,
+    client: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "client",
+    },
+    viewId: {
+      type: String,
+    },
+    pageTargeting: [PageTargetingSchema],
+    audienceTargeting: AudienceTargetingSchema,
+    variants: [VariantsSchema],
+  },
+  {
+    timestamps: true,
+  }
+);
+
+ClientExperimentSchema.index({
+  client: 1,
+});
+
+const ClientExperiment = model<IClientExperiment>(
+  "clientexperiment",
+  ClientExperimentSchema
+);
+
+export default ClientExperiment;

package/src/models/ClientScript.ts

@@ -0,0 +1,164 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IClientScriptSchema extends Document {
+  scriptUrl: string;
+  viewId: string;
+}
+
+export interface IClientScript extends Document {
+  organisationId?: string;
+  client?: mongoose.Schema.Types.ObjectId;
+  viewId?: string;
+  clientScriptURL: string;
+  jquery_include: string;
+  debug: Boolean;
+  restrict_debug: Boolean;
+  adhere_dnt: Boolean;
+  max_cookie_lifetime: Number;
+  activation_mode: string;
+  use_antiflicker: Boolean;
+  snippet_revision: Number;
+  rules: string;
+  rules_tracking: string;
+  tracker_url: string;
+  asset_url: string;
+  metadata_key_exp_1: mongoose.Schema.Types.Mixed;
+  metadata_key_exp_2: mongoose.Schema.Types.Mixed;
+  metadata_key_exp_3: mongoose.Schema.Types.Mixed;
+  metadata_key_var_1: mongoose.Schema.Types.Mixed;
+  metadata_key_var_2: mongoose.Schema.Types.Mixed;
+  metadata_key_var_3: mongoose.Schema.Types.Mixed;
+  cookie_domain: string;
+  snippet_version: Number;
+  storage: string;
+  run_only_on_reinit: Boolean;
+  allow_in_iframes: Boolean;
+  visual_editor_version: Number;
+  jscode: string;
+  csscode: string;
+  is_spa: Boolean;
+}
+
+const ClientScriptSchema = new Schema<IClientScript>(
+  {
+    organisationId: {
+      type: String,
+      default: null,
+    },
+    client: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "client",
+    },
+    viewId: {
+      type: String,
+    },
+    clientScriptURL: {
+      type: String,
+    },
+    jquery_include: {
+      type: String,
+      default: "false",
+    },
+    debug: {
+      type: Boolean,
+      default: false,
+    },
+    restrict_debug: {
+      type: Boolean,
+      default: false,
+    },
+    adhere_dnt: {
+      type: Boolean,
+      default: false,
+    },
+    max_cookie_lifetime: {
+      type: Number,
+    },
+    activation_mode: {
+      type: String,
+    },
+    use_antiflicker: {
+      type: Boolean,
+      default: false,
+    },
+    snippet_revision: {
+      type: Number,
+      default: 1,
+    },
+    rules: {
+      type: String,
+      default: "return true;"
+    },
+    rules_tracking: {
+      type: String,
+      default: "return true;"
+    },
+    tracker_url: {
+      type: String,
+    },
+    asset_url: {
+      type: String,
+    },
+    metadata_key_exp_1: {
+      type: mongoose.Schema.Types.Mixed,
+    },
+    metadata_key_exp_2: {
+      type: mongoose.Schema.Types.Mixed,
+    },
+    metadata_key_exp_3: {
+      type: mongoose.Schema.Types.Mixed,
+    },
+    metadata_key_var_1: {
+      type: mongoose.Schema.Types.Mixed,
+    },
+    metadata_key_var_2: {
+      type: mongoose.Schema.Types.Mixed,
+    },
+    metadata_key_var_3: {
+      type: mongoose.Schema.Types.Mixed,
+    },
+    cookie_domain: {
+      type: String,
+    },
+    snippet_version: {
+      type: Number,
+    },
+    storage: {
+      type: String,
+      default: "default",
+    },
+    run_only_on_reinit: {
+      type: Boolean,
+      default: false,
+    },
+    allow_in_iframes: {
+      type: Boolean,
+      default: false,
+    },
+    visual_editor_version: {
+      type: Number,
+    },
+    jscode: {
+      type: String,
+    },
+    csscode: {
+      type: String,
+    },
+    is_spa: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+ClientScriptSchema.index({
+  client: 1,
+  viewId: 1,
+});
+
+const ClientScript = model<IClientScript>("clientscript", ClientScriptSchema);
+
+export default ClientScript;

package/src/models/Environment.ts

@@ -0,0 +1,29 @@
+import mongoose, { Document, Schema, model } from "mongoose";
+
+export interface IEnvironment extends Document {
+  name: string;
+  rules_js?: string;
+  client?: mongoose.Schema.Types.ObjectId;
+}
+
+const EnvironmentSchema = new Schema<IEnvironment>({
+  name: {
+    type: String,
+    required: true,
+    default: 'Default'
+  },
+  client: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "client",
+  },
+  rules_js: {
+    type: String,
+    default: "return true"
+  },
+},{
+  timestamps: true
+});
+
+const Environment = model<IEnvironment>("environment", EnvironmentSchema);
+
+export default Environment;