vwo-fme-node-sdk 1.0.0

package/lib/services/CampaignDecisionService.ts

@@ -0,0 +1,160 @@
+import { DecisionMaker } from '../modules/decision-maker';
+import { LogManager } from '../modules/logger';
+import { SegmentationManager } from '../modules/segmentor';
+
+import { VariationModel } from '../models/VariationModel';
+// import { Campaign } from '../adapters/campaign';
+import { Constants } from '../constants';
+
+import { isObject } from '../utils/DataTypeUtil';
+import { CampaignModel } from '../models/CampaignModel';
+import { CampaignTypeEnum } from '../enums/campaignTypeEnum';
+import { SettingsModel } from '../models/SettingsModel';
+
+interface ICampaignDecisionService {
+  isUserPartOfCampaign(userId: any, campaign: CampaignModel): boolean;
+  getVariation(variations: Array<VariationModel>, bucketValue: number): VariationModel;
+  checkInRange(variation: VariationModel, bucketValue: number): VariationModel;
+  bucketUserToVariation(userId: any, accountId: any, campaign: CampaignModel): VariationModel;
+  getDecision(campaign: CampaignModel, settings: SettingsModel, dsl: any, properties: any): Promise<any>;
+  getVariationAlloted(userId: any, accountId: any, campaign: CampaignModel): VariationModel;
+}
+
+export class CampaignDecisionService implements ICampaignDecisionService {
+  /**
+   * Calculate if this user should become part of the campaign or not
+   *
+   * @param {String} userId the unique ID assigned to a user
+   * @param {Object} campaign fot getting the value of traffic allotted to the campaign
+   *
+   * @return {Boolean} if User is a part of Campaign or not
+   */
+  isUserPartOfCampaign(userId: any, campaign: CampaignModel): boolean {
+    // if (!ValidateUtil.isValidValue(userId) || !campaign) {
+    //   return false;
+    // }
+
+    if (!campaign || !userId) {
+      return false;
+    }
+    let trafficAllocation;
+    if (campaign.getType() === CampaignTypeEnum.ROLLOUT || campaign.getType() === CampaignTypeEnum.PERSONALIZE) {
+      trafficAllocation = campaign.getVariations()[0].getWeight();
+    } else {
+      trafficAllocation = campaign.getTraffic();
+    }
+    const valueAssignedToUser = new DecisionMaker().getBucketValueForUser(`${campaign.getId()}_${userId}`);
+    const isUserPart = valueAssignedToUser !== 0 && valueAssignedToUser <= trafficAllocation;
+
+    LogManager.Instance.debug(`user:${userId} part of campaign ${campaign.getKey()} ? ${isUserPart}`);
+
+    return isUserPart;
+  }
+
+  /**
+   * Returns the Variation by checking the Start and End Bucket Allocations of each Variation
+   *
+   * @param {Object} campaign which contains the variations
+   * @param {Number} bucketValue the bucket Value of the user
+   *
+   * @return {Object|null} variation data allotted to the user or null if not
+   */
+  getVariation(variations: Array<VariationModel>, bucketValue: number): VariationModel {
+    for (let i = 0; i < variations.length; i++) {
+      const variation = variations[i];
+      if (bucketValue >= variation.getStartRangeVariation() && bucketValue <= variation.getEndRangeVariation()) {
+        return variation;
+      }
+    }
+
+    return null;
+  }
+
+  checkInRange(variation: VariationModel, bucketValue: number): VariationModel {
+    if (bucketValue >= variation.getStartRangeVariation() && bucketValue <= variation.getEndRangeVariation()) {
+      return variation;
+    }
+  }
+
+  /**
+   * Validates the User ID and generates Variation into which the User is bucketed in.
+   *
+   * @param {String} userId the unique ID assigned to User
+   * @param {Object} campaign the Campaign of which User is a part of
+   *
+   * @return {Object|null} variation data into which user is bucketed in or null if not
+   */
+  bucketUserToVariation(userId: any, accountId: any, campaign: CampaignModel): VariationModel {
+    let multiplier;
+    // if (!ValidateUtil.isValidValue(userId)) {
+    //   return null;
+    // }
+
+    if (!campaign || !userId) {
+      return null;
+    }
+    if (campaign.getTraffic()) {
+      multiplier = 1;
+    }
+    const percentTraffic = campaign.getTraffic();
+    const hashValue = new DecisionMaker().generateHashValue(`${campaign.getId()}_${accountId}_${userId}`);
+    const bucketValue = new DecisionMaker().generateBucketValue(hashValue, Constants.MAX_TRAFFIC_VALUE, multiplier);
+    LogManager.Instance.debug(
+      `user:${userId} for campaign:${campaign.getKey()} having percenttraffic:${percentTraffic} got bucketValue as ${bucketValue} and hashvalue:${hashValue}`,
+    );
+
+    return this.getVariation(campaign.getVariations(), bucketValue);
+  }
+
+  async getDecision(campaign: CampaignModel, settings: SettingsModel, context: any): Promise<any> {
+    // validate segmentation
+    let segments = {};
+    if (campaign.getType() === CampaignTypeEnum.ROLLOUT || campaign.getType() === CampaignTypeEnum.PERSONALIZE) {
+      segments = campaign.getVariations()[0].getSegments();
+    } else if (campaign.getType() === CampaignTypeEnum.AB) {
+      segments = campaign.getSegments();
+    }
+    if (isObject(segments) && !Object.keys(segments).length) {
+      LogManager.Instance.debug(
+        `For userId:${
+          context.user.id
+        } of Campaign:${campaign.getKey()}, segment was missing, hence skipping segmentation`,
+      );
+      return true;
+    } else {
+      const preSegmentationResult = await SegmentationManager.Instance.validateSegmentation(
+        segments,
+        context.user.customVariables,
+        settings,
+        context.user,
+        // {
+        //   ipAddress: context.user.ipAddress,
+        //   userAgent : context.user.userAgent
+        // }
+      );
+      if (!preSegmentationResult) {
+        LogManager.Instance.info(`Segmentation failed for userId:${context.user.id} of Campaign:${campaign.getKey()}`);
+        return false;
+      }
+      LogManager.Instance.info(`Segmentation passed for userId:${context.user.id} of Campaign:${campaign.getKey()}`);
+      return true;
+    }
+  }
+
+  getVariationAlloted(userId: any, accountId: any, campaign: CampaignModel): VariationModel {
+    const isUserPart = this.isUserPartOfCampaign(userId, campaign);
+    if (campaign.getType() === CampaignTypeEnum.ROLLOUT || campaign.getType() === CampaignTypeEnum.PERSONALIZE) {
+      if (isUserPart) {
+        return campaign.getVariations()[0];
+      } else {
+        return null;
+      }
+    } else {
+      if (isUserPart) {
+        return this.bucketUserToVariation(userId, accountId, campaign);
+      } else {
+        return null;
+      }
+    }
+  }
+}

