@splitsoftware/splitio 10.17.3-rc.4 → 10.17.4-rc.1

package/lib/utils/timeTracker/index.js

@@ -1,213 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = void 0;
-
-var _lang = require("../lang");
-
-var _LoggerFactory = require("../logger/LoggerFactory");
-
-var _timer = _interopRequireDefault(require("./timer"));
-
-var _thenable = _interopRequireDefault(require("../promise/thenable"));
-
-var _CALLBACKS;
-
-// logger to be used on this module
-var logger = new _LoggerFactory.Logger('[TIME TRACKER]', {
-  showLevel: false
-}); // Map we will use for storing timers data
-
-var timers = {}; // Tasks constants
-
-var CONSTANTS = {
-  SDK_READY: 'Getting ready - Split SDK',
-  SDK_GET_TREATMENT: 'SDK - Get Treatment',
-  SDK_GET_TREATMENTS: 'SDK - Get Treatments',
-  SDK_GET_TREATMENT_WITH_CONFIG: 'SDK - Get Treatment with config',
-  SDK_GET_TREATMENTS_WITH_CONFIG: 'SDK - Get Treatments with config',
-  SPLITS_READY: 'Getting ready - Splits',
-  SEGMENTS_READY: 'Getting ready - Segments',
-  METRICS_PUSH: 'Pushing - Metrics',
-  IMPRESSIONS_PUSH: 'Pushing - Impressions',
-  EVENTS_PUSH: 'Pushing - Events',
-  MY_SEGMENTS_FETCH: 'Fetching - My Segments',
-  SEGMENTS_FETCH: 'Fetching - Segments',
-  SPLITS_FETCH: 'Fetching - Splits'
-}; // Tasks callbacks, if any
-
-var CALLBACKS = (_CALLBACKS = {}, _CALLBACKS[CONSTANTS.SDK_READY] = {
-  collector: 'client',
-  method: 'ready'
-}, _CALLBACKS[CONSTANTS.SDK_GET_TREATMENT] = {
-  collector: 'client',
-  method: 'getTreatment'
-}, _CALLBACKS[CONSTANTS.SDK_GET_TREATMENTS] = {
-  collector: 'client',
-  method: 'getTreatments'
-}, _CALLBACKS[CONSTANTS.SDK_GET_TREATMENT_WITH_CONFIG] = {
-  collector: 'client',
-  method: 'getTreatmentWithConfig'
-}, _CALLBACKS[CONSTANTS.SDK_GET_TREATMENTS_WITH_CONFIG] = {
-  collector: 'client',
-  method: 'getTreatmentsWithConfig'
-}, _CALLBACKS[CONSTANTS.MY_SEGMENTS_FETCH] = {
-  collector: 'mySegments',
-  method: 'latency'
-}, _CALLBACKS[CONSTANTS.SEGMENTS_FETCH] = {
-  collector: 'segmentChanges',
-  method: 'latency'
-}, _CALLBACKS[CONSTANTS.SPLITS_FETCH] = {
-  collector: 'splitChanges',
-  method: 'latency'
-}, _CALLBACKS);
-/**
- * Generates the timer keys using the task name and a modifier, if any.
- * @param {string} task - The task name
- * @param {string} modifier - (optional) The modifier, if any.
- * @return {string} The generated timer key
- */
-
-var generateTimerKey = function generateTimerKey(task, modifier) {
-  return typeof modifier === 'string' ? task + modifier : task;
-};
-/**
- * Given the collectors map, it returns the specific collector for a given task.
- *
- * @param {string} task - The task name
- * @param {Object} collectors - The collectors map
- */
-
-
-var getCollectorForTask = function getCollectorForTask(task, collectors) {
-  var callbackData = CALLBACKS[task];
-  if (callbackData && collectors) return collectors[callbackData.collector];
-  return false;
-};
-/**
- * Given a collector and a task, returns the callback function that should be called when we stop the timer.
- *
- * @param {string} task - The task name
- * @param {Object} collector - The collector object for the task
- */
-
-
-var getCallbackForTask = function getCallbackForTask(task, collector) {
-  var callbackData = CALLBACKS[task];
-  if (callbackData && collector) return collector[callbackData.method];
-  return false;
-};
-
-var TrackerAPI = {
-  /**
-   * "Private" method, used to attach count/countException and stop callbacks to a promise.
-   *
-   * @param {Promise} promise - The promise we want to attach the callbacks.
-   * @param {string} task - The name of the task.
-   * @param {string} modifier - (optional) The modifier for the task, if any.
-   */
-  __attachToPromise: function __attachToPromise(promise, task, collector, modifier) {
-    var _this = this;
-
-    return promise.then(function (resp) {
-      _this.stop(task, modifier);
-
-      if (collector && collector.count) collector.count(resp.status);
-      return resp;
-    }).catch(function (err) {
-      _this.stop(task, modifier);
-
-      if (collector && collector.countException) collector.countException();
-      throw err;
-    });
-  },
-
-  /**
-   * Starts tracking the time for a given task. All tasks tracked are considered "unique" because
-   * there may be multiple SDK instances tracking a "generic" task, making any task non-generic.
-   *
-   * @param {string} task - The task we are starting.
-   * @param {Object} collectors - The collectors map.
-   * @param {Promise} promise - (optional) The promise we are tracking.
-   * @return {Function | Promise} The stop function for this specific task or the promise received with the callbacks registered.
-   */
-  start: function start(task, collectors, promise) {
-    var taskUniqueId = (0, _lang.uniqueId)();
-    var taskCollector = getCollectorForTask(task, collectors);
-    var result; // If we are registering a promise with this task, we should count the status and the exceptions as well
-    // as stopping the task when the promise resolves. Then return the promise
-
-    if ((0, _thenable.default)(promise)) {
-      result = this.__attachToPromise(promise, task, taskCollector, taskUniqueId);
-    } else {
-      // If not, we return the stop function, as it will be stopped manually.
-      result = this.stop.bind(this, task, taskUniqueId);
-
-      if (CALLBACKS[task] && !taskCollector) {
-        // and provide a way for a defered setup of the collector, if needed.
-        result.setCollectorForTask = this.setCollectorForTask.bind(this, task, taskUniqueId);
-      }
-    } // We start the timer, with an uniqueId attached to it's name, and save tracking info for this task.
-
-
-    var trackingKey = generateTimerKey(task, taskUniqueId);
-    var cb = getCallbackForTask(task, taskCollector);
-    timers[trackingKey] = {
-      cb: cb,
-      timer: (0, _timer.default)()
-    };
-    return result;
-  },
-
-  /**
-   * Setup the collector for a task that reports metrics.
-   *
-   * @param {string} task - The task name
-   * @param {string} taskUniqueId - The unique identifier for this task
-   * @param {Object} collectors - The collectors map.
-   */
-  setCollectorForTask: function setCollectorForTask(task, taskUniqueId, collectors) {
-    var taskCollector = getCollectorForTask(task, collectors);
-
-    if (taskCollector) {
-      var trackingKey = generateTimerKey(task, taskUniqueId);
-      timers[trackingKey].cb = getCallbackForTask(task, taskCollector);
-    }
-  },
-
-  /**
-   * Stops the tracking of a given task.
-   *
-   * @param {string} task - The task we are starting.
-   * @param {string} modifier - (optional) The modifier for that specific task.
-   */
-  stop: function stop(task, modifier) {
-    var timerName = generateTimerKey(task, modifier);
-    var timerData = timers[timerName];
-
-    if (timerData) {
-      // Stop the timer and round result for readability.
-      var et = timerData.timer();
-      logger.debug("[" + task + "] took " + et + "ms to finish."); // Check if we have a tracker callback.
-
-      if (timerData.cb) {
-        // If we have a callback, we call it with the elapsed time of the task and then delete the reference.
-        timerData.cb(et);
-      } // Remove the task tracking reference.
-
-
-      delete timers[timerName];
-      return et;
-    }
-  },
-
-  /**
-   * The constants shortcut for the task names.
-   */
-  TaskNames: CONSTANTS
-}; // Our "time tracker" API
-
-var _default = TrackerAPI;
-exports.default = _default;

