@splitsoftware/splitio 10.16.0 → 10.16.2-rc.0

package/src/client/attributesDecoration.js

@@ -0,0 +1,112 @@
+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,5 +1,5 @@
 import { get } from '../utils/lang';
-import ClientWithInputValidationLayer from './inputValidation';
+import ClientAttributesDecorationLayer from './attributesDecoration';
 import { LOCALHOST_MODE } from '../utils/constants';
 import {
   validateKey,
@@ -25,7 +25,7 @@ function BrowserClientFactory(context) {
     trackBindings.push(tt);
   }
 
-  const client = ClientWithInputValidationLayer(context, true, trackBindings.length > 1);
+  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)

package/src/engine/engine/murmur3/murmur3_128.js

@@ -265,7 +265,7 @@ function hash128x64(key /*: string */, seed /*: number */) /*: string */ {
 
 /**
  * x64 version of Murmur3 for 128bits.
- * Used in hashImpression128.
+ *
  * @param {string} str
  */
 export function hash128(str /*: string */, seed /*: number */) /*: string */ {

package/src/engine/engine/murmur3/murmur3_128_x86.js

@@ -179,10 +179,9 @@ function hash128x86(key /*: string */, seed /*: number */) /*: string */ {
 
 /**
  * x86 version of Murmur3 for 128bits.
- * @param {string} str
+ * Used by hashImpression128 because in JS it is more efficient than the x64 version, no matter the underlying OS/CPU arch.
  *
- * @TODO Test and use in hashImpression128 instead of the x64 version,
- * because it is more time efficient in JS, no matter the underlying CPU arch.
+ * @param {string} str
  */
 export function hash128(str /*: string */, seed /*: number */) /*: string */ {
   return hash128x86(UTF16ToUTF8(str), seed >>> 0);

package/src/engine/evaluator/index.js

@@ -17,7 +17,6 @@ limitations under the License.
 import Engine from '../';
 import thenable from '../../utils/promise/thenable';
 import * as LabelsConstants from '../../utils/labels';
-import { get } from '../../utils/lang';
 import { CONTROL } from '../../utils/constants';
 
 const treatmentException = {
@@ -103,17 +102,17 @@ function getEvaluation(
     const split = Engine.parse(splitJSON, storage);
     evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
-    // If the storage is async, evaluation and changeNumber will return a thenable
+    // If the storage is async and the evaluated split uses segment, evaluation is thenable
     if (thenable(evaluation)) {
       return evaluation.then(result => {
         result.changeNumber = split.getChangeNumber();
-        result.config = get(splitJSON, `configurations.${result.treatment}`, null);
+        result.config = splitJSON.configurations && splitJSON.configurations[result.treatment] || null;
 
         return result;
       });
     } else {
       evaluation.changeNumber = split.getChangeNumber(); // Always sync and optional
-      evaluation.config = get(splitJSON, `configurations.${evaluation.treatment}`, null);
+      evaluation.config = splitJSON.configurations && splitJSON.configurations[evaluation.treatment] || null;
     }
   }
 

package/src/engine/matchers/index.js

@@ -13,7 +13,6 @@ 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 { types } from './types';
 import allMatcher from './all';
 import segmentMatcher from './segment';
 import whitelistMatcher from './whitelist';
@@ -32,6 +31,27 @@ import dependencyMatcher from './dependency';
 import booleanMatcher from './boolean';
 import stringMatcher from './string';
 
+const matchers = [
+  undefined, // UNDEFINED: 0,
+  allMatcher, // ALL_KEYS: 1,
+  segmentMatcher, // IN_SEGMENT: 2,
+  whitelistMatcher, // WHITELIST: 3,
+  eqMatcher, // EQUAL_TO: 4,
+  gteMatcher, // GREATER_THAN_OR_EQUAL_TO: 5,
+  lteMatcher, // LESS_THAN_OR_EQUAL_TO: 6,
+  betweenMatcher, // BETWEEN: 7,
+  equalToSetMatcher, // EQUAL_TO_SET: 8,
+  containsAnySetMatcher, // CONTAINS_ANY_OF_SET: 9,
+  containsAllSetMatcher, // CONTAINS_ALL_OF_SET: 10,
+  partOfSetMatcher, // PART_OF_SET: 11,
+  ewMatcher, // ENDS_WITH: 12,
+  swMatcher, // STARTS_WITH: 13,
+  containsStrMatcher, // CONTAINS_STRING: 14,
+  dependencyMatcher, // IN_SPLIT_TREATMENT: 15,
+  booleanMatcher, // EQUAL_TO_BOOLEAN: 16,
+  stringMatcher // MATCHES_STRING: 17
+];
+
 /**
  * Matcher factory.
  */
@@ -43,41 +63,7 @@ function MatcherFactory(matcherDto, storage) {
 
   let matcherFn;
 
-  if (type === types.ALL) {
-    matcherFn = allMatcher(value);
-  } else if (type === types.SEGMENT) {
-    matcherFn = segmentMatcher(value, storage);
-  } else if (type === types.WHITELIST) {
-    matcherFn = whitelistMatcher(value);
-  } else if (type === types.EQUAL_TO) {
-    matcherFn = eqMatcher(value);
-  } else if (type === types.GREATER_THAN_OR_EQUAL_TO) {
-    matcherFn = gteMatcher(value);
-  } else if (type === types.LESS_THAN_OR_EQUAL_TO) {
-    matcherFn = lteMatcher(value);
-  } else if (type === types.BETWEEN) {
-    matcherFn = betweenMatcher(value);
-  } else if (type === types.EQUAL_TO_SET) {
-    matcherFn = equalToSetMatcher(value);
-  } else if (type === types.CONTAINS_ANY_OF_SET) {
-    matcherFn = containsAnySetMatcher(value);
-  } else if (type === types.CONTAINS_ALL_OF_SET) {
-    matcherFn = containsAllSetMatcher(value);
-  } else if (type === types.PART_OF_SET) {
-    matcherFn = partOfSetMatcher(value);
-  } else if (type === types.STARTS_WITH) {
-    matcherFn = swMatcher(value);
-  } else if (type === types.ENDS_WITH) {
-    matcherFn = ewMatcher(value);
-  } else if (type === types.CONTAINS_STRING) {
-    matcherFn = containsStrMatcher(value);
-  } else if (type === types.IN_SPLIT_TREATMENT) {
-    matcherFn = dependencyMatcher(value, storage);
-  } else if (type === types.EQUAL_TO_BOOLEAN) {
-    matcherFn = booleanMatcher(value);
-  } else if (type === types.MATCHES_STRING) {
-    matcherFn = stringMatcher(value);
-  }
+  if (matchers[type]) matcherFn = matchers[type](value, storage); // There is no index-out-of-bound exception in JavaScript
 
   return matcherFn;
 }

package/src/engine/matchers/types.js

@@ -15,28 +15,28 @@ limitations under the License.
 **/
 
 // @WARNING Symbol is not correctly working in PhantomJS
-export const types = {
-  ALL: 1,
-  SEGMENT: 2,
+export const matcherTypes = {
+  UNDEFINED: 0,
+  ALL_KEYS: 1,
+  IN_SEGMENT: 2,
   WHITELIST: 3,
   EQUAL_TO: 4,
   GREATER_THAN_OR_EQUAL_TO: 5,
   LESS_THAN_OR_EQUAL_TO: 6,
   BETWEEN: 7,
-  UNDEFINED: 8,
-  EQUAL_TO_SET: 9,
-  CONTAINS_ANY_OF_SET: 10,
-  CONTAINS_ALL_OF_SET: 11,
-  PART_OF_SET: 12,
-  ENDS_WITH: 13,
-  STARTS_WITH: 14,
-  CONTAINS_STRING: 15,
-  IN_SPLIT_TREATMENT: 16,
-  EQUAL_TO_BOOLEAN: 17,
-  MATCHES_STRING: 18
+  EQUAL_TO_SET: 8,
+  CONTAINS_ANY_OF_SET: 9,
+  CONTAINS_ALL_OF_SET: 10,
+  PART_OF_SET: 11,
+  ENDS_WITH: 12,
+  STARTS_WITH: 13,
+  CONTAINS_STRING: 14,
+  IN_SPLIT_TREATMENT: 15,
+  EQUAL_TO_BOOLEAN: 16,
+  MATCHES_STRING: 17
 };
 
-export const dataTypes = {
+export const matcherDataTypes = {
   BOOLEAN: 'BOOLEAN',
   STRING: 'STRING',
   NUMBER: 'NUMBER',
@@ -45,43 +45,8 @@ export const dataTypes = {
   NOT_SPECIFIED: 'NOT_SPECIFIED'
 };
 
-export const mapper = (matcherType) => {
-  switch (matcherType) {
-    case 'ALL_KEYS':
-      return types.ALL;
-    case 'IN_SEGMENT':
-      return types.SEGMENT;
-    case 'WHITELIST':
-      return types.WHITELIST;
-    case 'EQUAL_TO':
-      return types.EQUAL_TO;
-    case 'GREATER_THAN_OR_EQUAL_TO':
-      return types.GREATER_THAN_OR_EQUAL_TO;
-    case 'LESS_THAN_OR_EQUAL_TO':
-      return types.LESS_THAN_OR_EQUAL_TO;
-    case 'BETWEEN':
-      return types.BETWEEN;
-    case 'EQUAL_TO_SET':
-      return types.EQUAL_TO_SET;
-    case 'CONTAINS_ANY_OF_SET':
-      return types.CONTAINS_ANY_OF_SET;
-    case 'CONTAINS_ALL_OF_SET':
-      return types.CONTAINS_ALL_OF_SET;
-    case 'PART_OF_SET':
-      return types.PART_OF_SET;
-    case 'ENDS_WITH':
-      return types.ENDS_WITH;
-    case 'STARTS_WITH':
-      return types.STARTS_WITH;
-    case 'CONTAINS_STRING':
-      return types.CONTAINS_STRING;
-    case 'IN_SPLIT_TREATMENT':
-      return types.IN_SPLIT_TREATMENT;
-    case 'EQUAL_TO_BOOLEAN':
-      return types.EQUAL_TO_BOOLEAN;
-    case 'MATCHES_STRING':
-      return types.MATCHES_STRING;
-    default:
-      return types.UNDEFINED;
-  }
-};
+export function matcherTypesMapper(matcherType) {
+  const type = matcherTypes[matcherType];
+  if (type) return type;
+  else return matcherTypes.UNDEFINED;
+}

package/src/engine/transforms/matcherGroup.js

@@ -13,10 +13,7 @@ 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 {
-  types as matcherTypes,
-  mapper as matcherTypesMapper
-} from '../matchers/types';
+import { matcherTypes, matcherTypesMapper } from '../matchers/types';
 import segmentTransform from './segment';
 import whitelistTransform from './whitelist';
 
@@ -33,7 +30,7 @@ function transform(matcherGroup) {
   let type = matcherTypesMapper(matcherType);
   let value = undefined;
 
-  if (type === matcherTypes.SEGMENT) {
+  if (type === matcherTypes.IN_SEGMENT) {
     value = segmentTransform(segmentObject);
   } else if (type === matcherTypes.WHITELIST) {
     value = whitelistTransform(whitelistObject);

package/src/engine/transforms/matchers.js

@@ -15,11 +15,7 @@ limitations under the License.
 **/
 
 import { findIndex } from '../../utils/lang';
-import {
-  types as matcherTypes,
-  mapper as matcherTypesMapper,
-  dataTypes as matcherDataTypes
-} from '../matchers/types';
+import { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/types';
 import segmentTransform from './segment';
 import whitelistTransform from './whitelist';
 import setTransform from './set';
@@ -49,7 +45,7 @@ function transform(matchers) {
     let dataType = matcherDataTypes.STRING;
     let value = undefined;
 
-    if (type === matcherTypes.SEGMENT) {
+    if (type === matcherTypes.IN_SEGMENT) {
       value = segmentTransform(segmentObject);
     } else if (type === matcherTypes.WHITELIST) {
       value = whitelistTransform(whitelistObject);

package/src/engine/value/sanitize.js

@@ -18,12 +18,7 @@ import logFactory from '../../utils/logger';
 const log = logFactory('splitio-engine:sanitize');
 import { isObject, uniq, toString, toNumber } from '../../utils/lang';
 import { zeroSinceHH, zeroSinceSS } from '../convertions';
-import {
-  types as matcherTypes,
-  dataTypes as matcherDataTypes
-} from '../matchers/types';
-const MATCHERS = matcherTypes;
-const DATA_TYPES = matcherDataTypes;
+import { matcherTypes, matcherDataTypes } from '../matchers/types';
 
 function sanitizeNumber(val) {
   const num = toNumber(val);
@@ -72,13 +67,13 @@ function dependencyProcessor(sanitizedValue, attributes) {
  */
 function getProcessingFunction(matcherTypeID, dataType) {
   switch (matcherTypeID) {
-    case MATCHERS.EQUAL_TO:
+    case matcherTypes.EQUAL_TO:
       return dataType === 'DATETIME' ? zeroSinceHH : undefined;
-    case MATCHERS.GREATER_THAN_OR_EQUAL_TO:
-    case MATCHERS.LESS_THAN_OR_EQUAL_TO:
-    case MATCHERS.BETWEEN:
+    case matcherTypes.GREATER_THAN_OR_EQUAL_TO:
+    case matcherTypes.LESS_THAN_OR_EQUAL_TO:
+    case matcherTypes.BETWEEN:
       return dataType === 'DATETIME' ? zeroSinceSS : undefined;
-    case MATCHERS.IN_SPLIT_TREATMENT:
+    case matcherTypes.IN_SPLIT_TREATMENT:
       return dependencyProcessor;
     default:
       return undefined;
@@ -90,20 +85,20 @@ function sanitizeValue(matcherTypeID, value, dataType, attributes) {
   let sanitizedValue;
 
   switch (dataType) {
-    case DATA_TYPES.NUMBER:
-    case DATA_TYPES.DATETIME:
+    case matcherDataTypes.NUMBER:
+    case matcherDataTypes.DATETIME:
       sanitizedValue = sanitizeNumber(value);
       break;
-    case DATA_TYPES.STRING:
+    case matcherDataTypes.STRING:
       sanitizedValue = sanitizeString(value);
       break;
-    case DATA_TYPES.SET:
+    case matcherDataTypes.SET:
       sanitizedValue = sanitizeArray(value);
       break;
-    case DATA_TYPES.BOOLEAN:
+    case matcherDataTypes.BOOLEAN:
       sanitizedValue = sanitizeBoolean(value);
       break;
-    case DATA_TYPES.NOT_SPECIFIED:
+    case matcherDataTypes.NOT_SPECIFIED:
       sanitizedValue = value;
       break;
     default:

package/src/impressions/hasher/hashImpression128.js

@@ -1,4 +1,4 @@
-import { hash128 } from '../../engine/engine/murmur3/murmur3_128';
+import { hash128 } from '../../engine/engine/murmur3/murmur3_128_x86';
 import { buildKey } from './buildKey';
 
 export function hashImpression128(impression) {

package/src/impressions/observer/observer.js

@@ -7,8 +7,6 @@ class ImpressionObserver {
   }
 
   testAndSet(impression) {
-    if (!impression) return null;
-
     const hash = this.hasher(impression);
     const previous = this.cache.get(hash);
     this.cache.set(hash, impression.time);

package/src/producer/updater/SplitChangesFromObject.js

@@ -13,6 +13,7 @@ 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 { STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { forOwn } from '../../utils/lang';
 import logFactory from '../../utils/logger';
 const log = logFactory('splitio-producer:offline');
@@ -59,7 +60,6 @@ function FromObjectUpdaterFactory(Fetcher, context) {
 
       return Promise.all([
         storage.splits.flush(), // required to sync removed splits from mock
-        storage.splits.setChangeNumber(Date.now()),
         storage.splits.addSplits(splits)
       ]).then(() => {
         readiness.splits.emit(readiness.splits.SDK_SPLITS_ARRIVED);
@@ -67,7 +67,7 @@ function FromObjectUpdaterFactory(Fetcher, context) {
         if (startingUp) {
           startingUp = false;
           // Emits SDK_READY_FROM_CACHE
-          if (storage.splits.checkCache()) readiness.splits.emit(readiness.splits.SDK_SPLITS_CACHE_LOADED);
+          if (settings.storage.__originalType === STORAGE_LOCALSTORAGE) readiness.splits.emit(readiness.splits.SDK_SPLITS_CACHE_LOADED);
           // Only emits SDK_SEGMENTS_ARRIVED the first time for SDK_READY
           readiness.segments.emit(readiness.segments.SDK_SEGMENTS_ARRIVED);
         }

package/src/storage/AttributesCache/InMemory.js

@@ -0,0 +1,75 @@
+import objectAssign from 'object-assign';
+
+class AttributesCacheInMemory {
+
+  constructor() {
+    this.attributesCache = {};
+  }
+
+  /**
+   * Create or update the value for the given attribute
+   * 
+   * @param {string} attributeName attribute name
+   * @param {Object} attributeValue attribute value
+   * @returns {boolean} the attribute was stored 
+   */
+  setAttribute(attributeName, attributeValue) {
+    this.attributesCache[attributeName] = attributeValue;
+    return true;
+  }
+
+  /**
+   * Retrieves the value of a given attribute
+   * 
+   * @param {string} attributeName attribute name
+   * @returns {Object?} stored attribute value
+   */
+  getAttribute(attributeName) {
+    return this.attributesCache[attributeName];
+  }
+
+  /**
+   * Create or update all the given attributes
+   * 
+   * @param {[string, Object]} attributes attributes to create or update
+   * @returns {boolean} attributes were stored
+   */
+  setAttributes(attributes) {
+    this.attributesCache = objectAssign(this.attributesCache, attributes);
+    return true;
+  }
+
+  /**
+   * Retrieve the full attributes map
+   * 
+   * @returns {Map<string, Object>} stored attributes
+   */
+  getAll() {
+    return this.attributesCache;
+  }
+
+  /**
+   * Removes a given attribute from the map
+   * 
+   * @param {string} attributeName attribute to remove
+   * @returns {boolean} attribute removed
+   */
+  removeAttribute(attributeName) {
+    if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {
+      delete this.attributesCache[attributeName];
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Clears all attributes stored in the SDK
+   * 
+   */
+  clear() {
+    this.attributesCache = {};
+  }
+
+}
+
+export default AttributesCacheInMemory;

package/src/sync/PushManager/index.js

@@ -247,19 +247,12 @@ export default function PushManagerFactory(context, clientContexts /* undefined
           }
 
           forOwn(clients, ({ hash64, worker }) => {
-            if (added.has(hash64.dec)) {
+            const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
+            if (add !== undefined) {
               worker.put(parsedData.changeNumber, {
                 name: parsedData.segmentName,
-                add: true
+                add
               });
-              return;
-            }
-            if (removed.has(hash64.dec)) {
-              worker.put(parsedData.changeNumber, {
-                name: parsedData.segmentName,
-                add: false
-              });
-              return;
             }
           });
           return;

package/src/sync/constants.js

@@ -40,4 +40,4 @@ export const ControlTypes = {
   STREAMING_PAUSED: 'STREAMING_PAUSED',
   STREAMING_RESUMED: 'STREAMING_RESUMED',
   STREAMING_RESET: 'STREAMING_RESET'
-};
+};

package/src/utils/inputValidation/attribute.js

@@ -0,0 +1,22 @@
+import { isString, numberIsFinite, isBoolean } from '../lang';
+import logFactory from '../logger';
+const log = logFactory('');
+
+export function validateAttribute(attributeKey, attributeValue, method) {
+  if (!isString(attributeKey) || attributeKey.length === 0){
+    log.warn(`${method}: you passed an invalid attribute name, attribute name must be a non-empty string.`);
+    return false;
+  }
+
+  const isStringVal = isString(attributeValue);
+  const isFiniteVal = numberIsFinite(attributeValue);
+  const isBoolVal = isBoolean(attributeValue);
+  const isArrayVal = Array.isArray(attributeValue);
+
+  if (!(isStringVal || isFiniteVal || isBoolVal || isArrayVal)) { // If it's not of valid type.
+    log.warn(`${method}: you passed an invalid attribute value for ${attributeKey}. Acceptable types are: string, number, boolean and array of strings.`);
+    return false;
+  }
+
+  return true;
+}

package/src/utils/inputValidation/attributes.js

@@ -1,5 +1,6 @@
 import { isObject } from '../lang';
 import logFactory from '../logger';
+import { validateAttribute } from './attribute';
 const log = logFactory('');
 
 export function validateAttributes(maybeAttrs, method) {
@@ -10,3 +11,16 @@ export function validateAttributes(maybeAttrs, method) {
   log.error(`${method}: attributes must be a plain object.`);
   return false;
 }
+
+export function validateAttributesDeep(maybeAttributes, method) {
+  if (!validateAttributes(maybeAttributes, method)) return false;
+  
+  let result = true;
+  Object.keys(maybeAttributes).forEach(attributeKey => {
+    if (!validateAttribute(attributeKey, maybeAttributes[attributeKey], method))
+      result = false;
+  });
+
+  return result;
+
+}