vwo-fme-node-sdk 1.0.0

package/lib/utils/CampaignUtil.ts

@@ -0,0 +1,236 @@
+import { VariationModel } from '../models/VariationModel';
+import { VariableModel } from '../models/VariableModel';
+import { Constants } from '../constants';
+import { CampaignModel } from '../models/CampaignModel';
+import { LogManager } from '../modules/logger';
+import { CampaignTypeEnum } from '../enums/campaignTypeEnum';
+import { SettingsModel } from '../models/SettingsModel';
+
+export function setVariationAllocation(campaign: CampaignModel): void {
+  if (campaign.getType() === CampaignTypeEnum.ROLLOUT || campaign.getType() === CampaignTypeEnum.PERSONALIZE) {
+    // Handle special logic for rollout or personalize campaigns
+    handleRolloutCampaign(campaign);
+  } else {
+    let stepFactor = 0;
+    const numberOfVariations = campaign.getVariations().length;
+    for (let i = 0, currentAllocation = 0; i < numberOfVariations; i++) {
+      let variation = campaign.getVariations()[i];
+
+      stepFactor = assignRangeValues(variation, currentAllocation);
+      currentAllocation += stepFactor;
+      LogManager.Instance.debug(
+        `VARIATION_RANGE_ALLOCATION: Variation:${variation.getKey()} of Campaign:${campaign.getKey()} having weight:${variation.getWeight()} got bucketing range: ( ${variation.getStartRangeVariation()} - ${variation.getEndRangeVariation()} )`,
+      );
+    }
+  }
+}
+
+function handleRolloutCampaign(campaign: CampaignModel): void {
+  // Set start and end ranges for all variations in the campaign
+  for (let i = 0; i < campaign.getVariations().length; i++) {
+    let variation = campaign.getVariations()[i];
+    let endRange = campaign.getVariations()[i].getWeight() * 100;
+    variation.setStartRange(1);
+    variation.setEndRange(endRange);
+    LogManager.Instance.debug(
+      `VARIATION_RANGE_ALLOCATION: Variation:${variation.getKey()} of Campaign:${campaign.getKey()} got bucketing range: ( ${1} - ${endRange} )`,
+    );
+  }
+}
+
+function copyVariableData(variationVariable: Array<VariableModel>, featureVariable: Array<VariableModel>): void {
+  // create a featureVariableMap
+  const featureVariableMap: Record<number, VariableModel> = {};
+  featureVariable.forEach((variable: VariableModel) => {
+    featureVariableMap[variable.getId()] = variable;
+  });
+  variationVariable.forEach((variable: VariableModel) => {
+    const featureVariable: VariableModel = featureVariableMap[variable.getId()];
+    if (featureVariable) {
+      variable.setKey(featureVariable.getKey());
+      variable.setType(featureVariable.getType());
+    }
+  });
+}
+
+export function assignRangeValues(data: VariationModel, currentAllocation: number) {
+  const stepFactor: number = getVariationBucketRange(data.getWeight());
+
+  if (stepFactor) {
+    data.setStartRange(currentAllocation + 1);
+    data.setEndRange(currentAllocation + stepFactor);
+  } else {
+    data.setStartRange(-1);
+    data.setEndRange(-1);
+  }
+  return stepFactor;
+}
+
+function getVariationBucketRange(variationWeight: number) {
+  if (!variationWeight || variationWeight === 0) {
+    return 0;
+  }
+
+  const startRange = Math.ceil(variationWeight * 100);
+
+  return Math.min(startRange, Constants.MAX_TRAFFIC_VALUE);
+}
+
+export function scaleVariationWeights(variations: any) {
+  const totalWeight = variations.reduce((acc, variation) => {
+    return acc + variation.weight;
+  }, 0);
+  if (!totalWeight) {
+    const weight = 100 / variations.length;
+    variations.forEach((variation) => (variation.weight = weight));
+  } else {
+    variations.forEach((variation) => (variation.weight = (variation.weight / totalWeight) * 100));
+  }
+}
+
+export function getBucketingSeed(userId, campaign, groupId) {
+  if (groupId) {
+    return `${groupId}_${userId}`;
+  }
+  return `${campaign.id}_${userId}`;
+}
+
+export function getCampaignVariation(settings, campaignKey, variationId) {
+  const campaign: CampaignModel = settings.getCampaigns().find((campaign: CampaignModel) => {
+    return campaign.getKey() === campaignKey;
+  });
+
+  if (campaign) {
+    const variation: VariationModel = campaign.getVariations().find((variation: VariationModel) => {
+      return variation.getId() === variationId;
+    });
+
+    if (variation) {
+      return new VariationModel().modelFromDictionary(variation);
+    }
+  }
+  return null;
+}
+
+export function getRolloutVariation(settings, rolloutKey, variationId) {
+  const rolloutCampaign: CampaignModel = settings.getCampaigns().find((campaign: CampaignModel) => {
+    return campaign.getKey() === rolloutKey;
+  });
+
+  if (rolloutCampaign) {
+    const variation: VariationModel = rolloutCampaign.getVariations().find((variation: VariationModel) => {
+      return variation.getId() === variationId;
+    });
+
+    if (variation) {
+      return new VariationModel().modelFromDictionary(variation);
+    }
+  }
+  return null;
+}
+
+export function setCampaignAllocation(campaigns: any[]) {
+  let stepFactor = 0;
+  for (let i = 0, currentAllocation = 0; i < campaigns.length; i++) {
+    let campaign = campaigns[i];
+
+    stepFactor = assignRangeValuesMEG(campaign, currentAllocation);
+    currentAllocation += stepFactor;
+  }
+}
+
+export function isPartOfGroup(settings: any, campaignId: any) {
+  if (settings.campaignGroups && settings.campaignGroups.hasOwnProperty(campaignId)) {
+    return {
+      groupId: settings.campaignGroups[campaignId],
+      groupName: settings.groups[settings.campaignGroups[campaignId]].name,
+    };
+  }
+  return {};
+}
+
+export function findGroupsFeaturePartOf(settings: any, featureKey: string) {
+  const campaignIds: Array<number> = [];
+  // loop over all rules inside feature where feature key is given featureKey and get all campaignIds
+  settings.features.forEach((feature) => {
+    if (feature.key === featureKey) {
+      feature.rules.forEach((rule) => {
+        if (campaignIds.indexOf(rule.campaignId) === -1) {
+          campaignIds.push(rule.campaignId);
+        }
+      });
+    }
+  });
+
+  // loop over all campaigns and find the group for the campaign
+  const groups: Array<any> = [];
+  campaignIds.forEach((campaignId) => {
+    const group = isPartOfGroup(settings, campaignId);
+    if (group.groupId) {
+      // check if group is already added to groups array
+      const groupIndex = groups.findIndex((grp) => grp.groupId === group.groupId);
+      if (groupIndex === -1) {
+        groups.push(group);
+      }
+    }
+  });
+  return groups;
+}
+
+export function getCampaignsByGroupId(settings: SettingsModel, groupId: any) {
+  const group = settings.getGroups()[groupId];
+  if (group) {
+    return group.campaigns;
+  } else {
+    return []; // Return an empty array if the group ID is not found
+  }
+}
+
+export function getFeatureKeysFromCampaignIds(settings: SettingsModel, campaignIds: any) {
+  const featureKeys = [];
+  for (const campaignId of campaignIds) {
+    settings.getFeatures().forEach((feature) => {
+      feature.getRules().forEach((rule) => {
+        if (rule.getCampaignId() === campaignId) {
+          featureKeys.push(feature.getKey());
+        }
+      });
+    });
+  }
+  return featureKeys;
+}
+
+export function getCampaignIdsFromFeatureKey(settings: SettingsModel, featureKey: string) {
+  const campaignIds = [];
+  settings.getFeatures().forEach((feature) => {
+    if (feature.getKey() === featureKey) {
+      feature.getRules().forEach((rule) => {
+        campaignIds.push(rule.getCampaignId());
+      });
+    }
+  });
+  return campaignIds;
+}
+
+export function assignRangeValuesMEG(data: any, currentAllocation: number) {
+  const stepFactor: number = getVariationBucketRange(data.weight);
+
+  if (stepFactor) {
+    data.startRangeVariation = currentAllocation + 1;
+    data.endRangeVariation = currentAllocation + stepFactor;
+  } else {
+    data.startRangeVariation = -1;
+    data.endRangeVariation = -1;
+  }
+  return stepFactor;
+}
+
+export function getRuleTypeUsingCampaignIdFromFeature(feature: any, campaignId: number) {
+  let ruleType = '';
+  feature.rules.forEach((rule) => {
+    if (rule.campaignId === campaignId) {
+      ruleType = rule.type;
+    }
+  });
+  return ruleType;
+}

