@splitsoftware/splitio 10.17.1-rc.0 → 10.17.3-rc.0

package/src/storage/SplitCache/InMemory.js

@@ -1,145 +0,0 @@
-import { numberIsFinite } from '../../utils/lang';
-import usesSegments from '../../utils/splits/usesSegments';
-import killLocally from './killLocally';
-
-class SplitCacheInMemory {
-
-  constructor() {
-    this.flush();
-  }
-
-  addSplit(splitName, split) {
-    const splitFromMemory = this.getSplit(splitName);
-    if (splitFromMemory) { // We had this Split already
-      const previousSplit = JSON.parse(splitFromMemory);
-
-      if (previousSplit.trafficTypeName) {
-        const previousTtName = previousSplit.trafficTypeName;
-        this.ttCache[previousTtName]--;
-        if (!this.ttCache[previousTtName]) delete this.ttCache[previousTtName];
-      }
-
-      if (usesSegments(previousSplit.conditions)) { // Substract from segments count for the previous version of this Split.
-        this.splitsWithSegmentsCount--;
-      }
-    }
-
-    const parsedSplit = JSON.parse(split);
-
-    if (parsedSplit) {
-      // Store the Split.
-      this.splitCache[splitName] = split;
-      // Update TT cache
-      const ttName = parsedSplit.trafficTypeName;
-      if (ttName) { // safeguard
-        if (!this.ttCache[ttName]) this.ttCache[ttName] = 0;
-        this.ttCache[ttName]++;
-      }
-
-      // Add to segments count for the new version of the Split
-      if (usesSegments(parsedSplit.conditions)) this.splitsWithSegmentsCount++;
-
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  addSplits(entries) {
-    let results = [];
-
-    entries.forEach(keyValuePair => {
-      results.push(this.addSplit(keyValuePair[0], keyValuePair[1]));
-    });
-
-    return results;
-  }
-
-  removeSplit(splitName) {
-    const split = this.getSplit(splitName);
-    if (split) {
-      // Delete the Split
-      delete this.splitCache[splitName];
-
-      const parsedSplit = JSON.parse(split);
-      const ttName = parsedSplit.trafficTypeName;
-
-      if (ttName) { // safeguard
-        this.ttCache[ttName]--; // Update tt cache
-        if (!this.ttCache[ttName]) delete this.ttCache[ttName];
-      }
-
-      // Update the segments count.
-      if (usesSegments(parsedSplit.conditions)) this.splitsWithSegmentsCount--;
-
-      return 1;
-    } else {
-      return 0;
-    }
-  }
-
-  removeSplits(splitNames) {
-    splitNames.forEach(n => this.removeSplit(n));
-
-    return splitNames.length;
-  }
-
-  getSplit(splitName) {
-    return this.splitCache[splitName];
-  }
-
-  setChangeNumber(changeNumber) {
-    this.changeNumber = changeNumber;
-
-    return true;
-  }
-
-  getChangeNumber() {
-    return this.changeNumber;
-  }
-
-  getAll() {
-    return this.getKeys().map(key => this.splitCache[key]);
-  }
-
-  getKeys() {
-    return Object.keys(this.splitCache);
-  }
-
-  trafficTypeExists(trafficType) {
-    return numberIsFinite(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
-  }
-
-  usesSegments() {
-    return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
-  }
-
-  flush() {
-    this.splitCache = {};
-    this.ttCache = {};
-    this.changeNumber = -1;
-    this.splitsWithSegmentsCount = 0;
-  }
-
-  /**
-   * Fetches multiple splits definitions.
-   */
-  fetchMany(splitNames) {
-    const splits = {};
-    splitNames.forEach(splitName => {
-      splits[splitName] = this.splitCache[splitName] || null;
-    });
-    return splits;
-  }
-
-  /**
-   * Check if the splits information is already stored in cache. In memory there is no cache to check.
-   */
-  checkCache() {
-    return false;
-  }
-}
-
-SplitCacheInMemory.prototype.killLocally = killLocally;
-
-export default SplitCacheInMemory;

package/src/storage/SplitCache/InRedis.js

@@ -1,187 +0,0 @@
-import { numberIsFinite, numberIsNaN } from '../../utils/lang';
-import logFactory from '../../utils/logger';
-const log = logFactory('splitio-storage:redis');
-
-/**
- * Discard errors for an answer of multiple operations.
- */
-const processPipelineAnswer = (results) =>
-  results.reduce((accum, errValuePair) => {
-    if (errValuePair[0] === null) accum.push(errValuePair[1]);
-    return accum;
-  }, []);
-
-class SplitCacheInRedis {
-
-  constructor(keys, redis) {
-    this.redis = redis;
-    this.keys = keys;
-    this.redisError = false;
-
-    this.redis.on('error', (e) => {
-      this.redisError = e;
-    });
-
-    this.redis.on('connect', () => {
-      this.redisError = false;
-    });
-  }
-
-  addSplit(splitName, split) {
-    return this.redis.set(
-      this.keys.buildSplitKey(splitName), split
-    ).then(
-      status => status === 'OK'
-    );
-  }
-
-  addSplits(entries) {
-    if (entries.length) {
-      const cmds = entries.map(keyValuePair => ['set', this.keys.buildSplitKey(keyValuePair[0]), keyValuePair[1]]);
-
-      return this.redis.pipeline(cmds)
-        .exec()
-        .then(processPipelineAnswer)
-        .then(answers => answers.map(status => status === 'OK'));
-    } else {
-      return [true];
-    }
-  }
-
-  /**
-   * Remove a given split from Redis. Returns the number of deleted keys.
-   */
-  removeSplit(splitName) {
-    return this.redis.del(this.keys.buildSplitKey(splitName));
-  }
-
-  /**
-   * Bulk delete of splits from Redis. Returns the number of deleted keys.
-   */
-  removeSplits(names) {
-    if (names.length) {
-      return this.redis.del(names.map(n => this.keys.buildSplitKey(n)));
-    } else {
-      return Promise.resolve(0);
-    }
-  }
-
-  /**
-   * Get split definition or null if it's not defined.
-   */
-  getSplit(splitName) {
-    if (this.redisError) {
-      log.error(this.redisError);
-
-      throw this.redisError;
-    }
-
-    return this.redis.get(this.keys.buildSplitKey(splitName));
-  }
-
-  /**
-   * Set till number.
-   *
-   * @TODO pending error handling
-   */
-  setChangeNumber(changeNumber) {
-    return this.redis.set(this.keys.buildSplitsTillKey(), changeNumber + '').then(
-      status => status === 'OK'
-    );
-  }
-
-  /**
-   * Get till number or null if it's not defined.
-   *
-   * @TODO pending error handling
-   */
-  getChangeNumber() {
-    return this.redis.get(this.keys.buildSplitsTillKey()).then(value => {
-      const i = parseInt(value, 10);
-
-      return numberIsNaN(i) ? -1 : i;
-    });
-  }
-
-  /**
-   * @TODO we need to benchmark which is the maximun number of commands we could
-   *       pipeline without kill redis performance.
-   */
-  getAll() {
-    return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(
-      (listOfKeys) => this.redis.pipeline(listOfKeys.map(k => ['get', k])).exec()
-    ).then(processPipelineAnswer);
-  }
-
-  getKeys() {
-    return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(
-      (listOfKeys) => listOfKeys.map(this.keys.extractKey)
-    );
-  }
-
-  trafficTypeExists(trafficType) {
-    // If there is a number there should be > 0, otherwise the TT is considered as not existent.
-    return this.redis.get(this.keys.buildTrafficTypeKey(trafficType))
-      .then(ttCount => {
-        ttCount = parseInt(ttCount, 10);
-        if (!numberIsFinite(ttCount) || ttCount < 0) {
-          log.info(`Could not validate traffic type existance of ${trafficType} due to data corruption of some sorts.`);
-          return false;
-        }
-
-        return ttCount > 0;
-      })
-      .catch(e => {
-        log.error(`Could not validate traffic type existance of ${trafficType} due to an error: ${e}.`);
-        // If there is an error, bypass the validation so the event can get tracked.
-        return true;
-      });
-  }
-
-  // noop, just keeping the interface. This is used by client-side implementations only.
-  usesSegments() {
-    return true;
-  }
-
-  /**
-   * Delete everything in the current database.
-   *
-   * @NOTE documentation says it never fails.
-   */
-  flush() {
-    return this.redis.flushdb().then(status => status === 'OK');
-  }
-
-  /**
-   * Fetches multiple splits definitions.
-   */
-  fetchMany(splitNames) {
-    if (this.redisError) {
-      log.error(this.redisError);
-
-      throw this.redisError;
-    }
-    const splits = {};
-    const keys = splitNames.map(splitName => this.keys.buildSplitKey(splitName));
-    return this.redis.mget(...keys)
-      .then(splitDefinitions => {
-        splitNames.forEach((splitName, idx) => {
-          splits[splitName] = splitDefinitions[idx];
-        });
-        return Promise.resolve(splits);
-      })
-      .catch(e => {
-        log.error(`Could not grab splits due to an error: ${e}.`);
-        return Promise.reject(e);
-      });
-  }
-
-  /**
-   * Check if the splits information is already stored in cache. Redis would actually be the cache.
-   */
-  checkCache() {
-    return false;
-  }
-}
-
-export default SplitCacheInRedis;

package/src/storage/SplitCache/killLocally.js

@@ -1,33 +0,0 @@
-import thenable from '../../utils/promise/thenable';
-
-/**
- * Kill `splitName` at `this` split storage, setting `defaultTreatment` and `changeNumber`,
- * only if the split exists and its `changeNumber` is older than the given one.
- * Used for SPLIT_KILL push notifications.
- *
- * @param {string} splitName
- * @param {string} defaultTreatment
- * @param {number} changeNumber
- * @returns {Promise} a promise that is resolved once the split kill is performed.
- * The fulfillment value is a boolean: `true` if the kill success updating the split or `false` if no split is updated, for instance,
- * if the `changeNumber` is old, if the `splitName` is not found, or if the storage fails to apply the update.
- */
-export default function killLocally(splitName, defaultTreatment, changeNumber) {
-  const split = this.getSplit(splitName);
-  const splitPromise = thenable(split) ? split : Promise.resolve(split);
-
-  return splitPromise.then((split) => {
-    if (split) {
-      const parsedSplit = JSON.parse(split);
-      if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
-        parsedSplit.killed = true;
-        parsedSplit.defaultTreatment = defaultTreatment;
-        parsedSplit.changeNumber = changeNumber;
-        const newSplit = JSON.stringify(parsedSplit);
-
-        return this.addSplit(splitName, newSplit);
-      }
-    }
-    return false;
-  });
-}

package/src/storage/browser.js

@@ -1,110 +0,0 @@
-import SplitCacheInMemory from './SplitCache/InMemory';
-import SplitCacheInLocalStorage from './SplitCache/InLocalStorage';
-import SegmentCacheInMemory from './SegmentCache/InMemory';
-import SegmentCacheInLocalStorage from './SegmentCache/InLocalStorage';
-import ImpressionsCacheInMemory from './ImpressionsCache/InMemory';
-import LatencyCacheInMemory from './LatencyCache/InMemory';
-import CountCacheInMemory from './CountCache/InMemory';
-import EventsCacheInMemory from './EventsCache/InMemory';
-import KeyBuilder from './Keys';
-import KeyBuilderLocalStorage from './KeysLocalStorage';
-import { STORAGE_MEMORY, STORAGE_LOCALSTORAGE } from '../utils/constants';
-
-// This value might be eventually set via a config parameter
-export const DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days
-
-const BrowserStorageFactory = context => {
-  const settings = context.get(context.constants.SETTINGS);
-  const { storage } = settings;
-
-  switch (storage.type) {
-    case STORAGE_MEMORY: {
-      const keys = new KeyBuilder(settings);
-
-      return {
-        splits: new SplitCacheInMemory,
-        segments: new SegmentCacheInMemory(keys),
-        impressions: new ImpressionsCacheInMemory,
-        metrics: new LatencyCacheInMemory,
-        count: new CountCacheInMemory,
-        events: new EventsCacheInMemory(context),
-
-        // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
-        shared(settings) {
-          const childKeyBuilder = new KeyBuilder(settings);
-
-          return {
-            splits: this.splits,
-            segments: new SegmentCacheInMemory(childKeyBuilder),
-            impressions: this.impressions,
-            metrics: this.metrics,
-            count: this.count,
-            events: this.events,
-
-            destroy() {
-              this.splits = new SplitCacheInMemory;
-              this.segments.flush();
-            }
-          };
-        },
-
-        destroy() {
-          this.splits.flush();
-          this.segments.flush();
-          this.impressions.clear();
-          this.metrics.clear();
-          this.count.clear();
-          this.events.clear();
-        }
-      };
-    }
-
-    case STORAGE_LOCALSTORAGE: {
-      const keys = new KeyBuilderLocalStorage(settings);
-      const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
-
-      return {
-        splits: new SplitCacheInLocalStorage(keys, expirationTimestamp, settings.sync.__splitFiltersValidation),
-        segments: new SegmentCacheInLocalStorage(keys),
-        impressions: new ImpressionsCacheInMemory,
-        metrics: new LatencyCacheInMemory,
-        count: new CountCacheInMemory,
-        events: new EventsCacheInMemory(context),
-
-        // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
-        shared(settings) {
-          const childKeysBuilder = new KeyBuilderLocalStorage(settings);
-
-          return {
-            splits: this.splits,
-            segments: new SegmentCacheInLocalStorage(childKeysBuilder),
-            impressions: this.impressions,
-            metrics: this.metrics,
-            count: this.count,
-            events: this.events,
-
-            destroy() {
-              this.splits = new SplitCacheInMemory;
-              this.segments = new SegmentCacheInMemory(childKeysBuilder);
-            }
-          };
-        },
-
-        destroy() {
-          this.splits = new SplitCacheInMemory;
-          this.segments = new SegmentCacheInMemory(new KeyBuilder(settings));
-          this.impressions.clear();
-          this.metrics.clear();
-          this.count.clear();
-          this.events.clear();
-        }
-      };
-    }
-
-    default:
-      throw new Error('Unsupported storage type');
-  }
-
-};
-
-export default BrowserStorageFactory;

package/src/storage/node.js

@@ -1,83 +0,0 @@
-import RedisAdapter from './RedisAdapter';
-import SplitCacheInMemory from './SplitCache/InMemory';
-import SplitCacheInRedis from './SplitCache/InRedis';
-import SegmentCacheInMemory from './SegmentCache/InMemory';
-import SegmentCacheInRedis from './SegmentCache/InRedis';
-import ImpressionsCacheInMemory from './ImpressionsCache/InMemory';
-import ImpressionsCacheInRedis from './ImpressionsCache/InRedis';
-import LatencyCacheInMemory from './LatencyCache/InMemory';
-import LatencyCacheInRedis from './LatencyCache/InRedis';
-import CountCacheInMemory from './CountCache/InMemory';
-import CountCacheInRedis from './CountCache/InRedis';
-import EventsCacheInMemory from './EventsCache/InMemory';
-import EventsCacheInRedis from './EventsCache/InRedis';
-import KeyBuilder from './Keys';
-import MetaBuilder from './Meta';
-import { STORAGE_MEMORY, STORAGE_REDIS } from '../utils/constants';
-
-const NodeStorageFactory = context => {
-  const settings = context.get(context.constants.SETTINGS);
-  const { storage } = settings;
-  const keys = new KeyBuilder(settings);
-
-  switch (storage.type) {
-    case STORAGE_REDIS: {
-      const redis = new RedisAdapter(storage.options);
-      const meta = MetaBuilder(settings);
-
-      // subscription to Redis connect event in order to emit SDK_READY
-      const { splits, segments } = context.get(context.constants.READINESS);
-      redis.on('connect', () => {
-        splits.emit(splits.SDK_SPLITS_ARRIVED);
-        segments.emit(segments.SDK_SEGMENTS_ARRIVED);
-      });
-
-      return {
-        splits: new SplitCacheInRedis(keys, redis),
-        segments: new SegmentCacheInRedis(keys, redis),
-        impressions: new ImpressionsCacheInRedis(keys, redis, meta),
-        metrics: new LatencyCacheInRedis(keys, redis),
-        count: new CountCacheInRedis(keys, redis),
-        events: new EventsCacheInRedis(keys, redis, meta),
-
-        // When using REDIS we should:
-        // 1- Disconnect from the storage
-        // 2- Stop sending data to Redis and instance using empty in memory implementation
-        destroy() {
-          redis.disconnect();
-
-          this.splits = new SplitCacheInMemory;
-          this.segments = new SegmentCacheInMemory(keys);
-          this.impressions = new ImpressionsCacheInMemory;
-          this.metrics = new LatencyCacheInMemory;
-          this.count = new CountCacheInMemory;
-          this.events = new EventsCacheInMemory(context);
-        }
-      };
-    }
-
-    case STORAGE_MEMORY:
-    default:
-      return {
-        splits: new SplitCacheInMemory,
-        segments: new SegmentCacheInMemory(keys),
-        impressions: new ImpressionsCacheInMemory,
-        metrics: new LatencyCacheInMemory,
-        count: new CountCacheInMemory,
-        events: new EventsCacheInMemory(context),
-
-        // When using MEMORY we should flush all the storages and leave them empty
-        destroy() {
-          this.splits.flush();
-          this.segments.flush();
-          this.impressions.clear();
-          this.metrics.clear();
-          this.count.clear();
-          this.events.clear();
-        }
-      };
-  }
-
-};
-
-export default NodeStorageFactory;

package/src/storage/package.json

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

package/src/sync/AuthClient/index.js

@@ -1,31 +0,0 @@
-import objectAssign from 'object-assign';
-import authService from '../../services/auth';
-import authRequest from '../../services/auth/auth';
-import { decodeJWTtoken } from '../../utils/jwt';
-
-/**
- * Run authentication requests to Auth Server, and handle response decoding the JTW token.
- * Precondition:
- *
- * @param {Object} settings Split factory config, used to get authorizationKey and other params required by authRequest.
- * @param {string[] | undefined} userKeys set of user Keys to track MY_SEGMENTS_CHANGES. It is undefined for Node.
- * @throws {ReferenceError} if `atob` function is not defined
- */
-export default function authenticate(settings, userKeys) {
-  let authPromise = authService(authRequest(settings, userKeys)); // errors handled by authService
-  return authPromise
-    // no need to handle json parsing errors as SplitError, since no user callbacks are executed after this promise is resolved
-    .then(resp => resp.json())
-    .then(json => {
-      if (json.token) { // empty token when `"pushEnabled": false`
-        const decodedToken = decodeJWTtoken(json.token);
-        if (typeof decodedToken.iat !== 'number' || typeof decodedToken.exp !== 'number') throw new Error('token properties "issuedAt" (iat) or "expiration" (exp) are missing or invalid');
-        const channels = JSON.parse(decodedToken['x-ably-capability']);
-        return objectAssign({
-          decodedToken,
-          channels
-        }, json);
-      }
-      return json;
-    });
-}