package/lib/services/HooksManager.ts

@@ -0,0 +1,50 @@
+import { dynamic } from '../types/common';
+import { isFunction } from '../utils/DataTypeUtil';
+
+interface Options {
+  integrations?: {
+    callback?: (properties: Record<string, any>) => void;
+  };
+}
+
+class HooksManager {
+  private callback: ((properties: Record<string, any>) => void) | undefined;
+  private isCallBackFunction: boolean;
+  private decision: Record<string, any>;
+
+  constructor(options: Options = {}) {
+    this.callback = options.integrations?.callback;
+    this.isCallBackFunction = isFunction(this.callback);
+    this.decision = {};
+  }
+
+  /**
+   * Executes the callback
+   * @param {Record<string, any>} properties Properties from the callback
+   */
+  execute(properties: Record<string, any>): void {
+    if (this.isCallBackFunction) {
+      this.callback(properties);
+    }
+  }
+
+  /**
+   * Sets properties to the decision object
+   * @param {Record<string, any>} properties Properties to set
+   */
+  set(properties: Record<string, any>): void {
+    if (this.isCallBackFunction) {
+      this.decision = properties;
+    }
+  }
+
+  /**
+   * Retrieves the decision object
+   * @returns {Record<string, any>} The decision object
+   */
+  get(): Record<string, any> {
+    return this.decision;
+  }
+}
+
+export default HooksManager;

package/lib/services/SettingsManager.ts