package/lib/utils/DataTypeUtil.ts

@@ -0,0 +1,87 @@
+import { dynamic } from '../types/common';
+
+type FunctionType = (val: dynamic) => void;
+
+export function isObject<T>(
+  val: T,
+): val is Record<any, dynamic> & Exclude<T, Array<dynamic> | FunctionType | RegExp | Promise<dynamic> | Date> {
+  return Object.prototype.toString.call(val) === '[object Object]';
+}
+
+export function isArray(val: dynamic): val is Array<dynamic> {
+  return Object.prototype.toString.call(val) === '[object Array]';
+}
+
+export function isNull(val: dynamic): val is null {
+  return Object.prototype.toString.call(val) === '[object Null]';
+}
+
+export function isUndefined(val: dynamic): val is undefined {
+  return Object.prototype.toString.call(val) === '[object Undefined]';
+}
+
+export function isDefined<T>(val: T): val is NonNullable<T> {
+  return !isUndefined(val) && !isNull(val);
+}
+
+export function isNumber(val: dynamic): val is number {
+  // Note: NaN is also a number
+  return Object.prototype.toString.call(val) === '[object Number]';
+}
+
+export function isString(val: dynamic): val is string {
+  return Object.prototype.toString.call(val) === '[object String]';
+}
+
+export function isBoolean(val: dynamic): val is boolean {
+  return Object.prototype.toString.call(val) === '[object Boolean]';
+}
+
+export function isNaN(val: dynamic): val is number {
+  // eslint-disable-next-line no-self-compare
+  return val !== val;
+}
+
+export function isDate(val: dynamic): val is Date {
+  return Object.prototype.toString.call(val) === '[object Date]';
+}
+
+export function isFunction(val: dynamic): val is FunctionType {
+  return Object.prototype.toString.call(val) === '[object Function]';
+}
+
+export function isRegex(val: dynamic): val is RegExp {
+  return Object.prototype.toString.call(val) === '[object RegExp]';
+}
+
+export function isPromise(val: dynamic): val is Promise<dynamic> {
+  return Object.prototype.toString.call(val) === '[object Promise]';
+}
+
+export function getType(val: dynamic): string {
+  return isObject(val)
+    ? 'Object'
+    : isArray(val)
+      ? 'Array'
+      : isNull(val)
+        ? 'Null'
+        : isUndefined(val)
+          ? 'Undefined'
+          : isNaN(val)
+            ? 'NaN'
+            : isNumber(val)
+              ? 'Number'
+              : isString(val)
+                ? 'String'
+                : isBoolean(val)
+                  ? 'Boolean'
+                  : isDate(val)
+                    ? 'Date'
+                    : isRegex(val)
+                      ? 'Regex'
+                      : isFunction(val)
+                        ? 'Function'
+                        : isPromise(val)
+                          ? 'Promise'
+                          : 'Unknown Type';
+}

