vwo-fme-node-sdk 1.0.0

package/lib/enums/EventEnum.ts

@@ -0,0 +1,4 @@
+export enum EventEnum {
+  VWO_VARIATION_SHOWN = 'vwo_variationShown',
+  VWO_SYNC_VISITOR_PROP = 'vwo_syncVisitorProp',
+}

package/lib/enums/HeadersEnum.ts

@@ -0,0 +1,4 @@
+export enum HeadersEnum {
+  USER_AGENT = 'X-Device-User-Agent',
+  IP = 'VWO-X-Forwarded-For',
+}

package/lib/enums/HooksEnum.ts

@@ -0,0 +1,11 @@
+enum DecisionTypes {
+  CAMPAIGN_DECISION = 'CAMPAIGN_DECISION',
+}
+
+interface HooksEnum {
+  DECISION_TYPES: typeof DecisionTypes;
+}
+
+const HooksEnum: HooksEnum = {
+  DECISION_TYPES: DecisionTypes,
+};

package/lib/enums/LogLevelEnum.ts

@@ -0,0 +1,7 @@
+export enum LogLevelEnum {
+  TRACE = 'trace',
+  DEBUG = 'debug',
+  INFO = 'info',
+  WARN = 'warn',
+  ERROR = 'error',
+}

package/lib/enums/StatusEnum.ts

@@ -0,0 +1,4 @@
+export enum StatusEnum {
+  PASSED = 'passed',
+  FAILED = 'failed',
+}

package/lib/enums/StorageEnum.ts

@@ -0,0 +1,8 @@
+export enum StorageEnum {
+  STORAGE_UNDEFINED,
+  INCORRECT_DATA,
+  NO_DATA_FOUND,
+  CAMPAIGN_PAUSED,
+  VARIATION_NOT_FOUND,
+  WHITELISTED_VARIATION,
+}

package/lib/enums/UrlEnum.ts

@@ -0,0 +1,13 @@
+export enum UrlEnum {
+  BASE_URL = 'dev.visualwebsiteoptimizer.com',
+  SETTINGS_URL = '/server-side/settings',
+  WEBHOOK_SETTINGS_URL = '/server-side/pull',
+  TRACK_USER = '/server-side/track-user',
+  TRACK_GOAL = '/server-side/track-goal',
+  PUSH = '/server-side/push',
+  BATCH_EVENTS = '/server-side/batch-events',
+  EVENTS = '/events/t',
+  ATTRIBUTE_CHECK = '/attributes/check',
+  LOCATION_CHECK = '/getLocation',
+  UAPARSER = '/server-side/ua-parser',
+}

package/lib/enums/campaignTypeEnum.ts

@@ -0,0 +1,5 @@
+export enum CampaignTypeEnum {
+  ROLLOUT = 'FLAG_ROLLOUT',
+  AB = 'FLAG_TESTING',
+  PERSONALIZE = 'FLAG_PERSONALIZE',
+}

package/lib/enums/logMessages/DebugLogMessageEnum.ts

@@ -0,0 +1,3 @@
+export enum DebugLogMessageEnum {
+  API_CALLED = 'API - {apiName} called'
+}

package/lib/enums/logMessages/ErrorLogMessageEnum.ts

@@ -0,0 +1,3 @@
+export enum ErrorLogMessageEnum {
+  API_THROW_ERROR = 'API - {apiName} failed to execute. Trace - {err}'
+}

package/lib/index.ts

@@ -0,0 +1 @@
+export { VWO, init } from './VWO';

package/lib/models/CampaignModel.ts