@@ -0,0 +1,167 @@
+import { dynamic } from '../types/common';
+
+import { Storage } from '../modules/storage';
+import { NetworkManager, RequestModel, ResponseModel } from '../modules/networking';
+import { LogManager } from '../modules/logger';
+
+import { isObject } from '../utils/DataTypeUtil';
+import { Deferred } from '../utils/PromiseUtil';
+
+import { Constants } from '../constants';
+import { NetworkUtil } from '../utils/NetworkUtil';
+import { setVariationAllocation } from '../utils/CampaignUtil';
+import { CampaignModel } from '../models/CampaignModel';
+import { SettingsModel } from '../models/SettingsModel';
+import UrlService from './UrlService';
+
+export class SettingsManager implements ISettingsManager {
+  sdkKey: string;
+  accountId: any;
+  expiry: number;
+  networkTimeout: number;
+  settingsFileUrl: string;
+  settingsFilePort: number;
+
+  constructor(options: Record<string, any>) {
+    this.sdkKey = options.sdkKey;
+    this.accountId = options.accountId;
+    this.expiry = options?.settings?.expiry || Constants.SETTINGS_EXPIRY;
+    this.networkTimeout = options?.settings?.timeout || Constants.SETTINGS_TIMEOUT;
+
+    if (options?.webService?.url) {
+      const parsedUrl = new URL(`https://${options.webService.url}`);
+      this.settingsFileUrl = parsedUrl.hostname;
+      this.settingsFilePort = parseInt(parsedUrl.port);
+    } else {
+      this.settingsFileUrl = Constants.HOST_NAME;
+    }
+
+    // if (this.expiry > 0) {
+    //   this.setSettingsExpiry();
+    // }
+  }
+
+  private setSettingsExpiry() {
+    const settingsTimeout = setTimeout(() => {
+      this.fetchSettingsAndCacheInStorage(true).then(() => {
+        clearTimeout(settingsTimeout);
+        // again set the timer
+        // NOTE: setInterval could be used but it will not consider the time required to fetch settings
+        // This breaks the timer rythm and also sends more call than required
+        this.setSettingsExpiry();
+      });
+    }, this.expiry);
+  }
+
+  private fetchSettingsAndCacheInStorage(update = false) {
+    const deferredObject = new Deferred();
+    // const storageConnector = Storage.Instance.getConnector();
+
+    this.fetchSettings()
+      .then(async (res) => {
+        LogManager.Instance.info('Settings fetched successfully');
+
+        // const method = update ? 'update' : 'set';
+
+        // storageConnector[method](Constants.SETTINGS, res).then(() => {
+        //   LogManager.Instance.info('Settings persisted in cache: memory');
+        //   deferredObject.resolve(res);
+        // });
+        deferredObject.resolve(res);
+      })
+      .catch((err) => {
+        LogManager.Instance.error(`Settings could not be fetched: ${err}`);
+        deferredObject.resolve(null);
+      });
+
+    return deferredObject.promise;
+  }
+
+  fetchSettings(): Promise<SettingsModel> {
+    const deferredObject = new Deferred();
+
+    if (!this.sdkKey || !this.accountId) {
+      // console.error('AccountId and sdkKey are required for fetching account settings. Aborting!');
+      LogManager.Instance.error('sdkKey is required for fetching account settings. Aborting!');
+      deferredObject.reject(new Error('sdkKey is required for fetching account settings. Aborting!'));
+    }
+
+    const networkInstance = NetworkManager.Instance;
+    const options: Record<string, dynamic> = new NetworkUtil().getSettingsPath(this.sdkKey, this.accountId);
+    options.platform = 'server';
+    options['api-version'] = 1;
+    if (!networkInstance.getConfig().getDevelopmentMode()) {
+      options.s = 'prod';
+    }
+    try {
+      const request: RequestModel = new RequestModel(
+        this.settingsFileUrl,
+        'GET',
+        Constants.SETTINTS_ENDPOINT,
+        options,
+        null,
+        null,
+        null,
+        this.settingsFilePort,
+      );
+      request.setTimeout(this.networkTimeout);
+
+      networkInstance
+        .get(request)
+        .then((response: ResponseModel) => {
+          deferredObject.resolve(response.getData());
+        })
+        .catch((err: ResponseModel) => {
+          deferredObject.reject(err);
+        });
+
+      return deferredObject.promise;
+    } catch (err) {
+      console.error('Error occurred while fetching settings:', err);
+      deferredObject.reject(err);
+      return deferredObject.promise;
+    }
+  }
+
+  getSettings(forceFetch = false): Promise<SettingsModel> {
+    const deferredObject = new Deferred();
+
+    if (forceFetch) {
+      this.fetchSettingsAndCacheInStorage().then((settings) => {
+        deferredObject.resolve(settings);
+      });
+    } else {
+      this.fetchSettingsAndCacheInStorage().then((fetchedSettings) => {
+        deferredObject.resolve(fetchedSettings);
+      });
+      // const storageConnector = Storage.Instance.getConnector();
+
+      // storageConnector
+      //   .get(Constants.SETTINGS)
+      //   .then((storedSettings: dynamic) => {
+      //     if (!isObject(storedSettings)) {
+      //       this.fetchSettingsAndCacheInStorage().then((fetchedSettings) => {
+      //         deferredObject.resolve(fetchedSettings);
+      //       });
+      //     } else {
+      //       deferredObject.resolve(storedSettings);
+      //     }
+      //   })
+      //   .catch(() => {
+      //     this.fetchSettingsAndCacheInStorage().then((fetchedSettings) => {
+      //       deferredObject.resolve(fetchedSettings);
+      //     });
+      //   });
+    }
+
+    return deferredObject.promise;
+  }
+}
+
+interface ISettingsManager {
+  sdkKey: string;
+
+  getSettings(forceFetch: boolean): Promise<dynamic>;
+
+  fetchSettings(): Promise<dynamic>;
+}

