vwo-fme-node-sdk 1.0.0

package/lib/VWOBuilder.ts

@@ -0,0 +1,237 @@
+import { dynamic } from './types/common';
+
+import { SegmentationManager } from './modules/segmentor';
+import { NetworkManager } from './modules/networking';
+import { LogManager } from './modules/logger';
+
+import { Storage } from './modules/storage';
+
+import { SettingsManager } from './services/SettingsManager';
+import { VWOClient } from './VWOClient';
+import { processSettings } from './utils/SettingsUtil';
+import { SettingsModel } from './models/SettingsModel';
+// import { BatchEventsQueue } from './services/batchEventsQueue';
+// import { DimensionModel } from './types/types';
+import { Constants } from './constants';
+// import { AnalyticsEvent } from './services/analyticsEvent';
+
+import { Deferred } from './utils/PromiseUtil';
+// import { getRandomUUID } from './utils/UuidUtil';
+import { cloneObject } from './utils/FunctionUtil';
+import { isObject, isBoolean, isNumber, isFunction } from './utils/DataTypeUtil' ;
+
+
+interface IVWOBuilder {
+  settings: SettingsModel;
+  storage: Storage;
+  logManager: LogManager;
+  isSettingsFetchInProgress: boolean;
+
+  build(settings: SettingsModel): VWOClient;
+
+  fetchSettings(): Promise<SettingsModel>;
+  setSettingsManager(): this;
+  setSettings(settings: SettingsModel): void;
+  getSettings(force: boolean): Promise<dynamic>;
+  setStorage(): this;
+  setNetworkManager(): this;
+  initBatching(): this;
+  initPolling(): this;
+  setAnalyticsCallback(): this;
+  setLogger(): this;
+  setSegmentation(): this;
+}
+
+export class VWOBuilder implements IVWOBuilder {
+  readonly apiKey: string;
+  readonly options: Record<string, any>;
+
+  private settingFileManager: SettingsManager;
+
+  settings: SettingsModel;
+  storage: Storage;
+  logManager: LogManager;
+  originalSettings: dynamic;
+  isSettingsFetchInProgress: boolean;
+
+  constructor(options: Record<string, dynamic>) {
+    this.options = options;
+  }
+
+  setNetworkManager(): this {
+    const networkInstance = NetworkManager.Instance;
+    networkInstance.attachClient(this.options?.network?.client);
+    networkInstance.getConfig().setDevelopmentMode(this.options?.isDevelopmentMode);
+    return this;
+  }
+
+  setSegmentation(): this {
+    SegmentationManager.Instance.attachEvaluator(this.options?.segmentation);
+    return this;
+  }
+
+  fetchSettings(force?: boolean): Promise<SettingsModel> {
+    const deferredObject = new Deferred();
+
+    // If one call is in progress, wait for it to complete and use the response
+    if (!this.isSettingsFetchInProgress) {
+      this.isSettingsFetchInProgress = true;
+      this.settingFileManager.getSettings(force).then((settings: SettingsModel) => {
+        this.originalSettings = settings;
+
+        this.isSettingsFetchInProgress = false;
+        deferredObject.resolve(settings);
+      });
+
+      return deferredObject.promise;
+    } else {
+      // DO not send multiple calls in parallel to fetch settings
+      return this.fetchSettings(force);
+    }
+  }
+
+  setSettings(settings: Record<string, any> | string): void {
+    LogManager.Instance.debug('API - setSettings called');
+    this.originalSettings = settings;
+    this.settings = cloneObject(settings);
+    this.settings = processSettings(this.settings);
+  }
+
+  getSettings(force?: boolean): Promise<SettingsModel> {
+    const deferredObject = new Deferred();
+
+    if (!force && this.settings) {
+      LogManager.Instance.info('Using already fetched and cached settings');
+      deferredObject.resolve(this.settings);
+    } else {
+      this.fetchSettings(force).then((settings: SettingsModel) => {
+        deferredObject.resolve(settings);
+      });
+    }
+    return deferredObject.promise;
+  }
+
+  setStorage(): this {
+    if (this.options.storage) {
+      this.storage = Storage.Instance.attachConnector(this.options.storage);
+    } else {
+      this.storage = null;
+    }
+
+    return this;
+  }
+
+  setSettingsManager(): this {
+    this.settingFileManager = new SettingsManager(this.options);
+
+    return this;
+  }
+
+  setLogger(): this {
+    this.logManager = new LogManager(
+      this.options.logger || {
+        defaultTransport: true,
+        level: 'debug'
+      }
+    );
+    return this;
+  }
+
+  setAnalyticsCallback(): this {
+    if (!isObject(this.options.analyticsEvent)) {
+      // TODO: add logging here
+      return this;
+    }
+
+    if (!isFunction(this.options.analyticsEvent.eventCallback)) {
+      // TODO: add logging here
+      return this;
+    }
+
+    if (
+      this.options.analyticsEvent.isBatchingSupported &&
+      !isBoolean(this.options.analyticsEvent.isBatchingSupported)
+    ) {
+      // TODO:- add logging here
+      return this;
+    }
+
+    // AnalyticsEvent.Instance.attachCallback(
+    //   this.options.analyticsEvent.eventCallback,
+    //   this.options.analyticsEvent.isBatchingSupported
+    // );
+    return this;
+  }
+
+  initBatching(): this {
+    if (!isObject(this.options.batchEvents)) {
+      // TODO:- add logging here
+      return this;
+    }
+
+    if (
+      isObject(this.options.batchEvents) &&
+      (!(
+        (isNumber(this.options.batchEvents.eventsPerRequest) &&
+          this.options.batchEvents.eventsPerRequest > 0 &&
+          this.options.batchEvents.eventsPerRequest <= Constants.MAX_EVENTS_PER_REQUEST) ||
+        (isNumber(this.options.batchEvents.requestTimeInterval) && this.options.batchEvents.requestTimeInterval >= 1)
+      ) ||
+        !isFunction(this.options.batchEvents.flushCallback))
+    ) {
+      LogManager.Instance.error('Invalid batchEvents config');
+      // throw new Error('Invalid batchEvents config');
+      return this;
+    }
+
+    // BatchEventsQueue.Instance.setBatchConfig(this.options.batchEvents, this.options.apiKey); // TODO
+
+    return this;
+  }
+
+  initPolling(): this {
+    if (!this.options.pollInterval) {
+      // TODO: Add logging here
+      return this;
+    }
+
+    if (this.options.pollInterval && !isNumber(this.options.pollInterval)) {
+      // TODO: Add logging here
+      return this;
+    }
+
+    if (this.options.pollInterval && this.options.pollInterval < 0) {
+      // TODO: Add logging here
+      LogManager.Instance.error('Poll interval should be greater than 1');
+      return this;
+    }
+
+    this.checkAndPoll(this.options.pollInterval);
+
+    return this;
+  }
+
+  build(settings: SettingsModel): VWOClient {
+    return new VWOClient(settings, this.options);
+  }
+
+  checkAndPoll(pollingInterval: number): void {
+    setInterval(() => {
+      this.getSettings(true)
+        .then((latestSettingsFile: SettingsModel) => {
+          const lastSettingsFile = JSON.stringify(this.originalSettings);
+          const stringifiedLatestSettingsFile = JSON.stringify(latestSettingsFile);
+          if (stringifiedLatestSettingsFile !== lastSettingsFile) {
+            this.originalSettings = latestSettingsFile;
+            const clonedSettings = cloneObject(latestSettingsFile);
+            this.settings = processSettings(clonedSettings);
+            // TODO: Add Logging:- Settings file updated
+          }
+        })
+        .catch(() => {
+          // TODO:- Add logging:- Polling failed
+          LogManager.Instance.error('Error while fetching VWO settings with polling');
+        });
+    }, pollingInterval * 1000); // converting seconds to milliseconds
+  }
+}