@@ -0,0 +1,176 @@
+import { VariationModel } from './VariationModel';
+import { MetricModel } from './MetricModel';
+import { VariableModel } from './VariableModel';
+import { dynamic } from '../types/common';
+import { RuleModel } from './RuleModel';
+
+export class CampaignModel {
+  private id: number;
+  private segments: Record<string, dynamic>;
+  private percentTraffic: number;
+  private isUserListEnabled: boolean;
+  // private autoActivate: boolean;
+  // private autoTrack: boolean;
+  private key: string;
+  // private priority: number;
+  private type: string;
+  private name: string;
+  private isForcedVariationEnabled: boolean;
+  private variations: Array<VariationModel> = [];
+  private metrics: Array<MetricModel> = [];
+  private variables: Array<VariableModel> = [];
+  // private featureId: number;
+  // private featureKey: string;
+
+  copy(campaignModel: CampaignModel): void {
+    this.metrics = campaignModel.metrics;
+    this.variations = campaignModel.variations;
+    this.variables = campaignModel.variables;
+    this.processCampaignKeys(campaignModel);
+  }
+
+  modelFromDictionary(campaign: CampaignModel): this {
+    this.processCampaignProperties(campaign);
+    this.processCampaignKeys(campaign);
+    return this;
+  }
+
+  processCampaignProperties(campaign: CampaignModel): void {
+    if (campaign.variables) {
+      // campaign.var ||
+      if (
+        // (campaign.var && campaign.var.constructor === {}.constructor) ||
+        campaign.variables.constructor === {}.constructor
+      ) {
+        this.variables = [];
+      } else {
+        const variableList: Array<VariableModel> = campaign.variables; // campaign.var ||
+        variableList.forEach((variable: any) => {
+          this.variables.push(new VariableModel().modelFromDictionary(variable));
+        });
+      }
+    }
+
+    if (campaign.variations) {
+      // campaign.v ||
+      if (
+        // (campaign.v && campaign.v.constructor === {}.constructor) ||
+        campaign.variations.constructor === {}.constructor
+      ) {
+        this.variations = [];
+      } else {
+        const variationList: Array<VariationModel> = campaign.variations; // campaign.v ||
+        variationList.forEach((variation: any) => {
+          this.variations.push(new VariationModel().modelFromDictionary(variation));
+        });
+      }
+    }
+
+    if (campaign.metrics) {
+      // campaign.m ||
+      if (campaign.metrics && campaign.metrics.constructor === {}.constructor) {
+        this.metrics = [];
+      } else {
+        const metricsList: Array<MetricModel> = campaign.metrics || [];
+        metricsList.forEach((metric: any) => {
+          this.metrics.push(new MetricModel().modelFromDictionary(metric));
+        });
+      }
+    }
+  }
+
+  processCampaignKeys(campaign: CampaignModel): void {
+    this.id = campaign.id;
+    this.percentTraffic = campaign.percentTraffic; // campaign.pT ||
+    this.name = campaign.name; // campaign.n ||
+    // this.autoActivate =
+    //   campaign.autoActivate !== undefined
+    //     ? campaign.autoActivate
+    //     : campaign.iMAE
+    //     ? !campaign.iMAE
+    //     : !campaign.isManualActivationEnabled;
+    // this.autoTrack =
+    //   campaign.autoTrack !== undefined
+    //     ? campaign.autoTrack
+    //     : campaign.iMTRE
+    //     ? !campaign.iMTRE
+    //     : !campaign.isManualTrackingEnabled;
+    this.isForcedVariationEnabled = campaign.isForcedVariationEnabled; // campaign.iFVE ||
+    this.isUserListEnabled = campaign.isUserListEnabled; // campaign.iULE ||
+    this.segments = campaign.segments;
+    this.key = campaign.key; // campaign.k ||
+    // this.priority = campaign.pr || campaign.priority;
+    this.type = campaign.type; // campaign.t ||
+    // this.featureId = campaign.featureId;
+    // this.featureKey = campaign.featureKey;
+  }
+
+  // setFeatureDetails(featuerId: number, featureKey: string): void {
+  //   this.featureId = featuerId;
+  //   this.featureKey = featureKey;
+  // }
+
+  // getFeatureId(): number {
+  //   return this.featureId;
+  // }
+
+  // getFeatureKey(): string {
+  //   return this.featureKey;
+  // }
+
+  getId(): number {
+    return this.id;
+  }
+
+  getName(): string {
+    return this.name;
+  }
+
+  getSegments(): Record<string, dynamic> {
+    return this.segments;
+  }
+
+  getTraffic(): number {
+    return this.percentTraffic;
+  }
+
+  getType(): string {
+    return this.type;
+  }
+
+  getIsForcedVariationEnabled(): boolean {
+    return this.isForcedVariationEnabled;
+  }
+
+  getIsUserListEnabled(): boolean {
+    return this.isUserListEnabled;
+  }
+
+  // getAutoTrack(): boolean {
+  //   return this.autoTrack;
+  // }
+
+  // getAutoActivate(): boolean {
+  //   return this.autoActivate;
+  // }
+
+  getKey(): string {
+    return this.key;
+  }
+
+  getMetrics(): Array<MetricModel> {
+    return this.metrics;
+  }
+
+  getVariations(): Array<VariationModel> {
+    return this.variations;
+  }
+
+  getVariables(): Array<VariableModel> {
+    return this.variables;
+  }
+
+  // getPriority(): number {
+  //   return this.priority;
+  // }
+}

