vwo-fme-node-sdk 1.0.0

package/lib/models/schemas/SettingsSchemaValidation.ts

@@ -0,0 +1,83 @@
+import { validate, number, string, boolean, array, object, optional, union, Struct } from 'superstruct';
+import { SettingsModel } from '../SettingsModel';
+import { dynamic } from '../../types/common';
+
+export class SettingsSchema {
+  private campaignGoalSchema: Struct<dynamic>;
+  private variableObjectSchema: Struct<dynamic>;
+  private campaignVariationSchema: Struct<dynamic>;
+  private campaignObjectSchema: Struct<dynamic>;
+  private settingsFileSchema: Struct<dynamic>;
+  private campaignGroupSchema: Struct<dynamic>;
+  private featureSchema: Struct<dynamic>;
+
+  constructor() {
+    this.initializeSchemas();
+  }
+
+  private initializeSchemas(): void {
+    this.campaignGoalSchema = object({
+      id: union([number(), string()]),
+      key: string(),
+      type: string()
+    });
+
+    this.variableObjectSchema = object({
+      id: union([number(), string()]),
+      type: string(),
+      key: string(),
+      value: union([number(), string(), boolean()])
+    });
+
+    this.campaignVariationSchema = object({
+      id: union([number(), string()]),
+      key: string(),
+      weight: union([number(), string()]),
+      segments: optional(object()),
+      variables: optional(array(this.variableObjectSchema)),
+      startRangeVariation: optional(number()),
+      endRangeVariation: optional(number())
+    });
+
+    this.campaignObjectSchema = object({
+      id: union([number(), string()]),
+      type: string(),
+      key: string(),
+      featureId: optional(number()),
+      featureKey: optional(string()),
+      percentTraffic: number(),
+      goals: array(this.campaignGoalSchema),
+      variations: array(this.campaignVariationSchema),
+      variables: optional(array(this.variableObjectSchema)),
+      segments: object(),
+      isForcedVariationEnabled: optional(boolean()),
+      priority: number(),
+      autoActivate: boolean(),
+      autoTrack: boolean()
+    });
+
+    this.featureSchema = object({
+      id: union([number(), string()]),
+      key: string(),
+      variables: optional(array(this.variableObjectSchema)),
+      campaigns: array(this.campaignGroupSchema)
+    });
+
+    this.settingsFileSchema = object({
+      sdkKey: optional(string()),
+      version: union([number(), string()]),
+      accountId: union([number(), string()]),
+      features: optional(array(this.featureSchema))
+    });
+
+    this.campaignGroupSchema = object({
+      id: number(),
+      campaigns: array(number())
+    });
+  }
+
+  isSettingsValid(settings: SettingsModel): boolean {
+    const [error] = validate(settings, this.settingsFileSchema);
+    return !error;
+  }
+}

package/lib/modules/decision-maker/index.ts

@@ -0,0 +1,65 @@
+/**
+ * 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 * as Hasher from 'murmurhash';
+import { getBucketingSeed } from '../../utils/CampaignUtil';
+import { LogManager } from '../../modules/logger';
+
+const SEED_VALUE = 1;
+const MAX_TRAFFIC_VALUE = 10000;
+
+export class DecisionMaker {
+  /**
+   * Generates Bucket Value of the User by hashing the User ID by murmurHash
+   * and scaling it down.
+   *
+   * @param {Number} hashValue the hashValue generated after hashing
+   * @param {Number} maxValue the value up-to which hashValue needs to be scaled
+   * @param {Number} multiplier multiplier in case the traffic allocation is less than 100
+   *
+   * @return {Number} bucket Value of the User
+   */
+  generateBucketValue(hashValue: number, maxValue: number, multiplier = 1): number {
+    const ratio = hashValue / Math.pow(2, 32);
+    const multipliedValue = (maxValue * ratio + 1) * multiplier;
+    const value = Math.floor(multipliedValue);
+
+    return value;
+  }
+
+  /**
+   * Validates the User ID and generates Bucket Value of the User by hashing the userId by murmurHash and scaling it down.
+   *
+   * @param {String} userId the unique ID assigned to User
+   *
+   * @return {Number} the bucket Value allotted to User (between 1 to $this->$MAX_TRAFFIC_PERCENT)
+   */
+  getBucketValueForUser(hashKey: string, maxValue = 100): number {
+    const hashValue = Hasher.v3(hashKey, SEED_VALUE);
+    const bucketValue = this.generateBucketValue(hashValue, maxValue);
+    return bucketValue;
+  }
+
+  calculateBucketValue(str: string, multiplier = 1, maxValue = 10000): number {
+    const hashValue = this.generateHashValue(str);
+
+    return this.generateBucketValue(hashValue, maxValue, multiplier);
+  }
+
+  generateHashValue(hashKey: string): number {
+    return Hasher.v3(hashKey, SEED_VALUE);
+  }
+}