package/lib/VWOClient.ts

@@ -0,0 +1,321 @@
+// import { processSettings } from './utils/settingsUtil';
+import { Storage } from './modules/storage';
+import { LogManager } from './modules/logger';
+
+import { FlagApi } from './api/GetFlag';
+import { TrackApi } from './api/TrackEvent';
+import { SetAttributeApi } from './api/SetAttribute';
+
+// import { VWOBuilder } from './VWOBuilder';
+import { SettingsModel } from './models/SettingsModel';
+import { DebugLogMessageEnum } from './enums/logMessages/DebugLogMessageEnum';
+
+import { ErrorLogMessageEnum } from './enums/logMessages/ErrorLogMessageEnum';
+import { VariableModel } from './models/VariableModel';
+import { SettingsSchema } from './models/schemas/SettingsSchemaValidation';
+import { dynamic } from './types/common';
+// import { BatchEventsQueue } from './services/batchEventsQueue';
+
+import { isString, isObject, getType, isBoolean, isNumber, isUndefined, isArray, isNull } from './utils/DataTypeUtil';
+import { buildMessage } from './utils/LogMessageUtil';
+import { addLInkedCampaignsToSettings } from './utils/FunctionUtil';
+import { Deferred } from './utils/PromiseUtil';
+import UrlService from './services/UrlService';
+import { setVariationAllocation } from './utils/CampaignUtil';
+import { CampaignModel } from './models/CampaignModel';
+import HooksManager from './services/HooksManager';
+
+interface IVWOClient {
+  // readonly apiKey: string;
+  readonly options?: any;
+  settings: SettingsModel;
+  // vwoProvider: VWOBuilder;
+
+  // onceReady(): Promise<Record<string, dynamic>>;
+
+  // getSettings(force: boolean): SettingsModel | Promise<SettingsModel>;
+
+  getFlag(featureKey: string, context: any): Record<any, any>;
+  // getVariable(featureKey: string, variableSpecifier: dynamic, key?: string): Promise<VariableModel>;
+  // getVariables(featureKey: string): Promise<Array<VariableModel>>;
+  trackEvent(eventName: string, eventProperties: Record<string, dynamic>, context: any): Promise<Record<string, boolean>>;
+  setAttribute(attributeKey: string, attributeValue: string, context: any): void
+}
+
+export class VWOClient implements IVWOClient {
+  // readonly apiKey: string;
+
+  settings: SettingsModel;
+  storage: Storage;
+
+  constructor(
+    settings: SettingsModel,
+    options: any
+    // userId: string,
+    // properties: Record<string, dynamic>,
+    // dimensions: DimensionModel
+  ) {
+    // this.vwoProvider = vwoProvider;
+
+    // LogManager.Instance.debug(`VWO Client initialized with userId:${userId}`);
+    this.options = options;
+    this.settings = new SettingsModel(settings);
+    UrlService.init({ 
+      collectionPrefix: this.settings.getCollectionPrefix(),
+      webServiceUrl: options?.webService?.url,
+    });
+    for (let i = 0; i < this.settings.getCampaigns().length; i++) {
+      let campaign = this.settings.getCampaigns()[i];
+      setVariationAllocation(campaign);
+      this.settings.getCampaigns()[i] = campaign;
+    }
+    addLInkedCampaignsToSettings(this.settings);
+    LogManager.Instance.info('VWO Client initialized');
+    return this;
+  }
+  options?: Record<string, any>;
+
+  /* onceReady(): Promise<SettingsModel> {
+    try {
+      const deferredObject = new Deferred();
+
+      this.vwoProvider.getSettings(false).then(settings => {
+        this.settings = cloneObject(settings);
+        this.settings = processSettings(this.settings);
+
+        LogManager.Instance.info('VWO Client ready for use');
+
+        deferredObject.resolve(settings);
+      });
+
+      return deferredObject.promise;
+    } catch (err) {
+      LogManager.Instance.error('VWO Client failed to be ready');
+    }
+  } */
+
+  /* setSettings(settings: Record<string, dynamic>): void {
+    const apiName = 'setSettings';
+
+    try {
+      if (!isObject(settings)) {
+        LogManager.Instance.debug(`settings passed to setSettings API is not of valid type. Got ${getType(settings)}`);
+        throw new TypeError('TypeError: settings should be an object');
+      }
+
+      this.vwoProvider.setSettings(settings);
+    } catch (err) {
+      LogManager.Instance.error(
+        buildMessage(ErrorLogMessageEnum.API_THROW_ERROR, {
+          apiName,
+          err
+        })
+      );
+    }
+  } */
+
+  /* getSettings(force = false): Promise<SettingsModel> {
+    const apiName = 'getSettings';
+    const deferredObject = new Deferred();
+
+    try {
+      if (!isBoolean(force)) {
+        LogManager.Instance.debug(`force passed to getSettings API is not of valid type. Got ${getType(force)}`);
+        throw new TypeError('TypeError: force should be a boolean');
+      }
+
+      this.vwoProvider.getSettings(force).then(() => {
+        deferredObject.resolve(this.vwoProvider.originalSettings);
+      });
+    } catch (err) {
+      LogManager.Instance.error(
+        buildMessage(ErrorLogMessageEnum.API_THROW_ERROR, {
+          apiName,
+          err
+        })
+      );
+
+      deferredObject.resolve(null);
+    }
+    return deferredObject.promise;
+  } */
+
+  getFlag(featureKey: string, context: any): Record<any, any> {
+    const apiName = 'getFlag';
+    const deferredObject = new Deferred();
+    const hookManager = new HooksManager(this.options);
+    try {
+      LogManager.Instance.debug(
+        buildMessage(DebugLogMessageEnum.API_CALLED, {
+          apiName,
+        }),
+      );
+
+      if (!isString(featureKey)) {
+        LogManager.Instance.debug(
+          `featureKey passed to ${apiName} API is not of valid type. Got ${getType(featureKey)}`,
+        );
+        throw new TypeError('TypeError: variableSpecifier should be a string');
+      }
+
+      if (!this.settings) {
+        //|| !new SettingsSchema().isSettingsValid(this.settings)) {
+        LogManager.Instance.debug(`settings are not valid. Got ${getType(this.settings)}`);
+        throw new Error('Invalid Settings');
+      }
+
+      if (!context?.user?.id) {
+        LogManager.Instance.error('User ID is not valid. Not able to get flag');
+        throw new Error('Invalid context');
+      }
+
+      new FlagApi().get(featureKey, this.settings, context, hookManager).then((data: any) => {
+        deferredObject.resolve(data);
+      });
+
+      return deferredObject.promise;
+    } catch (err) {
+      LogManager.Instance.error(
+        buildMessage(ErrorLogMessageEnum.API_THROW_ERROR, {
+          apiName,
+          err,
+        }),
+      );
+
+      return deferredObject.resolve({});
+    }
+  }
+
+  // getVariable(variableSpecifier: dynamic, key?: string, featureKey = ''): Promise<VariableModel> {
+  //   const apiName = 'getVariable';
+  //   const deferredObject = new Deferred();
+
+  //   try {
+  //     LogManager.Instance.debug(
+  //       buildMessage(DebugLogMessageEnum.API_CALLED, {
+  //         apiName,
+  //       }),
+  //     );
+
+  //     if (!(isString(variableSpecifier) || isNumber(variableSpecifier))) {
+  //       LogManager.Instance.debug(
+  //         `variableSpecifier passed to getVariable API is not of valid type. Got ${getType(variableSpecifier)}`,
+  //       );
+  //       throw new TypeError('TypeError: variableSpecifier should be a string|number');
+  //     }
+
+  //     if (!this.settings || !new SettingsSchema().isSettingsValid(this.settings)) {
+  //       LogManager.Instance.debug(`settings are not valid. Got ${getType(this.settings)}`);
+  //       throw new Error('Invalid Settings');
+  //     }
+
+  //     // new VariableApi()
+  //     //   .get(featureKey, variableSpecifier, key || null, this.settings, this.user.getUser())
+  //     //   .then((variable: VariableModel) => {
+  //     //     deferredObject.resolve(variable);
+  //     //   });
+
+  //     return deferredObject.promise;
+  //   } catch (err) {
+  //     LogManager.Instance.error(
+  //       buildMessage(ErrorLogMessageEnum.API_THROW_ERROR, {
+  //         apiName,
+  //         err,
+  //       }),
+  //     );
+
+  //     return deferredObject.resolve(null);
+  //   }
+  // }
+
+  // getVariables(featureKey = ''): Promise<Array<VariableModel>> {
+  //   const apiName = 'getVariables';
+  //   const deferredObject = new Deferred();
+
+  //   try {
+  //     LogManager.Instance.debug(
+  //       buildMessage(DebugLogMessageEnum.API_CALLED, {
+  //         apiName,
+  //       }),
+  //     );
+
+  //     if (!this.settings || !new SettingsSchema().isSettingsValid(this.settings)) {
+  //       LogManager.Instance.debug(`settings are not valid. Got ${getType(this.settings)}`);
+  //       throw new Error('Invalid Settings');
+  //     }
+
+  //     // new VariableApi().getAll(featureKey, this.settings, this.user.getUser()).then(variableList => {
+  //     //   deferredObject.resolve(variableList);
+  //     // });
+
+  //     return deferredObject.promise;
+  //   } catch (err) {
+  //     LogManager.Instance.error(
+  //       buildMessage(ErrorLogMessageEnum.API_THROW_ERROR, {
+  //         apiName,
+  //         err,
+  //       }),
+  //     );
+
+  //     return deferredObject.resolve([]);
+  //   }
+  // }
+
+  trackEvent(
+    eventName: string,
+    eventProperties: Record<string, dynamic> = {},
+    context: any,
+  ): Promise<Record<string, boolean>> {
+    const apiName = 'trackEvent';
+    const hookManager = new HooksManager(this.options);
+    try {
+      LogManager.Instance.debug(
+        buildMessage(DebugLogMessageEnum.API_CALLED, {
+          apiName,
+        }),
+      );
+
+      if (!isString(eventName)) {
+        LogManager.Instance.debug(`eventName passed to track API is not of valid type. Got ${getType(eventName)}`);
+        throw new TypeError('TypeError: eventName should be a string');
+      }
+
+      if (!isObject(eventProperties)) {
+        LogManager.Instance.debug(
+          `eventProperties passed to track API is not of valid type. Got ${getType(eventProperties)}`,
+        );
+        // throw new TypeError('TypeError: eventProperties should be an object');
+      }
+
+      if (!this.settings) {
+        // || !new SettingsSchema().isSettingsValid(this.settings)) {
+        LogManager.Instance.debug(`settings are not valid. Got ${getType(this.settings)}`);
+        throw new Error('Invalid Settings');
+      }
+      if (!context?.user?.id) {
+        LogManager.Instance.error('User ID is not valid. Not able to track event');
+        throw new Error('Invalid context');
+      }
+
+      return new TrackApi().track(this.settings, eventName, eventProperties, context, hookManager);
+    } catch (err) {
+      LogManager.Instance.error(
+        buildMessage(ErrorLogMessageEnum.API_THROW_ERROR, {
+          apiName,
+          err,
+        }),
+      );
+    }
+  }
+
+  setAttribute(attributeKey: string, attributeValue: string, context: any): void {
+    if (!isString(attributeKey) || !isString(attributeValue) || !isString(context?.user?.id)) {
+      LogManager.Instance.error(
+        `Paramters passed to setAttribute API are not valid. Please check`,
+      );
+
+      return;
+    }
+    new SetAttributeApi().setAttribute(this.settings, attributeKey, attributeValue, context);
+  }
+}