package/lib/models/FeatureModel.ts

@@ -0,0 +1,81 @@
+import { VariableModel } from './VariableModel';
+import { VariationModel } from './VariationModel';
+import { MetricModel } from './MetricModel';
+import { CampaignModel } from './CampaignModel';
+import { RuleModel } from './RuleModel';
+import { ImpactCapmaignModel } from './ImpactCampaignModel';
+
+export class FeatureModel {
+  private m: Array<MetricModel> = [];
+  private metrics: Array<MetricModel> = [];
+
+  private id: number;
+  private key: string;
+  private name: string;
+  private type: string;
+  private rules: Array<RuleModel> = [];
+  private impactCampaign: ImpactCapmaignModel = null;
+
+  private rulesLinkedCampaign: Array<CampaignModel> = [];
+
+  modelFromDictionary(feature: FeatureModel): this {
+    this.id = feature.id;
+    this.key = feature.key;
+    this.name = feature.name;
+    this.type = feature.type;
+    if (feature.impactCampaign) {
+      this.impactCampaign = new ImpactCapmaignModel().modelFromDictionary(feature.impactCampaign);
+    }
+
+    if ((feature.m && feature.m.constructor === {}.constructor) || feature.metrics.constructor === {}.constructor) {
+      this.metrics = [];
+    } else {
+      const metricList: Array<MetricModel> = feature.m || feature.metrics;
+      metricList.forEach((metric) => {
+        this.metrics.push(new MetricModel().modelFromDictionary(metric));
+      });
+    }
+
+    if (feature.rules.constructor === {}.constructor) {
+      this.rules = [];
+    } else {
+      const ruleList: Array<RuleModel> = feature.rules;
+      ruleList.forEach((rule) => {
+        this.rules.push(new RuleModel().modelFromDictionary(rule));
+      });
+    }
+
+    if (feature.rulesLinkedCampaign && feature.rulesLinkedCampaign.constructor !== {}.constructor) {
+      const linkedCampaignList: Array<CampaignModel> = feature.rulesLinkedCampaign;
+      linkedCampaignList.forEach((linkedCampaign) => {
+        this.rulesLinkedCampaign.push(new CampaignModel().modelFromDictionary(linkedCampaign));
+      });
+    }
+
+    return this;
+  }
+
+  getName(): string {
+    return this.name;
+  }
+
+  getType(): string {
+    return this.type;
+  }
+
+  getId(): number {
+    return this.id;
+  }
+
+  getKey(): string {
+    return this.key;
+  }
+
+  getRules(): Array<RuleModel> {
+    return this.rules;
+  }
+
+  getImpactCampaign(): ImpactCapmaignModel {
+    return this.impactCampaign;
+  }
+}

package/lib/models/ImpactCampaignModel.ts

@@ -0,0 +1,20 @@
+import { dynamic } from '../types/common';
+
+export class ImpactCapmaignModel {
+  private campaignId: number;
+  private type: string;
+
+  modelFromDictionary(impactCampaign: ImpactCapmaignModel): this {
+    this.type = impactCampaign.type;
+    this.campaignId = impactCampaign.campaignId;
+    return this;
+  }
+
+  getCampaignId(): number {
+    return this.campaignId;
+  }
+
+  getType(): string {
+    return this.type;
+  }
+}