package/lib/modules/logger/core/logManager.ts

@@ -0,0 +1,113 @@
+import { v4 as uuidv4 } from 'uuid';
+import { dynamic } from '../../../types/common';
+
+import { Logger } from '../logger';
+import { LogTransportManager } from './transportManager';
+import { ConsoleTransport } from '../transports/consoleTransport';
+
+import { isObject } from '../../../utils/DataTypeUtil';
+import { LogLevelEnum } from '../enums/logLevelEnum';
+
+interface ILogManager {
+  transportManager: LogTransportManager;
+  config: Record<string, dynamic>;
+  name: string;
+  requestId: string;
+  level: string;
+  prefix: string;
+  dateTimeFormat: () => string;
+
+  transport: Record<string, dynamic>;
+  transports: Array<Record<string, dynamic>>;
+
+  addTransport(transportObject: Record<string, dynamic>): void;
+  addTransports(transportsList: Array<Record<string, dynamic>>): void;
+}
+
+export class LogManager extends Logger implements ILogManager {
+  private static instance: LogManager;
+  transportManager: LogTransportManager;
+  config: Record<string, any>;
+  name = 'VWO Logger';
+  requestId = uuidv4();
+  level = LogLevelEnum.ERROR;
+  prefix = 'VWO-SDK';
+  public dateTimeFormat(): string {
+    return new Date().toISOString();
+  }
+  transport: Record<string, any>;
+  transports: Array<Record<string, any>>;
+
+  constructor(config?: Record<string, any>) {
+    super();
+
+    this.config = config;
+
+    if (!LogManager.instance) {
+      LogManager.instance = this;
+
+      this.config.name = config.name || this.name;
+      this.config.requestId = config.requestId || this.requestId;
+      this.config.level = config.level || this.level;
+      this.config.prefix = config.prefix || this.prefix;
+      this.config.dateTimeFormat = config.dateTimeFormat || this.dateTimeFormat;
+
+      this.transportManager = new LogTransportManager(this.config);
+
+      this.handleTransports();
+    }
+
+    return LogManager.instance;
+  }
+
+  static get Instance(): LogManager {
+    return LogManager.instance;
+  }
+
+  handleTransports(): void {
+    const transports = this.config.transports;
+
+    if (transports?.length) {
+      this.addTransports(this.config.transports);
+    } else if (this.config.transport && isObject(this.config.transport)) {
+      this.addTransport(this.config.transport);
+    } else if (this.config.defaultTransport) {
+      // default
+      this.addTransport(
+        new ConsoleTransport({
+          level: this.config.level
+        })
+      );
+    }
+  }
+
+  addTransport(transport: Record<any, any>): void {
+    this.transportManager.addTransport(transport);
+  }
+
+  addTransports(transports: Record<any, any>): void {
+    for (let i = 0; i < transports.length; i++) {
+      this.addTransport(transports[i]);
+    }
+  }
+
+  trace(message: string): void {
+    this.transportManager.log(LogLevelEnum.TRACE, message);
+  }
+
+  debug(message: string): void {
+    this.transportManager.log(LogLevelEnum.DEBUG, message);
+  }
+
+  info(message: string): void {
+    this.transportManager.log(LogLevelEnum.INFO, message);
+  }
+
+  warn(message: string): void {
+    this.transportManager.log(LogLevelEnum.WARN, message);
+  }
+
+  error(message: string): void {
+    this.transportManager.log(LogLevelEnum.ERROR, message);
+  }
+}

package/lib/modules/logger/core/transportManager.ts