package/lib/utils/DecisionUtil.ts

@@ -0,0 +1,180 @@
+import { SettingsModel } from './../models/SettingsModel';
+import { LogManager } from '../modules/logger';
+import { isObject } from '../utils/DataTypeUtil';
+import { SegmentationManager } from '../modules/segmentor';
+import { getUUID } from './UuidUtil';
+import { isPromise } from 'util/types';
+import { cloneObject } from './FunctionUtil';
+import { scaleVariationWeights, assignRangeValues, getBucketingSeed } from './CampaignUtil';
+import { DecisionMaker } from '../modules/decision-maker';
+import { CampaignDecisionService } from '../services/CampaignDecisionService';
+import { CampaignModel } from '../models/CampaignModel';
+import { VariationModel } from '../models/VariationModel'; // Import the missing VariationModel type
+import { CampaignTypeEnum } from '../enums/campaignTypeEnum';
+import HooksManager from '../services/HooksManager';
+import { StatusEnum } from '../enums/StatusEnum';
+// import { CampaignTypeEnum } from '../enums/campaignTypeEnum';
+
+export const checkWhitelistingAndPreSeg = async (
+  settings: any,
+  campaign: CampaignModel,
+  context: any,
+  isMegWinnerRule: Boolean,
+  decision: any,
+): Promise<[Boolean, any]> => {
+  let vwoUserId = getUUID(context.user.id, settings.accountId);
+
+  // only check whitelisting for ab campaigns
+  if (campaign.getType() === CampaignTypeEnum.AB) {
+    // set _vwoUserId for variation targeting variables
+    context.user.variationTargetingVariables = Object.assign({}, context.user.variationTargetingVariables, {
+      _vwoUserId: campaign.getIsUserListEnabled() ? vwoUserId : context.user.id,
+    });
+    Object.assign(decision, { variationTargetingVariables: context.user.variationTargetingVariables }); // for integration
+    // check if the campaign satisfies the whitelisting
+    if (campaign.getIsForcedVariationEnabled()) {
+      const whitelistedVariation = await checkForWhitelisting(campaign, campaign.getKey(), settings, context);
+      if (whitelistedVariation && Object.keys(whitelistedVariation).length > 0) {
+        return [true, whitelistedVariation];
+      }
+    } else {
+      LogManager.Instance.info(
+        `WHITELISTING_SKIPPED: Whitelisting is not used for Campaign:${campaign.getKey()}, hence skipping evaluating whitelisting for User ID:${context.user.id}`,
+      );
+    }
+  }
+
+  if (isMegWinnerRule) {
+    return [true, null]; // for MEG winner rule, no need to check for pre segmentation as it's already evaluated
+  }
+  // userlist segment is also available for campaign pre segmentation
+  context.user.customVariables = Object.assign({}, context.user.customVariables, {
+    _vwoUserId: campaign.getIsUserListEnabled() ? vwoUserId : context.user.id,
+  });
+  Object.assign(decision, { customVariables: context.user.customVariables }); // for integeration
+
+  // check for campaign pre segmentation
+  const preSegmentationResult = await new CampaignDecisionService().getDecision(campaign, settings, context);
+  return [preSegmentationResult, null];
+};
+
+/**
+ * Check for whitelisting
+ * @param campaign      Campaign object
+ * @param campaignKey   Campaign key
+ * @param userId        User ID
+ * @param variationTargetingVariables   Variation targeting variables
+ * @returns
+ */
+const checkForWhitelisting = async (
+  campaign: any,
+  campaignKey: string,
+  settings: SettingsModel,
+  context: any,
+): Promise<any> => {
+  let status;
+  // check if the campaign satisfies the whitelisting
+  const whitelistingResult = await _evaluateWhitelisting(campaign, campaignKey, settings, context);
+  let variationString;
+  if (whitelistingResult) {
+    status = StatusEnum.PASSED;
+    variationString = whitelistingResult.variation.key;
+  } else {
+    status = StatusEnum.FAILED;
+    variationString = '';
+  }
+  LogManager.Instance.info(
+    `SEGMENTATION_STATUS: User ID:${context.user.id} for Campaign:${campaignKey} with variables:${JSON.stringify(context.user.variationTargetingVariables)} ${status} whitelisting ${variationString}`,
+  );
+  return whitelistingResult;
+};
+
+const _evaluateWhitelisting = async (
+  campaign: CampaignModel,
+  campaignKey: string,
+  settings: SettingsModel,
+  context: any,
+): Promise<any> => {
+  let whitelistedVariation;
+  let status;
+  const targetedVariations = [];
+  const promises: Promise<any>[] = [];
+  campaign.getVariations().forEach((variation) => {
+    if (isObject(variation.getSegments()) && !Object.keys(variation.getSegments()).length) {
+      LogManager.Instance.debug(
+        `SEGMENTATION_SKIPPED: Segmentation is not used for Campaign:${campaignKey}, hence skipping evaluating segmentation ${variation} for User ID:${context.user.id}`,
+      );
+      return;
+    }
+    // check for segmentation and evaluate
+    if (isObject(variation.getSegments())) {
+      const SegmentEvaluatorResult = SegmentationManager.Instance.validateSegmentation(
+        variation.getSegments(),
+        context.user.variationTargetingVariables,
+        settings,
+      );
+      const promise = isPromise(SegmentEvaluatorResult)
+        ? SegmentEvaluatorResult.then((evaluationResult) => {
+            if (evaluationResult) {
+              status = StatusEnum.PASSED;
+              targetedVariations.push(cloneObject(variation));
+            } else {
+              status = StatusEnum.FAILED;
+            }
+          })
+        : Promise.resolve(SegmentEvaluatorResult).then((evaluationResult) => {
+            if (evaluationResult) {
+              status = StatusEnum.PASSED;
+              targetedVariations.push(cloneObject(variation));
+            } else {
+              status = StatusEnum.FAILED;
+            }
+          });
+      promises.push(promise);
+    } else {
+      status = StatusEnum.FAILED;
+    }
+  });
+
+  // Wait for all promises to resolve
+  await Promise.all(promises);
+  if (targetedVariations.length > 1) {
+    scaleVariationWeights(targetedVariations);
+    for (let i = 0, currentAllocation = 0, stepFactor = 0; i < targetedVariations.length; i++) {
+      stepFactor = assignRangeValues(targetedVariations[i], currentAllocation);
+      currentAllocation += stepFactor;
+    }
+    whitelistedVariation = new CampaignDecisionService().getVariation(
+      targetedVariations,
+      new DecisionMaker().calculateBucketValue(getBucketingSeed(context.user.id, campaign, null)),
+    );
+  } else {
+    whitelistedVariation = targetedVariations[0];
+  }
+
+  if (whitelistedVariation) {
+    return {
+      variation: whitelistedVariation,
+      variationName: whitelistedVariation.name,
+      variationId: whitelistedVariation.id,
+    };
+  }
+};
+
+export const evaluateTrafficAndGetVariation = (
+  settingsFile: any,
+  campaign: CampaignModel,
+  userId: any,
+): VariationModel => {
+  const variation = new CampaignDecisionService().getVariationAlloted(userId, settingsFile.accountId, campaign);
+  if (!variation) {
+    LogManager.Instance.debug(
+      `USER_NOT_BUCKETED: User ID:${userId} for Campaign:${campaign.getKey()} did not get any variation`,
+    );
+    return null;
+  }
+  LogManager.Instance.debug(
+    `USER_BUCKETED: User ID:${userId} for Campaign:${campaign.getKey()} ${variation.getKey() ? `got variation:${variation.getKey()}` : 'did not get any variation'}`,
+  );
+  return variation;
+};