package/lib/utils/timeTracker/timer.js

@@ -1,33 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = void 0;
-
-var _now = _interopRequireDefault(require("../now"));
-
-/**
-Copyright 2016 Split Software
-
-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.
-**/
-function start() {
-  var st = (0, _now.default)();
-  return function stop() {
-    return Math.round((0, _now.default)() - st);
-  };
-}
-
-var _default = start;
-exports.default = _default;

package/src/client/attributesDecoration.js

@@ -1,112 +0,0 @@
-import ClientInputValidationLayer from './inputValidation';
-import AttributesCacheInMemory from '../storage/AttributesCache/InMemory';
-import { validateAttributesDeep } from '../utils/inputValidation/attributes';
-import logFactory from '../utils/logger';
-import objectAssign from 'object-assign';
-const log = logFactory('splitio-client');
-
-/**
- * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call 
- */
-export default function ClientAttributesDecorationLayer(context, isKeyBinded, isTTBinded) {
-
-  const client = ClientInputValidationLayer(context, isKeyBinded, isTTBinded);
-
-  const attributeStorage = new AttributesCacheInMemory();
-
-  // Keep a reference to the original methods
-  const clientGetTreatment = client.getTreatment;
-  const clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
-  const clientGetTreatments = client.getTreatments;
-  const clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
-
-  /**
-   * Add an attribute to client's in memory attributes storage
-   * 
-   * @param {string} attributeName Attrinute name
-   * @param {string, number, boolean, list} attributeValue Attribute value
-   * @returns {boolean} true if the attribute was stored and false otherways
-   */
-  client.setAttribute = (attributeName, attributeValue) => {
-    const attribute = {};
-    attribute[attributeName] = attributeValue;
-    if (!validateAttributesDeep(attribute)) return false;
-    log.debug(`stored ${attributeValue} for attribute ${attributeName}`);
-    return attributeStorage.setAttribute(attributeName, attributeValue);
-  };
-
-  /**
-   * Returns the attribute with the given key
-   * 
-   * @param {string} attributeName Attribute name
-   * @returns {Object} Attribute with the given key
-   */
-  client.getAttribute = (attributeName) => {
-    log.debug(`retrieved attribute ${attributeName}`);
-    return attributeStorage.getAttribute(attributeName + '');
-  };
-
-  /**
-   * Add to client's in memory attributes storage the attributes in 'attributes'
-   * 
-   * @param {Object} attributes Object with attributes to store
-   * @returns true if attributes were stored an false otherways
-   */
-  client.setAttributes = (attributes) => {
-    if (!validateAttributesDeep(attributes)) return false;
-    return attributeStorage.setAttributes(attributes);
-  };
-
-  /**
-   * Return all the attributes stored in client's in memory attributes storage
-   * 
-   * @returns {Object} returns all the stored attributes
-   */
-  client.getAttributes = () => {
-    return attributeStorage.getAll();
-  };
-
-  /**
-   * Removes from client's in memory attributes storage the attribute with the given key
-   * 
-   * @param {string} attributeName 
-   * @returns {boolean} true if attribute was removed and false otherways
-   */
-  client.removeAttribute = (attributeName) => {
-    log.debug(`removed attribute ${attributeName}`);
-    return attributeStorage.removeAttribute(attributeName + '');
-  };
-
-  /**
-   * Remove all the stored attributes in the client's in memory attribute storage
-   */
-  client.clearAttributes = () => {
-    return attributeStorage.clear();
-  };
-
-  client.getTreatment = (maybeKey, maybeSplit, maybeAttributes) => {
-    return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
-  };
-
-  client.getTreatmentWithConfig = (maybeKey, maybeSplit, maybeAttributes) => {
-    return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
-  };
-
-  client.getTreatments = (maybeKey, maybeSplits, maybeAttributes) => {
-    return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
-  };
-
-  client.getTreatmentsWithConfig = (maybeKey, maybeSplits, maybeAttributes) => {
-    return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
-  };
-
-  function combineAttributes(maybeAttributes) {
-    const storedAttributes = attributeStorage.getAll();
-    if (Object.keys(storedAttributes).length > 0) {
-      return objectAssign({}, storedAttributes, maybeAttributes);
-    }
-    return maybeAttributes;
-  }
-
-  return client;
-}

