vwo-fme-node-sdk 1.0.0

package/lib/modules/networking/manager/networkManager.ts

@@ -0,0 +1,77 @@
+import { Deferred } from '../../../utils/PromiseUtil';
+import { GlobalRequestModel } from '../models/globalRequestModel';
+import { NetworkClient } from '../client/networkClient';
+import { RequestModel } from '../models/requestModel';
+import { RequestHandler } from '../handlers/requestHandler';
+import { ResponseModel } from '../models/responseModel';
+import { NetworkClientInterface } from '../client/networkClientInterface';
+
+export class NetworkManager {
+  private config: GlobalRequestModel;
+  private client: NetworkClientInterface;
+  private static instance: NetworkManager;
+
+  attachClient(client?: NetworkClientInterface): void {
+    this.client = client || new NetworkClient();
+    this.config = new GlobalRequestModel(null, null, null, null);
+  }
+
+  static get Instance(): NetworkManager {
+    this.instance = this.instance || new NetworkManager();
+
+    return this.instance;
+  }
+
+  setConfig(config: GlobalRequestModel): void {
+    this.config = config;
+  }
+
+  getConfig(): GlobalRequestModel {
+    return this.config;
+  }
+
+  createRequest(request: RequestModel): RequestModel {
+    const options: RequestModel = new RequestHandler().createRequest(request, this.config);
+    return options;
+  }
+
+  get(request: RequestModel): Promise<ResponseModel> {
+    const deferred = new Deferred();
+
+    const networkOptions: RequestModel = this.createRequest(request);
+    if (networkOptions === null) {
+      deferred.reject(new Error('no url found'));
+    } else {
+      this.client
+        .GET(networkOptions)
+        .then((response: ResponseModel) => {
+          deferred.resolve(response);
+        })
+        .catch((errorResponse: ResponseModel) => {
+          deferred.reject(errorResponse);
+        });
+    }
+
+    return deferred.promise;
+  }
+
+  post(request: RequestModel): Promise<ResponseModel> {
+    const deferred = new Deferred();
+    const networkOptions: RequestModel = this.createRequest(request);
+
+    if (networkOptions === null) {
+      deferred.reject(new Error('no url found'));
+    } else {
+      this.client
+        .POST(networkOptions)
+        .then((response: ResponseModel) => {
+          deferred.resolve(response);
+        })
+        .catch((error: ResponseModel) => {
+          deferred.reject(error);
+        });
+    }
+
+    return deferred.promise;
+  }
+}

package/lib/modules/networking/models/globalRequestModel.ts

@@ -0,0 +1,69 @@
+import { dynamic } from '../../../types/common';
+
+export class GlobalRequestModel {
+  private url: string;
+  private timeout = 3000;
+  private query: Record<string, dynamic>;
+  private body: Record<string, dynamic>;
+  private headers: Record<string, string>;
+  private isDevelopmentMode: boolean;
+
+  constructor(
+    url: string,
+    query: Record<string, dynamic>,
+    body: Record<string, dynamic>,
+    headers: Record<string, any>
+  ) {
+    this.url = url;
+    this.query = query;
+    this.body = body;
+    this.headers = headers;
+  }
+  setQuery(query: Record<string, dynamic>): void {
+    this.query = query;
+  }
+
+  getQuery(): Record<string, dynamic> {
+    return this.query;
+  }
+
+  setBody(body: Record<string, dynamic>): void {
+    this.body = body;
+  }
+
+  getBody(): Record<string, dynamic> {
+    return this.body;
+  }
+
+  setBaseUrl(url: string): void {
+    this.url = url;
+  }
+
+  getBaseUrl(): string {
+    return this.url;
+  }
+
+  setTimeout(timeout: number): void {
+    this.timeout = timeout;
+  }
+
+  getTimeout(): number {
+    return this.timeout;
+  }
+
+  setHeaders(headers: Record<string, string>): void {
+    this.headers = headers;
+  }
+
+  getHeaders(): Record<string, string> {
+    return this.headers;
+  }
+
+  setDevelopmentMode(isDevelopmentMode: boolean): void {
+    this.isDevelopmentMode = isDevelopmentMode;
+  }
+
+  getDevelopmentMode(): boolean {
+    return this.isDevelopmentMode;
+  }
+}

package/lib/modules/networking/models/requestModel.ts

