@splitsoftware/splitio 10.16.1-rc.0 → 10.17.0

package/lib/utils/inputValidation/attributes.js

@@ -4,11 +4,14 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 exports.__esModule = true;
 exports.validateAttributes = validateAttributes;
+exports.validateAttributesDeep = validateAttributesDeep;
 
 var _lang = require("../lang");
 
 var _logger = _interopRequireDefault(require("../logger"));
 
+var _attribute = require("./attribute");
+
 var log = (0, _logger.default)('');
 
 function validateAttributes(maybeAttrs, method) {
@@ -17,4 +20,13 @@ function validateAttributes(maybeAttrs, method) {
     return maybeAttrs;
   log.error(method + ": attributes must be a plain object.");
   return false;
+}
+
+function validateAttributesDeep(maybeAttributes, method) {
+  if (!validateAttributes(maybeAttributes, method)) return false;
+  var result = true;
+  Object.keys(maybeAttributes).forEach(function (attributeKey) {
+    if (!(0, _attribute.validateAttribute)(attributeKey, maybeAttributes[attributeKey], method)) result = false;
+  });
+  return result;
 }

package/lib/utils/settings/index.js

@@ -44,7 +44,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.
 **/
-var version = '10.16.1-rc.0';
+var version = '10.17.0';
 var eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
 var authEndpointMatcher = /^\/v2\/auth/;
 var streamingEndpointMatcher = /^\/(sse|event-stream)/;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio",
-  "version": "10.16.1-rc.0",
+  "version": "10.17.0",
   "description": "Split SDK",
   "files": [
     "README.md",
@@ -46,7 +46,7 @@
     "eventsource": "^1.0.7"
   },
   "devDependencies": {
-    "@babel/cli": "^7.14.8",
+    "@babel/cli": "^7.15.7",
     "@babel/core": "^7.13.10",
     "@babel/plugin-transform-runtime": "^7.13.10",
     "@babel/preset-env": "^7.13.10",
@@ -55,8 +55,8 @@
     "copyfiles": "^2.4.1",
     "cross-env": "^7.0.3",
     "csv-streamify": "4.0.0",
-    "eslint": "^6.8.0",
-    "eslint-plugin-compat": "^3.9.0",
+    "eslint": "^8.0.1",
+    "eslint-plugin-compat": "^3.13.0",
     "fetch-mock": "^9.11.0",
     "karma": "^6.3.2",
     "karma-chrome-launcher": "^3.1.0",
@@ -94,7 +94,7 @@
     "check:version": "cross-env NODE_ENV=test tape -r @babel/register src/utils/__tests__/settings/index.spec.js",
     "test-browser-local": "cross-env NODE_ENV=test karma start karma/local.karma.conf.js",
     "test-browser-e2e-local": "cross-env NODE_ENV=test karma start karma/e2e.local.karma.conf.js",
-    "test-browser": "npm run test-browser-unit && npm run test-browser-online && npm run test-browser-offline && npm run test-browser-destroy && npm run test-browser-errors && npm run test-browser-push",
+    "test-browser": "npm run test-browser-unit && npm run test-browser-online && npm run test-browser-offline && npm run test-browser-destroy && npm run test-browser-errors && npm run test-browser-push && npm run test-browser-gaintegration",
     "test-browser-unit": "cross-env NODE_ENV=test karma start karma/ci.karma.conf.js",
     "test-browser-online": "cross-env NODE_ENV=test karma start karma/e2e.ci.karma.conf.js",
     "test-browser-offline": "cross-env NODE_ENV=test karma start karma/offline.karma.conf.js",
@@ -113,9 +113,7 @@
     "pretest-ts-decls": "npm run build-es && npm run build-cjs && npm link",
     "test-ts-decls": "./scripts/ts-tests.sh",
     "posttest-ts-decls": "npm unlink && npm install",
-    "browser-test-suite": "npm run test-browser-ci && npm run test-browser-e2e-ci && npm run test-browser-offline && npm run test-browser-destroy && npm run test-browser-errors && npm run test-browser-gaintegration",
-    "node-test-suite": "npm run test-node && npm run test-node-e2e && npm run test-node-destroy && npm run test-node-offline && npm run test-node-redis && npm run test-node-errors",
-    "test": "npm run browser-test-suite && npm run node-test-suite",
+    "test": "npm run test-node && npm run test-browser",
     "publish:rc": "npm run check && npm run build && npm publish --tag canary",
     "publish:stable": "npm run check && npm run build && npm publish"
   },

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/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/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/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;
+
+}

package/src/utils/settings/index.js

@@ -27,7 +27,7 @@ import { API } from '../../utils/logger';
 import { STANDALONE_MODE, STORAGE_MEMORY, CONSUMER_MODE, OPTIMIZED } from '../../utils/constants';
 import validImpressionsMode from './impressionsMode';
 
-const version = '10.16.1-rc.0';
+const version = '10.17.0';
 const eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
 const authEndpointMatcher = /^\/v2\/auth/;
 const streamingEndpointMatcher = /^\/(sse|event-stream)/;

package/types/index.d.ts

@@ -24,5 +24,5 @@ declare module JsSdk {
    * The settings parameter should be an object that complies with the SplitIO.IBrowserSettings.
    * For more information read the corresponding article: @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#configuration}
    */
-  export function SplitFactory(settings: SplitIO.IBrowserSettings): SplitIO.ISDK;
+  export function SplitFactory(settings: SplitIO.IBrowserSettings): SplitIO.IBrowserSDK;
 }