package/src/client/browser.js

@@ -1,41 +0,0 @@
-import { get } from '../utils/lang';
-import ClientAttributesDecorationLayer from './attributesDecoration';
-import { LOCALHOST_MODE } from '../utils/constants';
-import {
-  validateKey,
-  validateTrafficType,
-} from '../utils/inputValidation';
-
-function BrowserClientFactory(context) {
-  const settings = context.get(context.constants.SETTINGS);
-  const maybeKey = get(settings, 'core.key', undefined);
-  const maybeTT = get(settings, 'core.trafficType', undefined);
-
-  if (settings.mode === LOCALHOST_MODE && maybeKey === undefined) {
-    settings.core.key = 'localhost_key';
-  } else {
-    settings.core.key = validateKey(maybeKey, 'Client instantiation');
-  }
-
-  // Key is also binded to the .track method. Same thing happens with trafficType but only if present on configs. (not required)
-  const trackBindings = [settings.core.key];
-  if (maybeTT !== undefined) {
-    const tt = validateTrafficType(maybeTT, 'Client instantiation');
-    settings.core.trafficType = tt;
-    trackBindings.push(tt);
-  }
-
-  const client = ClientAttributesDecorationLayer(context, true, trackBindings.length > 1);
-  client.isBrowserClient = true;
-
-  // In the browser land, we can bind the key and the traffic type (if provided)
-  client.getTreatment = client.getTreatment.bind(client, settings.core.key);
-  client.getTreatmentWithConfig = client.getTreatmentWithConfig.bind(client, settings.core.key);
-  client.getTreatments = client.getTreatments.bind(client, settings.core.key);
-  client.getTreatmentsWithConfig = client.getTreatmentsWithConfig.bind(client, settings.core.key);
-  client.track = client.track.bind(client, ...trackBindings);
-
-  return client;
-}
-
-export default BrowserClientFactory;