package/lib/models/MetricModel.ts

@@ -0,0 +1,31 @@
+import { dynamic } from '../types/common';
+
+export class MetricModel {
+  private key: string;
+  private identifier: string;
+
+  private i: number;
+  private id: number;
+
+  private t: string;
+  private type: string;
+
+  modelFromDictionary(metric: MetricModel): this {
+    this.identifier = metric.identifier || metric.key;
+    this.id = metric.i || metric.id;
+    this.type = metric.t || metric.type;
+    return this;
+  }
+
+  getId(): number {
+    return this.id;
+  }
+
+  getIdentifier(): string {
+    return this.identifier;
+  }
+
+  getType(): string {
+    return this.type;
+  }
+}

package/lib/models/RuleModel.ts

@@ -0,0 +1,35 @@
+import { dynamic } from '../types/common';
+
+export class RuleModel {
+  private status: boolean;
+
+  private variationId: number;
+
+  private campaignId: number;
+
+  private type: string;
+
+  modelFromDictionary(rule: RuleModel): this {
+    this.type = rule.type;
+    this.status = rule.status;
+    this.variationId = rule.variationId;
+    this.campaignId = rule.campaignId;
+    return this;
+  }
+
+  getCampaignId(): number {
+    return this.campaignId;
+  }
+
+  getVariationId(): number {
+    return this.variationId;
+  }
+
+  getStatus(): boolean {
+    return this.status;
+  }
+
+  getType(): string {
+    return this.type;
+  }
+}

package/lib/models/SettingsModel.ts

@@ -0,0 +1,95 @@
+import { FeatureModel } from './FeatureModel';
+import { CampaignModel } from './CampaignModel';
+import { dynamic } from '../types/common';
+
+export class SettingsModel {
+  private sK: string;
+  private sdkKey: string;
+
+  private f: Array<FeatureModel> = [];
+  private features: Array<FeatureModel> = [];
+
+  private c: Array<CampaignModel> = [];
+  private campaigns: Array<CampaignModel> = [];
+
+  private campaignGroups: Record<string, number> = {};
+  private cG: Record<string, number> = {};
+
+  private groups: Record<string, any> = {};
+  private g: Record<string, any> = {};
+
+  private a: string;
+  private accountId: string;
+
+  private v: number;
+  private version: number;
+  private collectionPrefix: string;
+
+  constructor(settings: SettingsModel) {
+    this.sdkKey = settings.sK || settings.sdkKey;
+    this.accountId = settings.a || settings.accountId;
+    this.version = settings.v || settings.version;
+    this.collectionPrefix = settings.collectionPrefix;
+
+    if (
+      (settings.f && settings.f.constructor !== {}.constructor) ||
+      (settings.features && settings.features.constructor !== {}.constructor)
+    ) {
+      const featureList: Array<FeatureModel> = settings.f || settings.features;
+      featureList.forEach((feature) => {
+        this.features.push(new FeatureModel().modelFromDictionary(feature));
+      });
+    }
+
+    if (
+      (settings.c && settings.c.constructor !== {}.constructor) ||
+      (settings.campaigns && settings.campaigns.constructor !== {}.constructor)
+    ) {
+      const campaignList: Array<CampaignModel> = settings.c || settings.campaigns;
+      campaignList.forEach((campaign) => {
+        this.campaigns.push(new CampaignModel().modelFromDictionary(campaign));
+      });
+    }
+
+    if (settings.cG || settings.campaignGroups) {
+      this.campaignGroups = settings.cG || settings.campaignGroups;
+    }
+
+    if (settings.g || settings.groups) {
+      this.groups = settings.g || settings.groups;
+    }
+
+    return this;
+  }
+  getFeatures(): Array<FeatureModel> {
+    return this.features;
+  }
+
+  getCampaigns(): Array<CampaignModel> {
+    return this.campaigns;
+  }
+
+  getSdkkey(): string {
+    return this.sdkKey;
+  }
+
+  getAccountId(): string {
+    return this.accountId;
+  }
+
+  getVersion(): number {
+    return this.version;
+  }
+
+  getCollectionPrefix(): string {
+    return this.collectionPrefix;
+  }
+
+  getCampaignGroups(): Record<string, number> {
+    return this.campaignGroups;
+  }
+
+  getGroups(): Record<string, any> {
+    return this.groups;
+  }
+}