@@ -0,0 +1,76 @@
+import { Logger } from '../logger';
+import { LogLevelEnum } from '../enums/logLevelEnum';
+import { dynamic } from '../../../types/common';
+import { LogMessageBuilder } from '../logMessageBuilder';
+
+enum LogLevelNumberEnum {
+  TRACE = 0,
+  DEBUG = 1,
+  INFO = 2,
+  WARN = 3,
+  ERROR = 4
+}
+
+interface IlogTransport extends Logger {
+  transports: Array<Record<string, dynamic>>;
+  config: Record<string, dynamic>;
+
+  shouldLog(transportLevel: string, configLevel: string): boolean;
+  log(level: string, message: string): void;
+}
+export class LogTransportManager implements IlogTransport {
+  transports: Array<Record<string, any>>;
+  config: Record<string, any>;
+
+  constructor(config: Record<string, any>) {
+    this.transports = [];
+    this.config = config;
+  }
+
+  addTransport(transport: Record<string, any>): void {
+    this.transports.push(transport);
+  }
+
+  shouldLog(transportLevel: string, configLevel: string): boolean {
+    transportLevel = transportLevel || configLevel || this.config.level;
+
+    const targetLevel = LogLevelNumberEnum[transportLevel.toUpperCase()];
+    const desiredLevel = LogLevelNumberEnum[(configLevel || this.config.level).toUpperCase()];
+
+    return targetLevel >= desiredLevel;
+  }
+
+  trace(message: string): void {
+    this.log(LogLevelEnum.TRACE, message);
+  }
+
+  debug(message: string): void {
+    this.log(LogLevelEnum.DEBUG, message);
+  }
+
+  info(message: string): void {
+    this.log(LogLevelEnum.INFO, message);
+  }
+
+  warn(message: string): void {
+    this.log(LogLevelEnum.WARN, message);
+  }
+
+  error(message: string): void {
+    this.log(LogLevelEnum.ERROR, message);
+  }
+
+  log(level: string, message: string): void {
+    for (let i = 0; i < this.transports.length; i++) {
+      const logMessageBuilder = new LogMessageBuilder(this.config, this.transports[i]);
+      const formattedMessage = logMessageBuilder.formatMessage(level, message);
+      if (this.shouldLog(level, this.transports[i].level)) {
+        if (this.transports[i].logHandler) {
+          this.transports[i].logHandler(formattedMessage, level);
+        } else {
+          this.transports[i][level](formattedMessage, level);
+        }
+      }
+    }
+  }
+}

package/lib/modules/logger/enums/logLevelEnum.ts

@@ -0,0 +1,7 @@
+export enum LogLevelEnum {
+  TRACE = 'trace',
+  DEBUG = 'debug',
+  INFO = 'info',
+  WARN = 'warn',
+  ERROR = 'error'
+}

package/lib/modules/logger/index.ts

@@ -0,0 +1,2 @@
+export { LogManager } from './core/logManager';
+export { LogLevelEnum } from './enums/logLevelEnum';

package/lib/modules/logger/logMessageBuilder.ts

@@ -0,0 +1,60 @@
+import { LogLevelEnum } from './enums/logLevelEnum';
+import { dynamic } from '../../types/common';
+
+interface ILogMessageBuilder {
+  loggerConfig: Record<string, dynamic>;
+  transportConfig: Record<string, dynamic>;
+  prefix: string;
+  dateTimeFormat: dynamic;
+
+  formatMessage(level: string, message: string): string;
+  getFormattedLevel(level: string): string;
+  getFormattedDateTime(): string;
+}
+
+export class LogMessageBuilder implements ILogMessageBuilder {
+  loggerConfig: Record<string, any>;
+  transportConfig: Record<string, any>;
+  prefix: string;
+  dateTimeFormat: any;
+
+  constructor(loggerConfig: Record<string, any>, transportConfig: Record<string, any>) {
+    this.loggerConfig = loggerConfig;
+    this.transportConfig = transportConfig;
+
+    this.prefix = this.transportConfig.prefix || this.loggerConfig.prefix || '';
+    this.dateTimeFormat = this.transportConfig.dateTimeFormat || this.loggerConfig.dateTimeFormat;
+  }
+
+  formatMessage(level: string, message: string): string {
+    return `${this.getFormattedLevel(level)} ${this.prefix} ${this.getFormattedDateTime()} ${message}`;
+  }
+
+  getFormattedLevel(level: string): string {
+    const upperCaseLevel = level.toUpperCase();
+    const AnsiColorEnum = {
+      BOLD: '\x1b[1m',
+      CYAN: '\x1b[36m',
+      GREEN: '\x1b[32m',
+      LIGHTBLUE: '\x1b[94m',
+      RED: '\x1b[31m',
+      RESET: '\x1b[0m',
+      WHITE: '\x1b[30m',
+      YELLOW: '\x1b[33m'
+    };
+
+    const LogLevelColorInfoEnum = {
+      [LogLevelEnum.TRACE]: `${AnsiColorEnum.BOLD}${AnsiColorEnum.WHITE}${upperCaseLevel}${AnsiColorEnum.RESET}`,
+      [LogLevelEnum.DEBUG]: `${AnsiColorEnum.BOLD}${AnsiColorEnum.LIGHTBLUE}${upperCaseLevel} ${AnsiColorEnum.RESET}`,
+      [LogLevelEnum.INFO]: `${AnsiColorEnum.BOLD}${AnsiColorEnum.CYAN}${upperCaseLevel}  ${AnsiColorEnum.RESET}`,
+      [LogLevelEnum.WARN]: `${AnsiColorEnum.BOLD}${AnsiColorEnum.YELLOW}${upperCaseLevel}  ${AnsiColorEnum.RESET}`,
+      [LogLevelEnum.ERROR]: `${AnsiColorEnum.BOLD}${AnsiColorEnum.RED}${upperCaseLevel} ${AnsiColorEnum.RESET}`
+    };
+
+    return LogLevelColorInfoEnum[level];
+  }
+
+  getFormattedDateTime(): string {
+    return this.dateTimeFormat();
+  }
+}