@@ -0,0 +1,164 @@
+import { dynamic } from '../../../types/common';
+
+const HTTP = 'http';
+
+export class RequestModel {
+  private url: string;
+  private method: string;
+  private scheme: string;
+  private port: number;
+  private path: string;
+  private query: Record<string, dynamic>;
+  private timeout: number;
+  private body: Record<string, dynamic>;
+  private headers: Record<string, string>;
+
+  constructor(
+    url: string,
+    method: string = 'GET',
+    path: string,
+    query: Record<string, dynamic>,
+    body: Record<string, dynamic>,
+    headers: Record<string, string>,
+    scheme: string = HTTP,
+    port: number = 80
+  ) {
+    this.url = url;
+    this.path = path;
+    this.query = query;
+    this.body = body;
+    this.headers = headers;
+    this.scheme = scheme;
+    this.port = port;
+    this.method = method;
+  }
+
+  getMethod(): string {
+    return this.method;
+  }
+
+  setMethod(method: string): void {
+    this.method = method;
+  }
+
+  getBody(): Record<string, dynamic> {
+    return this.body;
+  }
+
+  setBody(body: Record<string, dynamic>): void {
+    this.body = body;
+  }
+
+  setQuery(query: Record<string, dynamic>): void {
+    this.query = query;
+  }
+
+  getQuery(): Record<string, dynamic> {
+    return this.query;
+  }
+
+  setHeaders(headers: Record<string, string>): this {
+    this.headers = headers;
+    return this;
+  }
+
+  getHeaders(): Record<string, string> {
+    return this.headers;
+  }
+
+  setTimeout(timeout: number): this {
+    this.timeout = timeout;
+    return this;
+  }
+
+  getTimeout(): number {
+    return this.timeout;
+  }
+
+  getUrl(): string {
+    return this.url;
+  }
+
+  setUrl(host: string): this {
+    this.url = host;
+    return this;
+  }
+
+  getScheme(): string {
+    return this.scheme;
+  }
+
+  setScheme(scheme: string): this {
+    this.scheme = scheme;
+    return this;
+  }
+
+  getPort(): number {
+    return this.port;
+  }
+
+  setPort(port: number): this {
+    this.port = port;
+    return this;
+  }
+
+  getPath(): string {
+    return this.path;
+  }
+
+  setPath(path: string): this {
+    this.path = path;
+    return this;
+  }
+
+  getOptions(): Record<string, any> {
+    let queryParams = '';
+    for (const key in this.query) {
+      const queryString = `${key}=${this.query[key]}&`;
+      queryParams += queryString;
+    }
+    const options: Record<string, any> = {
+      hostname: this.url,
+      agent: false
+    };
+
+    if (this.scheme) {
+      options.scheme = this.scheme;
+    }
+    if (this.port) {
+      options.port = this.port;
+    }
+    if (this.headers) {
+      options.headers = this.headers;
+    }
+
+    if (this.method) {
+      options.method = this.method;
+    }
+
+    if (this.body) {
+      const postBody = JSON.stringify(this.body);
+      options.headers = {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(postBody),
+      };
+      options.body = this.body;
+    }
+
+    if (this.path) {
+      if (queryParams !== '') {
+        options.path = this.path + '?' + queryParams || '';
+      } else {
+        options.path = this.path;
+      }
+    }
+    if (this.timeout) {
+      options.timeout = this.timeout;
+    }
+    if (options.path.charAt(options.path.length - 1) === '&') {
+      options.path = options.path.substring(0, options.path.length - 1);
+    }
+
+    return options;
+  }
+}

package/lib/modules/networking/models/responseModel.ts

@@ -0,0 +1,40 @@
+import { dynamic } from '../../../types/common';
+
+export class ResponseModel {
+  private statusCode: number;
+  private error: dynamic;
+  private headers: Record<string, string>;
+  private data: dynamic;
+
+  setStatusCode(statusCode: number): void {
+    this.statusCode = statusCode;
+  }
+
+  setHeaders(headers: Record<string, string>): void {
+    this.headers = headers;
+  }
+
+  setData(data: dynamic): void {
+    this.data = data;
+  }
+
+  setError(error: dynamic): void {
+    this.error = error;
+  }
+
+  getHeaders(): Record<string, string> {
+    return this.headers;
+  }
+
+  getData(): dynamic {
+    return this.data;
+  }
+
+  getStatusCode(): number {
+    return this.statusCode;
+  }
+
+  getError(): dynamic {
+    return this.error;
+  }
+}

package/lib/modules/segmentor/core/segmentationManger.ts