package/lib/models/VariableModel.ts

@@ -0,0 +1,51 @@
+import { dynamic } from '../types/common';
+
+export class VariableModel {
+  private val: dynamic;
+  private value: dynamic;
+
+  private type: string;
+
+  private k: string;
+  private key: string;
+
+  private i: number;
+  private id: number;
+
+  modelFromDictionary(variable: VariableModel): this {
+    this.value = variable.val || variable.value;
+    this.type = variable.type;
+    this.key = variable.k || variable.key;
+    this.id = variable.i || variable.id;
+
+    return this;
+  }
+
+  setValue(value: dynamic): void {
+    this.value = value;
+  }
+
+  setKey(key: string): void {
+    this.key = key;
+  }
+
+  setType(type: string): void {
+    this.type = type;
+  }
+
+  getId(): number {
+    return this.id;
+  }
+
+  getValue(): dynamic {
+    return this.value;
+  }
+
+  getType(): string {
+    return this.type;
+  }
+
+  getKey(): string {
+    return this.key;
+  }
+}

package/lib/models/VariationModel.ts

@@ -0,0 +1,101 @@
+import { dynamic } from '../types/common';
+import { VariableModel } from './VariableModel';
+
+export class VariationModel {
+  private i: number;
+  private id: number;
+
+  private n: string;
+  private key: string;
+  private name: string;
+
+  private w: number;
+  private weight: number;
+
+  private startRangeVariation: number;
+  private endRangeVariation: number;
+  private variables: Array<VariableModel> = [];
+  private variations: Array<VariationModel> = [];
+
+  private seg: Record<string, dynamic>;
+  private segments: Record<string, dynamic>;
+
+  modelFromDictionary(variation: VariationModel): this {
+    this.id = variation.i || variation.id;
+    this.key = variation.n || variation.key || variation.name;
+    this.weight = variation.w || variation.weight;
+    this.setStartRange(variation.startRangeVariation);
+    this.setEndRange(variation.endRangeVariation);
+    if (variation.seg || variation.segments) {
+      this.segments = variation.seg || variation.segments;
+    }
+
+    if (variation.variables) {
+      if (variation.variables.constructor === {}.constructor) {
+        this.variables = [];
+      } else {
+        const variableList: Array<VariableModel> = variation.variables;
+        variableList.forEach((variable) => {
+          this.variables.push(new VariableModel().modelFromDictionary(variable));
+        });
+      }
+    }
+
+    if (variation.variations) {
+      if (variation.variations.constructor === {}.constructor) {
+        this.variations = [];
+      } else {
+        const variationList: Array<VariationModel> = variation.variations;
+        variationList.forEach((variation: any) => {
+          this.variations.push(new VariationModel().modelFromDictionary(variation));
+        });
+      }
+    }
+
+    return this;
+  }
+
+  setStartRange(startRange: number): void {
+    this.startRangeVariation = startRange;
+  }
+
+  setEndRange(endRange: number): void {
+    this.endRangeVariation = endRange;
+  }
+
+  setWeight(weight: number): void {
+    this.weight = weight;
+  }
+
+  getId(): number {
+    return this.id;
+  }
+
+  getKey(): string {
+    return this.key;
+  }
+
+  getWeight(): number {
+    return this.weight;
+  }
+
+  getSegments(): Record<string, dynamic> {
+    return this.segments;
+  }
+
+  getStartRangeVariation(): number {
+    return this.startRangeVariation;
+  }
+
+  getEndRangeVariation(): number {
+    return this.endRangeVariation;
+  }
+
+  getVariables(): Array<VariableModel> {
+    return this.variables;
+  }
+
+  getVariations(): Array<VariationModel> {
+    return this.variations;
+  }
+}