package/src/client/client.js

@@ -1,131 +0,0 @@
-import logFactory from '../utils/logger';
-const log = logFactory('splitio-client');
-import { evaluateFeature, evaluateFeatures } from '../engine/evaluator';
-import ImpressionsTracker from '../trackers/impressions';
-import EventTracker from '../trackers/event';
-import tracker from '../utils/timeTracker';
-import thenable from '../utils/promise/thenable';
-import { matching, bucketing } from '../utils/key/factory';
-/* asynchronous validations that live on the client. */
-import { validateSplitExistance, validateTrafficTypeExistance } from '../utils/inputValidation';
-import { SDK_NOT_READY } from '../utils/labels';
-import { CONTROL } from '../utils/constants';
-
-function ClientFactory(context) {
-  const storage = context.get(context.constants.STORAGE);
-  const metricCollectors = context.get(context.constants.COLLECTORS);
-  const impressionsTracker = ImpressionsTracker(context);
-  const eventTracker = EventTracker(context);
-
-  function getTreatment(key, splitName, attributes, withConfig = false) {
-    const taskToBeTracked = tracker.TaskNames[withConfig ? 'SDK_GET_TREATMENT_WITH_CONFIG' : 'SDK_GET_TREATMENT'];
-    const stopLatencyTracker = tracker.start(taskToBeTracked, metricCollectors);
-    const evaluation = evaluateFeature(key, splitName, attributes, storage);
-
-    const wrapUp = (evaluationResult) => {
-      const treatment = processEvaluation(evaluationResult, splitName, key, attributes, withConfig, `getTreatment${withConfig ? 'withConfig' : ''}`);
-      impressionsTracker.track();
-      stopLatencyTracker();
-      return treatment;
-    };
-
-    return thenable(evaluation) ? evaluation.then((res) => wrapUp(res)) : wrapUp(evaluation);
-  }
-
-  function getTreatmentWithConfig(key, splitName, attributes) {
-    return getTreatment(key, splitName, attributes, true);
-  }
-
-  function getTreatments(key, splitNames, attributes, withConfig = false) {
-    const taskToBeTracked = tracker.TaskNames[withConfig ? 'SDK_GET_TREATMENTS_WITH_CONFIG' : 'SDK_GET_TREATMENTS'];
-    const stopLatencyTracker = tracker.start(taskToBeTracked, metricCollectors);
-
-    const wrapUp = (evaluationResults) => {
-      const results = {};
-      Object.keys(evaluationResults).forEach(splitName => {
-        results[splitName] = processEvaluation(evaluationResults[splitName], splitName, key, attributes, withConfig, `getTreatments${withConfig ? 'withConfig' : ''}`);
-      });
-      impressionsTracker.track();
-      stopLatencyTracker();
-      return results;
-    };
-
-    const evaluations = evaluateFeatures(key, splitNames, attributes, storage);
-
-    return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
-  }
-
-  function getTreatmentsWithConfig(key, splitNames, attributes) {
-    return getTreatments(key, splitNames, attributes, true);
-  }
-
-  // Internal function
-  function processEvaluation(
-    evaluation,
-    splitName,
-    key,
-    attributes,
-    withConfig,
-    invokingMethodName
-  ) {
-    const isSdkReady = context.get(context.constants.READY, true) || context.get(context.constants.READY_FROM_CACHE, true);
-    const matchingKey = matching(key);
-    const bucketingKey = bucketing(key);
-
-    // If the SDK was not ready, treatment may be incorrect due to having Splits but not segments data.
-    if (!isSdkReady) {
-      evaluation = { treatment: CONTROL, label: SDK_NOT_READY };
-    }
-
-    const { treatment, label, changeNumber, config = null } = evaluation;
-    log.info(`Split: ${splitName}. Key: ${matchingKey}. Evaluation: ${treatment}. Label: ${label}`);
-
-    if (validateSplitExistance(context, splitName, label, invokingMethodName)) {
-      log.info('Queueing corresponding impression.');
-      impressionsTracker.queue({
-        feature: splitName,
-        keyName: matchingKey,
-        treatment,
-        time: Date.now(),
-        bucketingKey,
-        label,
-        changeNumber
-      }, attributes);
-    }
-
-    if (withConfig) {
-      return {
-        treatment,
-        config
-      };
-    }
-
-    return treatment;
-  }
-
-  function track(key, trafficTypeName, eventTypeId, value = null, properties = null, size = 1024) {
-    const matchingKey = matching(key);
-    const timestamp = Date.now();
-    const eventData = {
-      eventTypeId,
-      trafficTypeName,
-      value,
-      timestamp,
-      key: matchingKey,
-      properties
-    };
-
-    // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
-    validateTrafficTypeExistance(trafficTypeName, context, 'track');
-
-    return eventTracker.track(eventData, size);
-  }
-
-  return {
-    getTreatment, getTreatmentWithConfig,
-    getTreatments, getTreatmentsWithConfig,
-    track
-  };
-}
-
-export default ClientFactory;