package/lib/utils/FunctionUtil.ts

@@ -0,0 +1,105 @@
+import { CampaignTypeEnum } from '../enums/campaignTypeEnum';
+import { SettingsModel } from '../models/SettingsModel';
+import { dynamic } from '../types/common';
+import { isString } from './DataTypeUtil';
+
+export function cloneObject(obj: dynamic): any {
+  if (!obj) {
+    return obj;
+  }
+  const clonedObj = JSON.parse(JSON.stringify(obj));
+  return clonedObj;
+}
+
+export function getCurrentUnixTimestamp(): number {
+  return Math.ceil(+new Date() / 1000);
+}
+
+export function getCurrentUnixTimestampInMillis(): number {
+  return +new Date();
+}
+
+export function getRandomNumber(): number {
+  return Math.random();
+}
+
+export function getSpecificRulesBasedOnType(settings, featureKey, type = null) {
+  let feature = getFeatureFromKey(settings, featureKey);
+  if (feature && !feature.rulesLinkedCampaign) {
+    return [];
+  }
+
+  if (feature && feature.rulesLinkedCampaign && type && isString(type)) {
+    return feature.rulesLinkedCampaign.filter((rule) => rule.type === type);
+  }
+
+  return feature.rulesLinkedCampaign;
+}
+
+export function getAllAbAndPersonaliseRules(settings, featureKey) {
+  let feature = getFeatureFromKey(settings, featureKey);
+  return feature.rulesLinkedCampaign.filter(
+    (rule) => rule.type === CampaignTypeEnum.AB || rule.type === CampaignTypeEnum.PERSONALIZE,
+  );
+}
+
+export function getFeatureFromKey(settings, featureKey) {
+  return settings?.features?.find((feature) => feature.key === featureKey);
+}
+
+export function eventExists(eventName: string, settings: any): boolean {
+  for (const feature of settings.features) {
+    for (const metric of feature.metrics) {
+      if (metric.identifier === eventName) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+export function addLInkedCampaignsToSettings(settingsFile: any): void {
+  // loop over all features
+  for (const feature of settingsFile.features) {
+    const { rules } = feature;
+    const campaigns = settingsFile.campaigns;
+    const rulesLinkedCampaign = [];
+
+    // loop over all rules of a feature
+    for (const rule of rules) {
+      const { campaignId, variationId } = rule;
+      if (campaignId) {
+        // find the campaign with the given campaignId
+        const campaign = campaigns.find((c) => c.id === campaignId);
+        if (campaign) {
+          // create a linked campaign object with the rule and campaign
+          const linkedCampaign = { key: campaign.key, ...rule, ...campaign };
+
+          if (variationId) {
+            // find the variation with the given variationId
+            const variation = campaign.variations.find((v) => v.id === variationId);
+            if (variation) {
+              // add the variation to the linked campaign
+              linkedCampaign.variations = [variation];
+            }
+          }
+          // add the linked campaign to the rulesLinkedCampaign array
+          rulesLinkedCampaign.push(linkedCampaign);
+        }
+      }
+    }
+    feature.rulesLinkedCampaign = rulesLinkedCampaign;
+  }
+}
+
+// get feature name from feature key using settings
+export function getFeatureNameFromKey(settings: SettingsModel, featureKey: string): string {
+  const feature = settings.getFeatures().find((f) => f.getKey() === featureKey);
+  return feature ? feature.getName() : '';
+}
+
+// get feature id from feature key using settings
+export function getFeatureIdFromKey(settings: SettingsModel, featureKey: string): number {
+  const feature = settings.getFeatures().find((f) => f.getKey() === featureKey);
+  return feature ? feature.getId() : null;
+}

package/lib/utils/LogMessageUtil.ts

@@ -0,0 +1,52 @@
+/**
+ * Copyright 2019-2020 Wingify Software Pvt. Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { isNull, isUndefined, isFunction } from '../utils/DataTypeUtil';
+
+const nargs = /\{([0-9a-zA-Z_]+)\}/g;
+
+export function buildMessage(template: string, data: Record<string, any>): string {
+  try {
+    return template.replace(nargs, (match, key, index) => {
+      let result;
+      let isKey;
+
+      if (template[index - 1] === '{' && template[index + match.length] === '}') {
+        return key;
+      } else {
+        isKey = Object.prototype.hasOwnProperty.call(data, key);
+
+        if (isKey) {
+          let value = data[key];
+
+          if (isFunction(value)) {
+            value = data[key]();
+          }
+          result = value;
+        } else {
+          result = null;
+        }
+        if (isNull(result) || isUndefined(result)) {
+          return '';
+        }
+
+        return result;
+      }
+    });
+  } catch (err) {
+    return template;
+  }
+}