vwo-fme-node-sdk 1.0.0

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

@@ -0,0 +1,199 @@
+import { getKeyValue, matchWithRegex } from '../utils/SegmentUtil';
+import { SegmentOperandValueEnum } from '../enums/segmentOperandValueEnum';
+import { SegmentOperandRegexEnum } from '../enums/segmentOperandRegexEnum';
+import { isBoolean } from '../../../utils/DataTypeUtil';
+import { dynamic } from '../../../types/common';
+import { getFromWebService } from '../../../utils/WebServiceUtil';
+import { UrlEnum } from '../../../enums/UrlEnum';
+import { LogManager } from '../../../modules/logger';
+
+export class SegmentOperandEvaluator {
+  async evaluateCustomVariableDSL(dslOperandValue: Record<string, dynamic>, properties: Record<string, dynamic>): Promise <boolean> {
+    const { key, value } = getKeyValue(dslOperandValue);
+    const operandKey = key;
+    const operand = value;
+    if (!Object.prototype.hasOwnProperty.call(properties, operandKey)) {
+      return false;
+    }
+
+    if (operand.includes('inlist')) {
+      const listIdRegex = /inlist\((\w+:\d+)\)/;
+      const match = operand.match(listIdRegex);
+      if (!match || match.length < 2) {
+        console.error("Invalid 'inList' operand format");
+        return false;
+      }
+
+      const tagValue = properties[operandKey];
+      const attributeValue = this.preProcessTagValue(tagValue);
+
+      const listId = match[1];
+      const queryParamsObj = {
+        attribute: attributeValue,
+        listId: listId
+      };
+      
+      try {
+        const res = await getFromWebService(queryParamsObj, UrlEnum.ATTRIBUTE_CHECK);
+        if (!res || res === undefined || res === 'false' || res.status === 0) {
+          return false;
+        }
+        return res;
+      } catch (error) {
+        console.error("Error while fetching data:", error);
+        return false;
+      } 
+    } else {
+      let tagValue = properties[operandKey];
+      tagValue = this.preProcessTagValue(tagValue);
+      const { operandType, operandValue } = this.preProcessOperandValue(operand);
+      const processedValues = this.processValues(operandValue, tagValue);
+      tagValue = processedValues.tagValue;
+      return this.extractResult(operandType, processedValues.operandValue, tagValue);
+    }
+  }
+
+  evaluateUserDSL(dslOperandValue: Record<string, any>, properties: Record<string, dynamic>): boolean {
+    const users = dslOperandValue.split(',');
+    for (let i = 0; i < users.length; i++) {
+      if (users[i].trim() == properties._vwoUserId) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  evaluateUserAgentDSL(dslOperandValue: Record<string, any>, context: any): boolean {
+    const operand = dslOperandValue;
+    if (!context.userAgent || context.userAgent === undefined) {
+      LogManager.Instance.info('To Evaluate UserAgent segmentation, please provide userAgent in context');
+      return false;
+    }
+    let tagValue = decodeURIComponent(context.userAgent);
+    const { operandType, operandValue } = this.preProcessOperandValue(operand);
+    const processedValues = this.processValues(operandValue, tagValue);
+    tagValue = processedValues.tagValue as string; // Fix: Type assertion to ensure tagValue is of type string
+    return this.extractResult(operandType, processedValues.operandValue, tagValue);
+  }
+
+  preProcessTagValue(tagValue: any): string | boolean {
+    if (tagValue === undefined) {
+      tagValue = '';
+    }
+    if (isBoolean(tagValue)) {
+      if (tagValue) {
+        tagValue = true;
+      } else {
+        tagValue = false;
+      }
+    }
+    if (tagValue !== null) {
+      tagValue = tagValue.toString();
+    }
+    return tagValue;
+  }
+
+  preProcessOperandValue(operand: any): Record<string, any> {
+    let operandType: SegmentOperandValueEnum;
+    let operandValue: dynamic;
+    // Pre process operand value
+    if (matchWithRegex(operand, SegmentOperandRegexEnum.LOWER_MATCH)) {
+      operandType = SegmentOperandValueEnum.LOWER_VALUE;
+      operandValue = this.extractOperandValue(operand, SegmentOperandRegexEnum.LOWER_MATCH);
+    } else if (matchWithRegex(operand, SegmentOperandRegexEnum.WILDCARD_MATCH)) {
+      operandValue = this.extractOperandValue(operand, SegmentOperandRegexEnum.WILDCARD_MATCH);
+      const startingStar = matchWithRegex(operandValue, SegmentOperandRegexEnum.STARTING_STAR);
+      const endingStar = matchWithRegex(operandValue, SegmentOperandRegexEnum.ENDING_STAR);
+      // In case of wildcard, the operand type is further divided into contains, startswith and endswith
+      if (startingStar && endingStar) {
+        operandType = SegmentOperandValueEnum.STARTING_ENDING_STAR_VALUE;
+      } else if (startingStar) {
+        operandType = SegmentOperandValueEnum.STARTING_STAR_VALUE;
+      } else if (endingStar) {
+        operandType = SegmentOperandValueEnum.ENDING_STAR_VALUE;
+      }
+      operandValue = operandValue
+        .replace(new RegExp(SegmentOperandRegexEnum.STARTING_STAR), '')
+        .replace(new RegExp(SegmentOperandRegexEnum.ENDING_STAR), '');
+    } else if (matchWithRegex(operand, SegmentOperandRegexEnum.REGEX_MATCH)) {
+      operandType = SegmentOperandValueEnum.REGEX_VALUE;
+      operandValue = this.extractOperandValue(operand, SegmentOperandRegexEnum.REGEX_MATCH);
+    } else {
+      operandType = SegmentOperandValueEnum.EQUAL_VALUE;
+      operandValue = operand;
+    }
+    return {
+      operandType,
+      operandValue
+    };
+  }
+
+  extractOperandValue(operand: any, regex: string): string {
+    return matchWithRegex(operand, regex) && matchWithRegex(operand, regex)[1];
+  }
+
+  processValues(operandValue: any, tagValue: any): Record<string, dynamic> {
+    // this is atomic, either both will be processed or none
+    const processedOperandValue = parseFloat(operandValue);
+    const processedTagValue = parseFloat(tagValue);
+    if (!processedOperandValue || !processedTagValue) {
+      return {
+        operandValue: operandValue,
+        tagValue: tagValue
+      };
+    }
+    // // now we have surity that both are numbers
+    // // now we can convert them independently to int type if they
+    // // are int rather than floats
+    // if (processedOperandValue === Math.floor(processedOperandValue)) {
+    //   processedOperandValue = parseInt(processedOperandValue, 10);
+    // }
+    // if (processedTagValue === Math.floor(processedTagValue)) {
+    //   processedTagValue = parseInt(processedTagValue, 10);
+    // }
+    // convert it back to string and return
+    return {
+      operandValue: processedOperandValue.toString(),
+      tagValue: processedTagValue.toString()
+    };
+  }
+
+  extractResult(operandType: SegmentOperandValueEnum, operandValue: any, tagValue: any): boolean {
+    let result: boolean;
+
+    switch (operandType) {
+      case SegmentOperandValueEnum.LOWER_VALUE:
+        if (tagValue !== null) {
+          result = operandValue.toLowerCase() === tagValue.toLowerCase();
+        }
+        break;
+      case SegmentOperandValueEnum.STARTING_ENDING_STAR_VALUE:
+        if (tagValue !== null) {
+          result = tagValue.indexOf(operandValue) > -1;
+        }
+        break;
+      case SegmentOperandValueEnum.STARTING_STAR_VALUE:
+        if (tagValue !== null) {
+          result = tagValue.endsWith(operandValue);
+        }
+        break;
+      case SegmentOperandValueEnum.ENDING_STAR_VALUE:
+        if (tagValue !== null) {
+          result = tagValue.startsWith(operandValue);
+        }
+        break;
+      case SegmentOperandValueEnum.REGEX_VALUE:
+        try {
+          const pattern = new RegExp(operandValue, 'g');
+          result = !!pattern.test(tagValue);
+        } catch (err) {
+          result = false;
+        }
+        break;
+      default:
+        result = tagValue === operandValue;
+    }
+
+    return result;
+  }
+}

package/lib/modules/segmentor/index.ts

@@ -0,0 +1,3 @@
+export { SegmentEvaluator } from './evaluators/segmentEvaluator';
+export { Segmentation } from './segmentation';
+export { SegmentationManager } from './core/segmentationManger';

package/lib/modules/segmentor/segmentation.ts

@@ -0,0 +1,6 @@
+import { SettingsModel } from '../../models/SettingsModel';
+import { dynamic } from '../../types/common';
+
+export interface Segmentation {
+  isSegmentationValid(dsl: Record<string, dynamic>, properties: Record<string, dynamic>, settings: SettingsModel): boolean | Promise<any>;
+}

package/lib/modules/segmentor/utils/SegmentUtil.ts

@@ -0,0 +1,23 @@
+import { isObject } from '../../../utils/DataTypeUtil';
+import { dynamic } from '../../../types/common';
+
+export function getKeyValue(obj: Record<string, any>): Record<string, any> {
+  if (!isObject(obj)) {
+    return;
+  }
+
+  const key = Object.keys(obj)[0];
+  const value = obj[key];
+  return {
+    key,
+    value
+  };
+}
+
+export function matchWithRegex(string: string, regex: string): RegExpMatchArray {
+  try {
+    return string.match(new RegExp(regex));
+  } catch (err) {
+    return null;
+  }
+}

package/lib/modules/storage/connector.ts

@@ -0,0 +1,25 @@
+import { dynamic } from '../../types/common';
+
+export abstract class Connector {
+  abstract connect(_config: Record<string, dynamic>): this;
+
+  abstract set(_key: string, _data: dynamic, ttl: number): Promise<dynamic>;
+
+  abstract get(_key: string): this | Promise<dynamic>;
+
+  abstract getAll(): Record<string, dynamic> | Promise<Array<Record<string, dynamic>>>;
+
+  abstract getKeys(): string[] | Promise<dynamic>;
+
+  abstract has(_key: string): boolean | Promise<dynamic>;
+
+  abstract hasData(): boolean | Promise<dynamic>;
+
+  abstract update(_key: string, _data: dynamic, ttl: number): Promise<dynamic>;
+
+  abstract remove(_key: string): this | Promise<dynamic>;
+
+  abstract clear(): this | Promise<dynamic>;
+
+  abstract close(): this; // TODO: stop
+}

package/lib/modules/storage/connectors/index.ts

@@ -0,0 +1,2 @@
+// export { MemoryConnector } from './memoryConnector';
+// export { RedisConnector } from './redisConnector';

package/lib/modules/storage/connectors/memoryConnector.ts

@@ -0,0 +1,115 @@
+import { Connector } from '../connector';
+import { Deferred } from '../../../utils/PromiseUtil';
+import { dynamic } from '../../../types/common';
+
+export class MemoryConnector extends Connector implements MemoryConnectorInterface {
+  data: Map<string, dynamic>;
+  isDataFlowing: boolean;
+  config: Record<string, dynamic>;
+
+  constructor(config: Record<string, dynamic> = {}) {
+    super();
+    this.connect(config);
+  }
+  _isOperational(): boolean {
+    return this.isDataFlowing;
+  }
+  connect(config: Record<string, dynamic>): this {
+    this.config = config;
+    this.data = new Map<string, dynamic>();
+    this.isDataFlowing = true;
+
+    return this;
+  }
+  set(key: string, value: dynamic): Promise<this> {
+    const deferredObject = new Deferred();
+
+    if (this._isOperational()) {
+      this.data.set(key, value);
+      deferredObject.resolve(this);
+    }
+
+    return deferredObject.promise;
+  }
+
+  update(key: string, value: dynamic): Promise<this> {
+    return this.set(key, value);
+  }
+
+  get(key: string): Promise<dynamic> {
+    const deferredObject = new Deferred();
+    this.has(key).then((keyExists: boolean) => {
+      if (keyExists) {
+        deferredObject.resolve(this.data.get(key));
+      } else {
+        deferredObject.reject(null);
+      }
+    });
+
+    return deferredObject.promise;
+  }
+
+  getAll(): Promise<Array<Record<string, dynamic>>> {
+    const deferredObject = new Deferred();
+    const allData = {};
+
+    for (const item in this.data) {
+      allData[item[0]] = item[1];
+    }
+
+    deferredObject.resolve(allData);
+
+    return deferredObject.promise;
+  }
+
+  getKeys(): Array<string> {
+    return Object.keys(this.data);
+  }
+
+  has(key: string): Promise<boolean> {
+    const deferredObject = new Deferred();
+
+    deferredObject.resolve(this.data.has(key));
+
+    return deferredObject.promise;
+  }
+
+  hasData(): boolean {
+    const deferredObject = new Deferred();
+
+    deferredObject.resolve(!!this.data.size);
+
+    return deferredObject.promise;
+  }
+
+  remove(key: string): Promise<this> {
+    const deferredObject = new Deferred();
+
+    this.data.delete(key);
+    deferredObject.resolve(this);
+
+    return deferredObject.promise;
+  }
+
+  clear(): Promise<this> {
+    const deferredObject = new Deferred();
+
+    this.data.clear();
+
+    deferredObject.resolve(this);
+
+    return deferredObject.promise;
+  }
+
+  close(): this {
+    this.isDataFlowing = false;
+
+    return this;
+  }
+}
+
+interface MemoryConnectorInterface {
+  data: Map<string, dynamic>;
+  isDataFlowing: boolean;
+  config: Record<string, dynamic>;
+}

package/lib/modules/storage/connectors/redisConnector.ts

@@ -0,0 +1,180 @@
+/* import * as redis from 'redis';
+import { Connector } from '../connector';
+import { dynamic } from '../../../types/common';
+
+import { Deferred } from '../../../utils/PromiseUtil';
+import { isString } from '../../../utils/DataTypeUtil';
+
+// TODO: error handling
+
+export class RedisConnector extends Connector implements RedisConnectorInterface {
+  data: Record<string, dynamic>;
+  isDataFlowing: boolean;
+  config: Record<string, dynamic>;
+  client: redis.RedisClient;
+
+  constructor(config: Record<string, dynamic>) {
+    super();
+    this.connect(config);
+  }
+
+  _isOperational(): boolean {
+    return this.isDataFlowing;
+  }
+
+  validate(config: Record<string, dynamic>): boolean {
+    if (!(config.host && config.port)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  connect(config: Record<string, dynamic>): this {
+    this.config = config;
+    this.isDataFlowing = true;
+
+    if (!this.validate(config)) {
+      // TODO: logging
+      console.error('Redis configuration is wrong');
+    } else {
+      if (config.alreadyCreatedClient) {
+        this.client = config.alreadyCreatedClient;
+      } else {
+        this.client = redis.createClient(config);
+      }
+
+      this.client.on('error', error => {
+        console.error(error);
+      });
+      this.client.on('connect', () => console.log('Redis Connected'));
+      this.client.on('reconnecting', () => console.log('Redis reconnecting'));
+      this.client.on('end', () => console.log('Redis end'));
+    }
+
+    return this;
+  }
+
+  set(key: string, value: dynamic): Promise<dynamic> {
+    const deferredObject = new Deferred();
+
+    if (this._isOperational()) {
+      // TODO: if type is string, then ok, otherwise strinigfy
+      if (!isString(value)) {
+        value = JSON.stringify(value);
+      }
+
+      if (this.config.ttl) {
+        this.client.set([key, value, 'EX', this.config.ttl], (err: dynamic, result: dynamic) => {
+          if (result) {
+            deferredObject.resolve(result);
+          } else {
+            deferredObject.reject(err);
+          }
+        });
+      } else {
+        this.client.set([key, value], (err: dynamic, result: dynamic) => {
+          if (result) {
+            deferredObject.resolve(result);
+          } else {
+            deferredObject.reject(err);
+          }
+        });
+      }
+    } else {
+      deferredObject.reject('redis is not operational');
+    }
+
+    return deferredObject.promise;
+  }
+
+  update(key: string, value: dynamic): Promise<dynamic> {
+    return this.set(key, value);
+  }
+
+  get(key: string): Promise<dynamic> {
+    const deferredObject = new Deferred();
+
+    this.client.get(key, (_err: dynamic, value: dynamic) => {
+      let res: Record<string, dynamic>;
+      if (value) {
+        try {
+          res = JSON.parse(value);
+          deferredObject.resolve(res);
+        } catch (e) {
+          // TODO: log error
+          console.error(e);
+          deferredObject.reject(e);
+        }
+      } else {
+        deferredObject.reject(_err);
+      }
+    });
+
+    return deferredObject.promise;
+  }
+
+  getAll(): this {
+    // TODO:
+    return this;
+  }
+  getKeys(): Promise<string> {
+    const deferredObject = new Deferred();
+
+    this.client.keys(`${this.config.prefix}*`, (_e, d) => deferredObject.resolve(d));
+
+    return deferredObject.promise;
+  }
+  has(key: string): Promise<boolean> {
+    const deferredObject = new Deferred();
+
+    this.client.exists(key, (_e, d) => deferredObject.resolve(!!d));
+
+    return deferredObject.promise;
+  }
+
+  hasData(): Promise<boolean> {
+    const deferredObject = new Deferred();
+
+    this.client.keys(`${this.config.prefix}*`, (_e, d) => deferredObject.resolve(!!d.length));
+
+    return deferredObject.promise;
+  }
+
+  remove(key: string): Promise<boolean> {
+    const deferredObject = new Deferred();
+
+    this.client.del(key, () => {
+      deferredObject.resolve(true);
+    });
+
+    return deferredObject.promise;
+  }
+
+  clear(): Promise<void> {
+    const deferredObject = new Deferred();
+    const removePrefixFromKeyPattern = new RegExp(this.config.prefix, 'ig');
+
+    this.client.keys(`${this.config.prefix}*`, (e, keys) => {
+      this.client.multi(keys.map(k => ['del', k.replace(removePrefixFromKeyPattern, '')])).exec(() => {
+        // console.log(d);
+        deferredObject.resolve();
+      });
+    });
+
+    return deferredObject.promise;
+  }
+
+  close(): this {
+    this.isDataFlowing = false;
+
+    return this;
+  }
+}
+
+interface RedisConnectorInterface {
+  data: Record<string, dynamic>;
+  isDataFlowing: boolean;
+  config: Record<string, dynamic>;
+}
+ */

package/lib/modules/storage/index.ts

@@ -0,0 +1 @@
+export { Storage } from './storage';

package/lib/modules/storage/storage.ts

@@ -0,0 +1,48 @@
+// import { MemoryConnector } from './connectors'; // RedisConnector
+import { dynamic } from '../../types/common';
+import { Connector } from './connector';
+
+// TODO: move to file
+enum ConnectorEnum {
+  MEMORY = 'memory',
+  REDIS = 'redis'
+}
+
+export class Storage {
+  public static instance: Storage;
+  public connector: any; // RedisConnector |
+  public storageType: dynamic;
+
+  public attachConnector(connector: any): any {
+    this.storageType = connector?.name;
+
+    this.connector = new connector();
+    // switch (connector.name) {
+      // case ConnectorEnum.FILE:
+      //   this.connector = new FileConnector(connector.config);
+      //   break;
+      // case ConnectorEnum.REDIS:
+      //   this.connector = new RedisConnector(connector.config);
+      //   break;
+      // case ConnectorEnum.MEMORY:
+      //   this.connector = new MemoryConnector(connector.config);
+      //   break;
+    // }
+
+    return this.connector;
+  }
+
+  public static get Instance(): Storage {
+    this.instance = this.instance || new Storage();
+
+    return this.instance;
+  }
+
+  public get config(): Record<string, dynamic> {
+    return this.connector.config;
+  }
+
+  public getConnector(): any { // RedisConnector |
+    return this.connector;
+  }
+}