@@ -0,0 +1,22 @@
+import { SegmentEvaluator } from '../evaluators/segmentEvaluator';
+import { dynamic } from '../../../types/common';
+import { SettingsModel } from '../../../models/SettingsModel';
+
+export class SegmentationManager {
+  private static instance: SegmentationManager;
+  evaluator: SegmentEvaluator;
+
+  static get Instance(): SegmentationManager {
+    this.instance = this.instance || new SegmentationManager();
+
+    return this.instance;
+  }
+
+  attachEvaluator(evaluator?: SegmentEvaluator): void {
+    this.evaluator = evaluator || new SegmentEvaluator();
+  }
+
+  async validateSegmentation(dsl: Record<string, dynamic>, properties: Record<any, dynamic>, settings: SettingsModel, context?:any): Promise<boolean> {
+    return await this.evaluator.isSegmentationValid(dsl, properties, settings, context);
+  }
+}

package/lib/modules/segmentor/enums/segmentOperandRegexEnum.ts

@@ -0,0 +1,10 @@
+export enum SegmentOperandRegexEnum {
+  LOWER = '^lower',
+  LOWER_MATCH = '^lower\\((.*)\\)',
+  WILDCARD = '^wildcard',
+  WILDCARD_MATCH = '^wildcard\\((.*)\\)',
+  REGEX = '^regex',
+  REGEX_MATCH = '^regex\\((.*)\\)',
+  STARTING_STAR = '^\\*',
+  ENDING_STAR = '\\*$'
+}

package/lib/modules/segmentor/enums/segmentOperandValueEnum.ts

@@ -0,0 +1,8 @@
+export enum SegmentOperandValueEnum {
+  LOWER_VALUE = 1,
+  STARTING_ENDING_STAR_VALUE = 2,
+  STARTING_STAR_VALUE = 3,
+  ENDING_STAR_VALUE = 4,
+  REGEX_VALUE = 5,
+  EQUAL_VALUE = 6
+}

package/lib/modules/segmentor/enums/segmentOperatorValueEnum.ts

@@ -0,0 +1,15 @@
+export enum SegmentOperatorValueEnum {
+  AND = 'and',
+  NOT = 'not',
+  OR = 'or',
+  CUSTOM_VARIABLE = 'custom_variable',
+  USER = 'user',
+  COUNTRY = 'country',
+  REGION = 'region',
+  CITY = 'city',
+  OPERATING_SYSTEM = 'os',
+  DEVICE_TYPE = 'device_type',
+  BROWSER_AGENT = 'browser_string',
+  UA = 'ua',
+  FEATURE_ID = 'featureId'
+}

package/lib/modules/segmentor/evaluators/segmentEvaluator.ts

