@splitsoftware/splitio-commons 2.4.2-rc.3 → 2.5.0-rc.1

package/src/storages/dataLoader.ts

@@ -1,55 +0,0 @@
-import { PreloadedData } from '../types';
-import { DataLoader, ISegmentsCacheSync, ISplitsCacheSync } from './types';
-
-// This value might be eventually set via a config parameter
-const DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days
-
-/**
- * Factory of client-side storage loader
- *
- * @param preloadedData - validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader
- * and extended with a `mySegmentsData` property.
- * @returns function to preload the storage
- */
-export function dataLoaderFactory(preloadedData: PreloadedData): DataLoader {
-
-  /**
-   * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
-   * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
-   *
-   * @param storage - object containing `splits` and `segments` cache (client-side variant)
-   * @param userId - user key string of the provided MySegmentsCache
-   */
-  // @TODO extend to support SegmentsCache (server-side variant) by making `userId` optional and adding the corresponding logic.
-  // @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
-  return function loadData(storage: { splits: ISplitsCacheSync, segments: ISegmentsCacheSync }, userId: string) {
-    // Do not load data if current preloadedData is empty
-    if (Object.keys(preloadedData).length === 0) return;
-
-    const { lastUpdated = -1, segmentsData = {}, since = -1, splitsData = {} } = preloadedData;
-
-    const storedSince = storage.splits.getChangeNumber();
-    const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
-
-    // Do not load data if current localStorage data is more recent,
-    // or if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-    if (storedSince > since || lastUpdated < expirationTimestamp) return;
-
-    // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
-    storage.splits.clear();
-
-    // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-    storage.splits.update(Object.keys(splitsData).map(splitName => JSON.parse(splitsData[splitName])), [], since);
-
-    // add mySegments data
-    let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
-    if (!mySegmentsData) {
-      // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
-      mySegmentsData = Object.keys(segmentsData).filter(segmentName => {
-        const userIds = JSON.parse(segmentsData[segmentName]).added;
-        return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
-      });
-    }
-    storage.segments.resetSegments({ k: mySegmentsData.map(s => ({ n: s })) });
-  };
-}

package/src/storages/inLocalStorage/storageAdapter.ts

@@ -1,62 +0,0 @@
-import { ILogger } from '../../logger/types';
-import SplitIO from '../../../types/splitio';
-import { LOG_PREFIX } from './constants';
-import { StorageAdapter } from '../types';
-
-
-export function storageAdapter(log: ILogger, prefix: string, wrapper: SplitIO.SyncStorageWrapper | SplitIO.AsyncStorageWrapper): Required<StorageAdapter> {
-  let keys: string[] = [];
-  let cache: Record<string, string> = {};
-
-  let loadPromise: Promise<void> | undefined;
-  let savePromise = Promise.resolve();
-
-  return {
-    load() {
-      return loadPromise || (loadPromise = Promise.resolve().then(() => {
-        return wrapper.getItem(prefix);
-      }).then((storedCache) => {
-        cache = JSON.parse(storedCache || '{}');
-        keys = Object.keys(cache);
-      }).catch((e) => {
-        log.error(LOG_PREFIX + 'Rejected promise calling wrapper `getItem` method, with error: ' + e);
-      }));
-    },
-
-    save() {
-      return savePromise = savePromise.then(() => {
-        return Promise.resolve(wrapper.setItem(prefix, JSON.stringify(cache)));
-      }).catch((e) => {
-        log.error(LOG_PREFIX + 'Rejected promise calling wrapper `setItem` method, with error: ' + e);
-      });
-    },
-
-    whenSaved() {
-      return savePromise;
-    },
-
-    get length() {
-      return keys.length;
-    },
-
-    getItem(key: string) {
-      return cache[key] || null;
-    },
-
-    key(index: number) {
-      return keys[index] || null;
-    },
-
-    removeItem(key: string) {
-      const index = keys.indexOf(key);
-      if (index === -1) return;
-      keys.splice(index, 1);
-      delete cache[key];
-    },
-
-    setItem(key: string, value: string) {
-      if (keys.indexOf(key) === -1) keys.push(key);
-      cache[key] = value;
-    }
-  };
-}

package/src/utils/inputValidation/preloadedData.ts

@@ -1,57 +0,0 @@
-import { isObject, isString, isFiniteNumber } from '../lang';
-import { validateSplit } from './split';
-import { ILogger } from '../../logger/types';
-
-function validateTimestampData(log: ILogger, maybeTimestamp: any, method: string, item: string) {
-  if (isFiniteNumber(maybeTimestamp) && maybeTimestamp > -1) return true;
-  log.error(`${method}: preloadedData.${item} must be a positive number.`);
-  return false;
-}
-
-function validateSplitsData(log: ILogger, maybeSplitsData: any, method: string) {
-  if (isObject(maybeSplitsData)) {
-    const splitNames = Object.keys(maybeSplitsData);
-    if (splitNames.length === 0) log.warn(`${method}: preloadedData.splitsData doesn't contain feature flag definitions.`);
-    // @TODO in the future, consider handling the possibility of having parsed definitions of splits
-    if (splitNames.every(splitName => validateSplit(log, splitName, method) && isString(maybeSplitsData[splitName]))) return true;
-  }
-  log.error(`${method}: preloadedData.splitsData must be a map of feature flag names to their stringified definitions.`);
-  return false;
-}
-
-function validateMySegmentsData(log: ILogger, maybeMySegmentsData: any, method: string) {
-  if (isObject(maybeMySegmentsData)) {
-    const userKeys = Object.keys(maybeMySegmentsData);
-    if (userKeys.every(userKey => {
-      const segmentNames = maybeMySegmentsData[userKey];
-      // an empty list is valid
-      return Array.isArray(segmentNames) && segmentNames.every(segmentName => isString(segmentName));
-    })) return true;
-  }
-  log.error(`${method}: preloadedData.mySegmentsData must be a map of user keys to their list of segment names.`);
-  return false;
-}
-
-function validateSegmentsData(log: ILogger, maybeSegmentsData: any, method: string) {
-  if (isObject(maybeSegmentsData)) {
-    const segmentNames = Object.keys(maybeSegmentsData);
-    if (segmentNames.every(segmentName => isString(maybeSegmentsData[segmentName]))) return true;
-  }
-  log.error(`${method}: preloadedData.segmentsData must be a map of segment names to their stringified definitions.`);
-  return false;
-}
-
-export function validatePreloadedData(log: ILogger, maybePreloadedData: any, method: string) {
-  if (!isObject(maybePreloadedData)) {
-    log.error(`${method}: preloadedData must be an object.`);
-  } else if (
-    validateTimestampData(log, maybePreloadedData.lastUpdated, method, 'lastUpdated') &&
-    validateTimestampData(log, maybePreloadedData.since, method, 'since') &&
-    validateSplitsData(log, maybePreloadedData.splitsData, method) &&
-    (!maybePreloadedData.mySegmentsData || validateMySegmentsData(log, maybePreloadedData.mySegmentsData, method)) &&
-    (!maybePreloadedData.segmentsData || validateSegmentsData(log, maybePreloadedData.segmentsData, method))
-  ) {
-    return true;
-  }
-  return false;
-}