package/lib/services/StorageService.ts

@@ -0,0 +1,53 @@
+import { dynamic } from '../types/common';
+import { Storage } from '../modules/storage';
+import { FeatureModel } from '../models/FeatureModel';
+import { StorageEnum } from '../enums/StorageEnum';
+
+import { Deferred } from '../utils/PromiseUtil';
+import { isUndefined, isNull } from '../utils/DataTypeUtil';
+
+export class StorageService {
+  private storageData: Record<string, dynamic> = {};
+
+  async getDataInStorage(featureKey: any, user: any): Promise<Record<any, any>> {
+    const deferredObject = new Deferred();
+    const storageInstance = Storage.Instance.getConnector();
+
+    if (isNull(storageInstance) || isUndefined(storageInstance)) {
+      deferredObject.resolve(StorageEnum.STORAGE_UNDEFINED);
+    } else {
+      storageInstance
+        .get(featureKey, user.id)
+        .then((data: Record<string, any>) => {
+          deferredObject.resolve(data);
+        })
+        .catch((err) => {
+          console.log('Error in getting data from storage', err);
+          // TODO:- Add logging here
+          deferredObject.resolve(StorageEnum.NO_DATA_FOUND);
+        });
+    }
+
+    return deferredObject.promise;
+  }
+
+  setDataInStorage(data: Record<any, any>): Promise<void> {
+    const deferredObject = new Deferred();
+
+    const storageInstance = Storage.Instance.getConnector();
+    if (storageInstance === null || storageInstance === undefined) {
+      deferredObject.resolve(false);
+    } else {
+      storageInstance
+        .set(data)
+        .then(() => {
+          deferredObject.resolve(true);
+        })
+        .catch(() => {
+          deferredObject.resolve(false);
+        });
+    }
+
+    return deferredObject.promise;
+  }
+}

package/lib/services/UrlService.ts

@@ -0,0 +1,50 @@
+import { isString } from '../utils/DataTypeUtil';
+import { UrlEnum } from '../enums/UrlEnum';
+
+interface UrlServiceType {
+  collectionPrefix?: string;
+  webServiceUrl?: string;
+  port?: number;
+  init({ collectionPrefix, webServiceUrl }?: { collectionPrefix?: string; webServiceUrl?: string }): UrlServiceType;
+  getBaseUrl(): string;
+  getPort(): number;
+}
+
+const UrlService: UrlServiceType = {
+  init({ collectionPrefix, webServiceUrl }: { collectionPrefix?: string; webServiceUrl?: any } = {}) {
+    if (collectionPrefix && isString(collectionPrefix)) {
+      UrlService.collectionPrefix = collectionPrefix;
+    }
+
+    if (webServiceUrl && isString(webServiceUrl)) {
+      // parse the url
+      const parsedUrl = new URL(`https://${webServiceUrl}`);
+      UrlService.webServiceUrl = parsedUrl.hostname;
+      UrlService.port = parseInt(parsedUrl.port);
+    } else {
+      UrlService.port = 80;
+    }
+
+    return UrlService;
+  },
+
+  getBaseUrl() {
+    const baseUrl: string = UrlEnum.BASE_URL;
+
+    if (UrlService.webServiceUrl) {
+      return UrlService.webServiceUrl;
+    }
+
+    if (UrlService.collectionPrefix) {
+      return `${baseUrl}/${UrlService.collectionPrefix}`;
+    }
+
+    return baseUrl;
+  },
+
+  getPort() {
+    return UrlService.port;
+  },
+};
+
+export default UrlService;

package/lib/types/common.ts

@@ -0,0 +1,13 @@
+export type dynamic =
+  | boolean
+  | number
+  | string
+  | Date
+  | void
+  | undefined
+  | null
+  | Record<string, any>
+  | Array<dynamicArray>
+  | Map<string, dynamicArray>;
+
+export type dynamicArray = boolean | number | string | Record<string, any>;