@@ -0,0 +1,239 @@
+import { object } from 'superstruct';
+import { getKeyValue } from '../utils/SegmentUtil';
+import { SegmentOperandEvaluator } from './segmentOperandEvaluator';
+import { SegmentOperatorValueEnum } from '../enums/segmentOperatorValueEnum';
+import { Segmentation } from '../segmentation';
+import { dynamic } from '../../../types/common';
+import { getFromWebService, getQueryParamForLocationPreSegment, getQueryParamForUaParser } from '../../../utils/WebServiceUtil';
+import { UrlEnum } from '../../../enums/UrlEnum';
+import { StorageDecorator } from '../../../decorators/StorageDecorator';
+import { StorageService } from '../../../services/StorageService';
+import { getCampaignVariation, getRolloutVariation } from '../../../utils/CampaignUtil';
+import { VariationModel } from '../../../models/VariationModel';
+import { VariableModel } from '../../../models/VariableModel';
+import { LogManager } from '../../../modules/logger';
+import { Deferred } from '../../../utils/PromiseUtil';
+import { SettingsModel } from '../../../models/SettingsModel';
+import { isObject } from '../../../utils/DataTypeUtil';
+
+export class SegmentEvaluator implements Segmentation {
+  async isSegmentationValid(dsl: Record<string, dynamic>, properties: Record<string, dynamic>, settings: SettingsModel, context?: any): Promise<boolean> {
+    const { key, value } = getKeyValue(dsl);
+    const operator = key;
+    const subDsl = value;
+
+    if (operator === SegmentOperatorValueEnum.NOT) {
+      const result = await this.isSegmentationValid(subDsl, properties, settings, context);
+      return !result;
+    } else if (operator === SegmentOperatorValueEnum.AND) {
+      return await this.every(subDsl, properties, settings, context);
+    } else if (operator === SegmentOperatorValueEnum.OR) {
+      return await this.some(subDsl, properties, settings, context);
+    } else if (operator === SegmentOperatorValueEnum.CUSTOM_VARIABLE) {
+      return await new SegmentOperandEvaluator().evaluateCustomVariableDSL(subDsl, properties);
+    } else if (operator === SegmentOperatorValueEnum.USER) {
+      return new SegmentOperandEvaluator().evaluateUserDSL(subDsl, properties);
+    } else if (operator === SegmentOperatorValueEnum.UA) {
+      return new SegmentOperandEvaluator().evaluateUserAgentDSL(subDsl, context);
+    }
+    return false;
+  }
+
+  async some(dslNodes: Array<Record<string, dynamic>>, customVariables: Record<string, dynamic>, settings: SettingsModel, context: any): Promise<boolean> {
+    let uaParserMap: Record<string, string[]> = {};
+    let keyCount: number = 0; // Initialize count of keys encountered
+    let isUaParser = false;
+    for (const dsl of dslNodes) {
+      for (const key in dsl) {
+        if (key === SegmentOperatorValueEnum.OPERATING_SYSTEM || key === SegmentOperatorValueEnum.BROWSER_AGENT || key === SegmentOperatorValueEnum.DEVICE_TYPE) {
+          isUaParser = true;
+          const value = dsl[key];
+
+          if (!uaParserMap[key]) {
+            uaParserMap[key] = [];
+          }
+
+          // Ensure value is treated as an array of strings
+          const valuesArray = Array.isArray(value) ? value : [value];
+
+          // Push each value from valueArray to uaParserMap[key]
+          valuesArray.forEach((val: dynamic) => {
+            if (typeof val === "string") {
+              uaParserMap[key].push(val);
+            }
+          });
+
+          keyCount++; // Increment count of keys encountered
+        }
+
+        if (key === SegmentOperatorValueEnum.FEATURE_ID) {
+          const featureIdObject = dsl[key] as Record<string, string>; // Type assertion to specify the shape of the object
+          const featureIdKey: string = Object.keys(featureIdObject)[0]; // Extract the key '4'
+          const featureIdValue: string = featureIdObject[featureIdKey]; // Extract the value 'on'
+
+
+          if (featureIdValue === 'on') {
+            
+            const features = settings.getFeatures(); // Access features using the getter method
+            const feature = features.find(feature => feature.getId() === parseInt(featureIdKey)); // Find feature by featureIdKey
+
+            if (feature) {
+                const featureKey = feature.getKey(); // Get the key of the found feature
+                const result = await this.checkInUserStorage(settings, featureKey, context);
+                return result;
+            } else {
+                console.error("Feature not found with featureIdKey:", featureIdKey);
+                return null; // Handle the case when feature is not found
+            }
+          }
+        }
+      }
+
+      // Check if the count of keys encountered is equal to dslNodes.length
+      if (isUaParser && keyCount === dslNodes.length) {
+        try {
+          const uaParserResult = await this.checkUserAgentParser(uaParserMap, context.userAgent);
+          return uaParserResult;
+        }
+        catch (err) {
+          console.log(err);
+        }
+      }
+
+      if (await this.isSegmentationValid(dsl, customVariables, settings, context)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  async every(dslNodes: Array<Record<string, dynamic>>, customVariables: Record<string, dynamic>, settings: SettingsModel, context: any): Promise<boolean> {
+    let locationMap: Record<string, dynamic> = {};
+    for (const dsl of dslNodes) {
+      if (dsl.hasOwnProperty(SegmentOperatorValueEnum.COUNTRY) || dsl.hasOwnProperty(SegmentOperatorValueEnum.REGION) || dsl.hasOwnProperty(SegmentOperatorValueEnum.CITY)) {
+        this.addLocationValuesToMap(dsl, locationMap);
+        // check if location map size is equal to dslNodes size
+        if (Object.keys(locationMap).length === dslNodes.length) {
+          if (!context.ipAddress || context.ipAddress === undefined){
+            LogManager.Instance.info('To evaluate location pre Segment, please pass ipAddress in context.user object');
+            return false;
+          }
+          const segmentResult = await this.checkLocationPreSegmentation(locationMap, context.ipAddress || '0.0.0.0');
+          return segmentResult;
+        }
+        continue;
+      }
+      const res = await this.isSegmentationValid(dsl, customVariables, settings, context);
+      if (!res) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  addLocationValuesToMap(dsl: Record<string, dynamic>, locationMap: Record<string, dynamic>): void {
+    if (dsl.hasOwnProperty(SegmentOperatorValueEnum.COUNTRY)) {
+      locationMap[SegmentOperatorValueEnum.COUNTRY] = dsl[SegmentOperatorValueEnum.COUNTRY];
+    }
+    if (dsl.hasOwnProperty(SegmentOperatorValueEnum.REGION)) {
+      locationMap[SegmentOperatorValueEnum.REGION] = dsl[SegmentOperatorValueEnum.REGION];
+    }
+    if (dsl.hasOwnProperty(SegmentOperatorValueEnum.CITY)) {
+      locationMap[SegmentOperatorValueEnum.CITY] = dsl[SegmentOperatorValueEnum.CITY];
+    }
+  }
+
+  async checkLocationPreSegmentation(locationMap: Record<string, dynamic>, ipAddress: string): Promise<boolean> {
+    const queryParams = getQueryParamForLocationPreSegment(ipAddress);
+    const userLocation = await getFromWebService(queryParams, UrlEnum.LOCATION_CHECK);
+    if (!userLocation || userLocation === undefined || userLocation === 'false' || userLocation.status === 0) {
+      return false;
+    }
+    return this.valuesMatch(locationMap, userLocation.location);
+  }
+
+  async checkUserAgentParser(uaParserMap: Record<string, string[]>, userAgent: string): Promise<boolean> {
+    const queryParams = getQueryParamForUaParser(userAgent);
+    if (!userAgent || userAgent === undefined){
+      LogManager.Instance.info('To evaluate user agent related segments, please pass userAgent in context object');
+      return false;
+    }
+    const uaParser = await getFromWebService(queryParams, UrlEnum.UAPARSER);
+    if (!uaParser || uaParser === undefined || uaParser === 'false' || uaParser.status === 0) {
+      return false;
+    }
+
+    return this.checkValuePresent(uaParserMap, uaParser);
+  }
+
+  async checkInUserStorage( settings: SettingsModel, featureKey: string, user: any): Promise<any> {
+    const storageService = new StorageService();
+    const storedData: Record<any, any> = await new StorageDecorator().getFeatureFromStorage(featureKey, user, storageService);
+
+    //check only in userStorage
+    if(isObject(storedData) && Object.keys(storedData).length > 0) {
+      return true;
+    }
+    else {
+      return false;
+    }
+  }
+
+  async checkValuePresent(expectedMap: Record<string, string[]>, actualMap: Record<string, string>): Promise<boolean> {
+    for (const key in actualMap) {
+      if (Object.prototype.hasOwnProperty.call(expectedMap, key)) {
+        const expectedValues = expectedMap[key];
+        const actualValue = actualMap[key];
+
+        if (key === SegmentOperatorValueEnum.DEVICE_TYPE) {
+          const wildcardPatterns = expectedValues.filter(val => val.startsWith('wildcard(') && val.endsWith(')'));
+          if (wildcardPatterns.length > 0) {
+            // If any wildcard pattern matches, return true
+            if (wildcardPatterns.some(pattern => {
+              const wildcardPattern = pattern.slice(9, -1); // Extract pattern from wildcard string
+              const regex = new RegExp(wildcardPattern.replace(/\*/g, '.*')); // Convert wildcard pattern to regex
+              return regex.test(actualValue);
+            })) {
+              continue; // Value matches, continue to next key
+            } else {
+              return false; // No wildcard pattern matched, return false
+            }
+          }
+        } else {
+          if (expectedValues.includes(actualValue)) {
+            continue; // Value found, continue to next key
+          } else {
+            return false; // Value not found, return false
+          }
+        }
+      }
+    }
+    return true; // All keys checked and values found, return true
+  }
+
+
+  async valuesMatch(expectedLocationMap, userLocation) {
+    for (let [key, value] of Object.entries(expectedLocationMap)) {
+      if (userLocation.hasOwnProperty(key)) {
+        let normalizedValue1 = this.normalizeValue(value);
+        let normalizedValue2 = this.normalizeValue(userLocation[key]);
+        if (normalizedValue1 !== normalizedValue2) {
+          return false;
+        }
+      } else {
+        return false;
+      }
+    }
+    // If all values match, return true
+    return true;
+  }
+
+  normalizeValue(value) {
+    if (value === null || value === undefined) {
+      return null;
+    }
+    return value.toString().replace(/^"|"$/g, "").trim();
+  }
+
+
+}