@splitsoftware/splitio 10.17.3 → 10.17.4-rc.2

package/src/settings/storage/browser.js

@@ -0,0 +1,43 @@
+import { isLocalStorageAvailable } from '@splitsoftware/splitio-commons/src/utils/env/isLocalStorageAvailable';
+import { LOCALHOST_MODE, STORAGE_MEMORY } from '@splitsoftware/splitio-commons/src/utils/constants';
+
+const STORAGE_LOCALSTORAGE = 'LOCALSTORAGE';
+
+export function validateStorage(settings) {
+  let {
+    log,
+    mode,
+    storage: {
+      type,
+      options = {},
+      prefix
+    } = { type: STORAGE_MEMORY },
+  } = settings;
+  let __originalType;
+
+  const fallbackToMemory = () => {
+    __originalType = type;
+    type = STORAGE_MEMORY;
+  };
+
+  // In localhost mode, fallback to Memory storage and track original type to emit SDK_READY_FROM_CACHE if corresponds.
+  // ATM, other mode settings (e.g., 'consumer') are ignored in client-side API, and so treated as standalone.
+  if (mode === LOCALHOST_MODE && type === STORAGE_LOCALSTORAGE) {
+    fallbackToMemory();
+  }
+
+  // If an invalid storage type is provided OR we want to use LOCALSTORAGE and
+  // it's not available, fallback into MEMORY
+  if (type !== STORAGE_MEMORY && type !== STORAGE_LOCALSTORAGE ||
+    type === STORAGE_LOCALSTORAGE && !isLocalStorageAvailable()) {
+    fallbackToMemory();
+    log.error('Invalid or unavailable storage. Fallbacking into MEMORY storage');
+  }
+
+  return {
+    type,
+    options,
+    prefix,
+    __originalType
+  };
+}

package/src/{utils/settings → settings}/storage/node.js

@@ -1,51 +1,34 @@
-/**
-Copyright 2016 Split Software
+import { LOCALHOST_MODE, STORAGE_MEMORY, STORAGE_REDIS, CONSUMER_MODE, STANDALONE_MODE } from '@splitsoftware/splitio-commons/src/utils/constants';
 
-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 { LOCALHOST_MODE, STORAGE_MEMORY, STORAGE_REDIS } from '../../constants';
-
-const ParseStorageSettings = (settings) => {
+export function validateStorage(settings) {
   let {
+    log,
     mode,
     storage: {
       type,
       options = {},
       prefix
-    }
+    } = { type: STORAGE_MEMORY }
   } = settings;
 
-  if (prefix) {
-    prefix += '.SPLITIO';
-  } else {
-    prefix = 'SPLITIO';
-  }
-
-  // In localhost mode we should force the user to use the MEMORY storage
-  if (mode === LOCALHOST_MODE) return {
-    type: STORAGE_MEMORY,
-    prefix
-  };
-
-  // In other cases we can have MEMORY or REDIS
+  // We can have MEMORY, REDIS or an invalid storage type
   switch (type) {
     case STORAGE_REDIS: {
+      // If passing REDIS storage in localhost or standalone mode, we log an error and fallback to MEMORY storage
+      if (mode === STANDALONE_MODE || mode === LOCALHOST_MODE) {
+        log.error('The provided REDIS storage is invalid for this mode. It requires consumer mode. Fallbacking into default MEMORY storage.');
+        return {
+          type: STORAGE_MEMORY,
+          prefix
+        };
+      }
       let {
         host,
         port,
         db,
         pass,
         url,
+        tls,
         connectionTimeout,
         operationTimeout
       } = options;
@@ -74,6 +57,10 @@ const ParseStorageSettings = (settings) => {
         newOpts.pass = pass;
       }
 
+      if (tls) {
+        newOpts.tls = tls;
+      }
+
       return {
         type,
         prefix,
@@ -84,12 +71,14 @@ const ParseStorageSettings = (settings) => {
     // For now, we don't have modifiers or settings for MEMORY in NodeJS
     case STORAGE_MEMORY:
     default: {
+      // If passing MEMORY storage in consumer mode, throw an error (no way to fallback to REDIS storage)
+      if (mode === CONSUMER_MODE) throw new Error('A REDIS storage is required on consumer mode');
+      // If passing an invalid storage type, log an error
+      if (type !== STORAGE_MEMORY) log.error(`The provided '${type}' storage type is invalid. Fallbacking into default MEMORY storage.`);
       return {
         type: STORAGE_MEMORY,
         prefix
       };
     }
   }
-};
-
-export default ParseStorageSettings;
+}

package/src/umd.js

@@ -1,3 +1,4 @@
 import { SplitFactory } from './index';
 
+// eslint-disable-next-line import/no-default-export
 export default SplitFactory;

package/types/splitio.d.ts

@@ -1,8 +1,9 @@
-// Type definitions for Javascript and Node Split Software SDK v8.1.0
+// Type definitions for Javascript and Node Split Software SDK
 // Project: http://www.split.io/
 // Definitions by: Nico Zelaya <https://github.com/NicoZelaya/>
 
 /// <reference types="google.analytics" />
+import { RedisOptions } from "ioredis";
 
 export as namespace SplitIO;
 export = SplitIO;
@@ -69,6 +70,7 @@ interface ISettings {
   readonly scheduler: {
     featuresRefreshRate: number,
     impressionsRefreshRate: number,
+    impressionsQueueSize: number,
     metricsRefreshRate: number,
     segmentsRefreshRate: number,
     offlineRefreshRate: number,
@@ -104,6 +106,10 @@ interface ISettings {
     splitFilters: SplitIO.SplitFilter[],
     impressionsMode: SplitIO.ImpressionsMode,
   }
+  /**
+   * User consent status if using in browser. Undefined if using in Node.
+   */
+  readonly userConsent?: SplitIO.ConsentStatus
 }
 /**
  * Log levels.
@@ -249,6 +255,13 @@ interface INodeBasicSettings extends ISharedSettings {
      * @default 300
      */
     impressionsRefreshRate?: number,