package/src/client/inputValidation.js

@@ -1,130 +0,0 @@
-import objectAssign from 'object-assign';
-import ClientFactory from './client';
-import {
-  validateAttributes,
-  validateEvent,
-  validateEventValue,
-  validateEventProperties,
-  validateKey,
-  validateSplit,
-  validateSplits,
-  validateTrafficType,
-  validateIfDestroyed,
-  validateIfReady
-} from '../utils/inputValidation';
-import { startsWith } from '../utils/lang';
-import { STORAGE_REDIS, CONTROL, CONTROL_WITH_CONFIG } from '../utils/constants';
-
-/**
- * We will validate the input before actually executing the client methods. We should "guard" the client here,
- * while not polluting the "real" implementation of those methods.
- */
-function ClientInputValidationLayer(context, isKeyBinded, isTTBinded) {
-  const settings = context.get(context.constants.SETTINGS);
-  const isStorageSync = settings.storage.type !== STORAGE_REDIS;
-  // instantiate the client
-  const client = ClientFactory(context);
-  // Keep a reference to the original methods
-  const clientGetTreatment = client.getTreatment;
-  const clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
-  const clientGetTreatments = client.getTreatments;
-  const clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
-  const clientTrack = client.track;
-
-  /**
-   * Avoid repeating this validations code
-   */
-  function validateEvaluationParams(maybeKey, maybeSplitOrSplits, maybeAttributes, methodName) {
-    const multi = startsWith(methodName, 'getTreatments');
-    const key = isKeyBinded ? maybeKey : validateKey(maybeKey, methodName);
-    const splitOrSplits = multi ? validateSplits(maybeSplitOrSplits, methodName) : validateSplit(maybeSplitOrSplits, methodName);
-    const attributes = validateAttributes(maybeAttributes, methodName);
-    const isOperational = validateIfDestroyed(context);
-
-    validateIfReady(context, methodName);
-
-    const valid = isOperational && key && splitOrSplits && attributes !== false;
-
-    return {
-      valid,
-      key,
-      splitOrSplits,
-      attributes
-    };
-  }
-
-  client.getTreatment = function getTreatment(maybeKey, maybeSplit, maybeAttributes) {
-    const params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatment');
-
-    if (params.valid) {
-      return clientGetTreatment(params.key, params.splitOrSplits, params.attributes);
-    } else {
-      if (isStorageSync) return CONTROL;
-
-      return Promise.resolve(CONTROL);
-    }
-  };
-
-  client.getTreatmentWithConfig = function getTreatmentWithConfig(maybeKey, maybeSplit, maybeAttributes) {
-    const params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatmentWithConfig');
-
-    if (params.valid) {
-      return clientGetTreatmentWithConfig(params.key, params.splitOrSplits, params.attributes);
-    } else {
-      if (isStorageSync) return objectAssign({}, CONTROL_WITH_CONFIG);
-
-      return Promise.resolve(objectAssign({}, CONTROL_WITH_CONFIG));
-    }
-  };
-
-  client.getTreatments = function getTreatments(maybeKey, maybeSplits, maybeAttributes) {
-    const params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatments');
-
-    if (params.valid) {
-      return clientGetTreatments(params.key, params.splitOrSplits, params.attributes);
-    } else {
-      const res = {};
-      if (params.splitOrSplits) params.splitOrSplits.forEach(split => res[split] = CONTROL);
-
-      if (isStorageSync) return res;
-
-      return Promise.resolve(res);
-    }
-  };
-
-  client.getTreatmentsWithConfig = function getTreatmentsWithConfig(maybeKey, maybeSplits, maybeAttributes) {
-    const params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatmentsWithConfig');
-
-    if (params.valid) {
-      return clientGetTreatmentsWithConfig(params.key, params.splitOrSplits, params.attributes);
-    } else {
-      const res = {};
-      if (params.splitOrSplits) params.splitOrSplits.forEach(split => res[split] = objectAssign({}, CONTROL_WITH_CONFIG));
-
-      if (isStorageSync) return res;
-
-      return Promise.resolve(res);
-    }
-  };
-
-  client.track = function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
-    const key = isKeyBinded ? maybeKey : validateKey(maybeKey, 'track');
-    const tt = isTTBinded ? maybeTT : validateTrafficType(maybeTT, 'track');
-    const event = validateEvent(maybeEvent, 'track');
-    const eventValue = validateEventValue(maybeEventValue, 'track');
-    const { properties, size } = validateEventProperties(maybeProperties, 'track');
-    const isOperational = validateIfDestroyed(context);
-
-    if (isOperational && key && tt && event && eventValue !== false && properties !== false) {
-      return clientTrack(key, tt, event, eventValue, properties, size);
-    } else {
-      if (isStorageSync) return false;
-
-      return Promise.resolve(false);
-    }
-  };
-
-  return client;
-}
-
-export default ClientInputValidationLayer;

package/src/client/node.js

@@ -1,8 +0,0 @@
-import ClientWithInputValidationLayer from './inputValidation';
-
-export default function NodeClientFactory(context) {
-  const client = ClientWithInputValidationLayer(context);
-  client.isBrowserClient = false;
-
-  return client;
-}

package/src/client/package.json

@@ -1,4 +0,0 @@
-{
-  "main": "./node.js",
-  "browser": "./browser.js"
-}