package/lib/modules/logger/logger.ts

@@ -0,0 +1,7 @@
+export abstract class Logger {
+  abstract trace(message: string): void;
+  abstract debug(message: string): void;
+  abstract info(message: string): void;
+  abstract warn(message: string): void;
+  abstract error(message: string): void;
+}

package/lib/modules/logger/transports/consoleTransport.ts

@@ -0,0 +1,37 @@
+import { Logger } from '../logger';
+import { LogLevelEnum } from '../enums/logLevelEnum';
+import { dynamic } from '../../../types/common';
+
+export class ConsoleTransport implements Logger {
+  config: Record<string, any>;
+  level: string;
+
+  constructor(config: Record<string, any> = {}) {
+    this.config = config;
+    this.level = this.config.level;
+  }
+
+  trace(message: string): void {
+    this.log(LogLevelEnum.TRACE, message);
+  }
+
+  debug(message: string): void {
+    this.log(LogLevelEnum.DEBUG, message);
+  }
+
+  info(message: string): void {
+    this.log(LogLevelEnum.INFO, message);
+  }
+
+  warn(message: string): void {
+    this.log(LogLevelEnum.WARN, message);
+  }
+
+  error(message: string): void {
+    this.log(LogLevelEnum.ERROR, message);
+  }
+
+  log(level: string, message: string): void {
+    console[level](message);
+  }
+}

package/lib/modules/networking/client/networkClient.ts