+    /**
+     * The maximum number of impression items we want to queue. If we queue more values, it will trigger a flush and reset the timer.
+     * If you use a 0 here, the queue will have no maximum size.
+     * @property {number} impressionsQueueSize
+     * @default 30000
+     */
+    impressionsQueueSize?: number,
     /**
      * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
      * @property {number} metricsRefreshRate
@@ -325,9 +338,9 @@ interface INodeBasicSettings extends ISharedSettings {
     type?: StorageType,
     /**
      * Options to be passed to the selected storage. Use it with type: 'REDIS'
-     * @property {Object} options
+     * @property {SplitIO.RedisStorageOptions} options
      */
-    options?: Object,
+    options?: SplitIO.RedisStorageOptions,
     /**
      * Optional prefix to prevent any kind of data collision between SDK versions.
      * @property {string} prefix
@@ -336,7 +349,8 @@ interface INodeBasicSettings extends ISharedSettings {
     prefix?: string
   },
   /**
-   * The SDK mode. Possible values are "standalone" (which is the default) and "consumer". For "localhost" mode, use "localhost" as authorizationKey.
+   * The SDK mode. Possible values are "standalone", which is the default when using a synchronous storage, like 'MEMORY' and 'LOCALSTORAGE',
+   * and "consumer", which must be set when using an asynchronous storage, like 'REDIS'. For "localhost" mode, use "localhost" as authorizationKey.
    * @property {SDKMode} mode
    * @default standalone
    */
@@ -625,6 +639,69 @@ declare namespace SplitIO {
    * @typedef {string} BrowserStorage
    */
   type BrowserStorage = 'MEMORY' | 'LOCALSTORAGE';
+  /**
+   * Options to be passed to the Redis storage. Use it with storage type: 'REDIS'.
+   * @typedef {Object} RedisStorageOptions
+   */
+  type RedisStorageOptions = {
+    /**
+     * Redis URL. If set, `host`, `port`, `db` and `pass` params will be ignored.
+     *
+     * Examples:
+     * ```
+     *   url: 'localhost'
+     *   url: '127.0.0.1:6379'
+     *   url: 'redis://:authpassword@127.0.0.1:6379/0'
+     * ```
+     * @property {string=} url
+     */
+    url?: string,
+    /**
+     * Redis host.
+     * @property {string=} host
+     * @default 'localhost'
+     */
+    host?: string,
+    /**
+     * Redis port.
+     * @property {number=} port
+     * @default 6379
+     */
+    port?: number,
+    /**
+     * Redis database to be used.
+     * @property {number=} db
+     * @default 0
+     */
+    db?: number,
+    /**
+     * Redis password. Don't define if no password is used.
+     * @property {string=} pass
+     * @default undefined
+     */
+    pass?: string,
+    /**
+     * The milliseconds before a timeout occurs during the initial connection to the Redis server.
+     * @property {number=} connectionTimeout
+     * @default 10000
+     */
+    connectionTimeout?: number,
+    /**
+     * The milliseconds before Redis commands are timeout by the SDK.
+     * Method calls that involve Redis commands, like `client.getTreatment` or `client.track` calls, are resolved when the commands success or timeout.
+     * @property {number=} operationTimeout
+     * @default 5000
+     */
+    operationTimeout?: number,
+    /**
+     * TLS configuration for Redis connection.
+     * @see {@link https://www.npmjs.com/package/ioredis#tls-options }
+     *
+     * @property {Object=} tls
+     * @default undefined
+     */
+    tls?: RedisOptions['tls'],
+  }
   /**
    * Impression listener interface. This is the interface that needs to be implemented
    * by the element you provide to the SDK as impression listener.
@@ -830,6 +907,11 @@ declare namespace SplitIO {
   * @typedef {string} ImpressionsMode
   */
   type ImpressionsMode = 'OPTIMIZED' | 'DEBUG';
+  /**
+   * User consent status.
+   * @typedef {string} ConsentStatus
+   */
+  type ConsentStatus = 'GRANTED' | 'DECLINED' | 'UNKNOWN';
   /**
    * Settings interface for SDK instances created on the browser
    * @interface IBrowserSettings
@@ -886,6 +968,13 @@ declare namespace SplitIO {
        * @default 60
        */
       impressionsRefreshRate?: number,
+      /**
+       * The maximum number of impression items we want to queue. If we queue more values, it will trigger a flush and reset the timer.
+       * If you use a 0 here, the queue will have no maximum size.
+       * @property {number} impressionsQueueSize
+       * @default 30000
+       */
+      impressionsQueueSize?: number,
       /**
        * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
        * @property {number} metricsRefreshRate
@@ -988,6 +1077,17 @@ declare namespace SplitIO {
      * @property {Object} integrations
      */
     integrations?: BrowserIntegration[],
+    /**
+     * User consent status. Possible values are `'GRANTED'`, which is the default, `'DECLINED'` or `'UNKNOWN'`.
+     * - `'GRANTED'`: the user has granted consent for tracking events and impressions. The SDK will send them to Split cloud.
+     * - `'DECLINED'`: the user has declined consent for tracking events and impressions. The SDK will not send them to Split cloud.
+     * - `'UNKNOWN'`: the user has neither granted nor declined consent for tracking events and impressions. The SDK will track them in its internal storage, and eventually send
+     * them or not if the consent status is updated to 'GRANTED' or 'DECLINED' respectively. The status can be updated at any time with the `setUserConsent` factory method.
+     *
+     * @typedef {string} userConsent
+     * @default 'GRANTED'
+     */
+    userConsent?: ConsentStatus
   }
   /**
    * Settings interface for SDK instances created on NodeJS.
@@ -1020,7 +1120,15 @@ declare namespace SplitIO {
        * @default SPLITIO
        */
       prefix?: string
-    }
+    },
+    /**
+     * The SDK mode. When using the default 'MEMORY' storage, the only possible value is "standalone", which is the default.
+     * For "localhost" mode, use "localhost" as authorizationKey.
+     *
+     * @property {'standalone'} mode
+     * @default standalone
+     */
+    mode?: 'standalone'
   }
   /**
    * Settings interface with async storage for SDK instances created on NodeJS.
@@ -1032,22 +1140,30 @@ declare namespace SplitIO {
   interface INodeAsyncSettings extends INodeBasicSettings {
     storage: {
       /**
-       * Redis storage type to be instantiated by the SDK.
+       * 'REDIS' storage type to be instantiated by the SDK.
        * @property {NodeAsyncStorage} type
        */
       type: NodeAsyncStorage,
       /**
        * Options to be passed to the selected storage. Use it with type: 'REDIS'
-       * @property {Object} options
+       * @property {SplitIO.RedisStorageOptions} options
        */