@@ -0,0 +1,128 @@
+import * as http from 'http';
+import * as https from 'https';
+import { dynamic } from '../../../types/common';
+import { Deferred } from '../../../utils/PromiseUtil';
+
+import { RequestModel } from '../models/requestModel';
+import { NetworkClientInterface } from './networkClientInterface';
+import { ResponseModel } from '../models/responseModel';
+
+const HTTPS = 'HTTPS';
+
+export class NetworkClient implements NetworkClientInterface {
+  GET(requestModel: RequestModel): Promise<ResponseModel> {
+    const deferred = new Deferred();
+
+    const networkOptions: Record<string, dynamic> = requestModel.getOptions();
+    const responseModel = new ResponseModel();
+
+    try {
+      const httpClient = networkOptions.scheme === HTTPS ? https : http;
+
+      const req = httpClient.get(networkOptions, res => {
+        responseModel.setStatusCode(res.statusCode);
+        const contentType = res.headers['content-type'];
+
+        let error;
+        let rawData = '';
+
+        if (!/^application\/json/.test(contentType)) {
+          error = `Invalid content-type.\nExpected application/json but received ${contentType}`;
+        }
+
+        if (error) {
+          // console.error(error);
+          // Consume response data to free up memory
+          res.resume();
+          responseModel.setError(error);
+          deferred.reject(responseModel);
+        }
+        res.setEncoding('utf8');
+
+        res.on('data', chunk => {
+          rawData += chunk;
+        });
+
+        res.on('end', () => {
+          try {
+            const parsedData = JSON.parse(rawData);
+
+            if (responseModel.getStatusCode() !== 200) {
+              const error = `Request failed for fetching account settings. Got Status Code: ${responseModel.getStatusCode()} and message: ${rawData}`;
+              // console.error(error);
+              responseModel.setError(error);
+              deferred.reject(responseModel);
+
+              return;
+            }
+            responseModel.setData(parsedData);
+            deferred.resolve(responseModel);
+          } catch (err) {
+            // console.log('error is ', err);
+            responseModel.setError(err);
+            deferred.reject(responseModel);
+          }
+        });
+      });
+
+      req.on('timeout', () => {
+        responseModel.setError(new Error('timeout'));
+        deferred.reject(responseModel);
+      });
+    } catch (err) {
+      responseModel.setError(err);
+      deferred.reject(responseModel);
+    }
+
+    return deferred.promise;
+  }
+
+  POST(request: RequestModel): Promise<ResponseModel> {
+    const deferred = new Deferred();
+    const networkOptions: Record<string, dynamic> = request.getOptions();
+    const responseModel: ResponseModel = new ResponseModel();
+
+    try {
+      const httpClient = networkOptions.scheme === HTTPS ? https : http;
+      const req = httpClient.request(networkOptions, res => {
+        let rawData = ''; // eslint-disable-line no-unused-vars
+        res.setEncoding('utf8');
+        res.on('data', function(chunk) {
+          rawData += chunk;
+        });
+
+        res.on('end', () => {
+          if (res.statusCode === 200) {
+            responseModel.setData(request.getBody());
+            deferred.resolve(responseModel);
+          } else if (res.statusCode === 413) {
+            const parsedData = JSON.parse(rawData);
+            responseModel.setError(parsedData.error);
+            responseModel.setData(request.getBody());
+            deferred.reject(responseModel);
+          } else {
+            const parsedData = JSON.parse(rawData);
+            responseModel.setError(parsedData.message);
+            responseModel.setData(request.getBody());
+            deferred.reject(responseModel);
+          }
+        });
+      });
+
+      req.on('timeout', () => {
+        responseModel.setError(new Error('timeout'));
+        responseModel.setData(request.getBody());
+        deferred.reject(responseModel);
+      });
+
+      req.write(JSON.stringify(networkOptions.body));
+      req.end();
+    } catch (err) {
+      responseModel.setError(err);
+      responseModel.setData(request.getBody());
+      deferred.reject(responseModel);
+    }
+
+    return deferred.promise;
+  }
+}

package/lib/modules/networking/client/networkClientInterface.ts

@@ -0,0 +1,8 @@
+import { RequestModel } from '../models/requestModel';
+import { ResponseModel } from '../models/responseModel';
+
+export interface NetworkClientInterface {
+  GET(request: RequestModel): Promise<ResponseModel>;
+
+  POST(request: RequestModel): Promise<ResponseModel>;
+}

package/lib/modules/networking/handlers/requestHandler.ts

@@ -0,0 +1,28 @@
+import { RequestModel } from '../models/requestModel';
+import { GlobalRequestModel } from '../models/globalRequestModel';
+import { dynamic } from '../../../types/common';
+
+export class RequestHandler {
+  createRequest(request: RequestModel, config: GlobalRequestModel): RequestModel {
+    if (
+      (config.getBaseUrl() === null || config.getBaseUrl() === undefined) &&
+      (request.getUrl() === null || request.getUrl() === undefined)
+    ) {
+      return null;
+    }
+    request.setUrl(request.getUrl() || config.getBaseUrl());
+    request.setTimeout(request.getTimeout() || config.getTimeout());
+    request.setBody(request.getBody() || config.getBody());
+    request.setHeaders(request.getHeaders() || config.getHeaders());
+    const requestQueryParams: Record<string, dynamic> = request.getQuery() || {};
+    const configQueryParams: Record<string, dynamic> = config.getQuery() || {};
+
+    for (const queryKey in configQueryParams) {
+      if (!Object.prototype.hasOwnProperty.call(requestQueryParams, queryKey)) {
+        requestQueryParams[queryKey] = configQueryParams[queryKey];
+      }
+    }
+    request.setQuery(requestQueryParams);
+    return request;
+  }
+}

package/lib/modules/networking/index.ts

@@ -0,0 +1,6 @@
+export { NetworkManager } from './manager/networkManager';
+export { RequestModel } from './models/requestModel';
+export { ResponseModel } from './models/responseModel';
+export { NetworkClient } from './client/networkClient';
+export { NetworkClientInterface } from './client/networkClientInterface';
+export { GlobalRequestModel } from './models/globalRequestModel';