-      options?: Object,
+      options?: RedisStorageOptions,
       /**
        * Optional prefix to prevent any kind of data collision between SDK versions.
        * @property {string} prefix
        * @default SPLITIO
        */
       prefix?: string
-    }
+    },
+    /**
+     * The SDK mode. When using 'REDIS' storage type, the only possible value is "consumer", which is required.
+     *
+     * @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#state-sharing-redis-integration}
+     *
+     * @property {'consumer'} mode
+     */
+    mode: 'consumer'
   }
   /**
    * This represents the interface for the SDK instance with synchronous storage.
@@ -1096,6 +1212,25 @@ declare namespace SplitIO {
      * @returns {IBrowserClient} The client instance.
      */
     client(key: SplitKey, trafficType?: string): IBrowserClient
+    /**
+     * Set or update the user consent status. Possible values are `true` and `false`, which represent user consent `'GRANTED'` and `'DECLINED'` respectively.
+     * - `true ('GRANTED')`: the user has granted consent for tracking events and impressions. The SDK will send them to Split cloud.
+     * - `false ('DECLINED')`: the user has declined consent for tracking events and impressions. The SDK will not send them to Split cloud.
+     *
+     * NOTE: calling this method updates the user consent at a factory level, affecting all clients of the same factory.
+     *
+     * @function setUserConsent
+     * @param {boolean} userConsent The user consent status, true for 'GRANTED' and false for 'DECLINED'.
+     * @returns {boolean} Whether the provided param is a valid value (i.e., a boolean value) or not.
+     */
+    setUserConsent(userConsent: boolean): boolean;
+    /**
+     * Get the user consent status.
+     *
+     * @function getUserConsent
+     * @returns {ConsentStatus} The user consent status.
+     */
+    getUserConsent(): ConsentStatus;
   }
   /**
    * This represents the interface for the SDK instance with asynchronous storage.
@@ -1245,7 +1380,7 @@ declare namespace SplitIO {
     /**
      * Add an attribute to client's in memory attributes storage.
      *
-     * @param {string} attributeName Attrinute name
+     * @param {string} attributeName Attribute name
      * @param {AttributeType} attributeValue Attribute value
      * @returns {boolean} true if the attribute was stored and false otherwise
      */

package/es/client/attributesDecoration.js

@@ -1,116 +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';
-var 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) {
-  var client = ClientInputValidationLayer(context, isKeyBinded, isTTBinded);
-  var attributeStorage = new AttributesCacheInMemory(); // Keep a reference to the original methods
-
-  var clientGetTreatment = client.getTreatment;
-  var clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
-  var clientGetTreatments = client.getTreatments;
-  var 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 = function (attributeName, attributeValue) {
-    var 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 = function (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 = function (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 = function () {
-    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 = function (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 = function () {
-    return attributeStorage.clear();
-  };
-
-  client.getTreatment = function (maybeKey, maybeSplit, maybeAttributes) {
-    return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
-  };
-
-  client.getTreatmentWithConfig = function (maybeKey, maybeSplit, maybeAttributes) {
-    return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
-  };
-
-  client.getTreatments = function (maybeKey, maybeSplits, maybeAttributes) {
-    return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
-  };
-
-  client.getTreatmentsWithConfig = function (maybeKey, maybeSplits, maybeAttributes) {
-    return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
-  };
-
-  function combineAttributes(maybeAttributes) {
-    var storedAttributes = attributeStorage.getAll();
-
-    if (Object.keys(storedAttributes).length > 0) {
-      return objectAssign({}, storedAttributes, maybeAttributes);
-    }
-
-    return maybeAttributes;
-  }
-
-  return client;
-}

package/es/client/browser.js

@@ -1,39 +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) {
-  var _client$track;
-
-  var settings = context.get(context.constants.SETTINGS);
-  var maybeKey = get(settings, 'core.key', undefined);
-  var 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)
-
-
-  var trackBindings = [settings.core.key];
-
-  if (maybeTT !== undefined) {
-    var tt = validateTrafficType(maybeTT, 'Client instantiation');
-    settings.core.trafficType = tt;
-    trackBindings.push(tt);
-  }
-
-  var 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 = client.track).bind.apply(_client$track, [client].concat(trackBindings));
-  return client;
-}
-
-export default BrowserClientFactory;