@splitsoftware/splitio-commons 2.5.0-rc.0 → 2.5.0

package/cjs/storages/dataLoader.js

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCache = exports.setCache = void 0;
-var sets_1 = require("../utils/lang/sets");
-var key_1 = require("../utils/key");
-/**
- * Sets the given synchronous storage with the provided preloaded data snapshot.
- * If `matchingKey` is provided, the storage is handled as a client-side storage (segments and largeSegments are instances of MySegmentsCache).
- * Otherwise, the storage is handled as a server-side storage (segments is an instance of SegmentsCache).
- */
-function setCache(log, preloadedData, storage, matchingKey) {
-    // Do not load data if current preloadedData is empty
-    if (Object.keys(preloadedData).length === 0)
-        return;
-    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
-    log.debug("set cache" + (matchingKey ? " for key " + matchingKey : ''));
-    if (splits) {
-        splits.clear();
-        splits.update(preloadedData.flags || [], [], preloadedData.since || -1);
-    }
-    if (rbSegments) {
-        rbSegments.clear();
-        rbSegments.update(preloadedData.rbSegments || [], [], preloadedData.rbSince || -1);
-    }
-    var segmentsData = preloadedData.segments || {};
-    if (matchingKey) { // add memberships data (client-side)
-        var memberships = preloadedData.memberships && preloadedData.memberships[matchingKey];
-        if (!memberships && segmentsData) {
-            memberships = {
-                ms: {
-                    k: Object.keys(segmentsData).filter(function (segmentName) {
-                        var segmentKeys = segmentsData[segmentName];
-                        return segmentKeys.indexOf(matchingKey) > -1;
-                    }).map(function (segmentName) { return ({ n: segmentName }); })
-                }
-            };
-        }
-        if (memberships) {
-            if (memberships.ms)
-                segments.resetSegments(memberships.ms);
-            if (memberships.ls && largeSegments)
-                largeSegments.resetSegments(memberships.ls);
-        }
-    }
-    else { // add segments data (server-side)
-        Object.keys(segmentsData).forEach(function (segmentName) {
-            var segmentKeys = segmentsData[segmentName];
-            segments.update(segmentName, segmentKeys, [], -1);
-        });
-    }
-}
-exports.setCache = setCache;
-/**
- * Gets the preloaded data snapshot from the given synchronous storage.
- * If `keys` are provided, the memberships for those keys is returned, to protect segments data.
- * Otherwise, the segments data is returned.
- */
-function getCache(log, storage, keys) {
-    log.debug("get cache" + (keys ? " for keys " + keys : ''));
-    return {
-        since: storage.splits.getChangeNumber(),
-        flags: storage.splits.getAll(),
-        rbSince: storage.rbSegments.getChangeNumber(),
-        rbSegments: storage.rbSegments.getAll(),
-        segments: keys ?
-            undefined : // @ts-ignore accessing private prop
-            Object.keys(storage.segments.segmentCache).reduce(function (prev, cur) {
-                prev[cur] = (0, sets_1.setToArray)(storage.segments.segmentCache[cur]);
-                return prev;
-            }, {}),
-        memberships: keys ?
-            keys.reduce(function (prev, key) {
-                if (storage.shared) {
-                    // Client-side segments
-                    // @ts-ignore accessing private prop
-                    var sharedStorage = storage.shared(key);
-                    prev[(0, key_1.getMatching)(key)] = {
-                        ms: {
-                            // @ts-ignore accessing private prop
-                            k: Object.keys(sharedStorage.segments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
-                        },
-                        ls: sharedStorage.largeSegments ? {
-                            // @ts-ignore accessing private prop
-                            k: Object.keys(sharedStorage.largeSegments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
-                        } : undefined
-                    };
-                }
-                else {
-                    prev[(0, key_1.getMatching)(key)] = {
-                        ms: {
-                            // Server-side segments
-                            // @ts-ignore accessing private prop
-                            k: Object.keys(storage.segments.segmentCache).reduce(function (prev, segmentName) {
-                                return storage.segments.segmentCache[segmentName].has(key) ?
-                                    prev.concat({ n: segmentName }) :
-                                    prev;
-                            }, [])
-                        },
-                        ls: {
-                            k: []
-                        }
-                    };
-                }
-                return prev;
-            }, {}) :
-            undefined
-    };
-}
-exports.getCache = getCache;

package/cjs/utils/inputValidation/preloadedData.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validatePreloadedData = void 0;
-var lang_1 = require("../lang");
-var split_1 = require("./split");
-function validateTimestampData(log, maybeTimestamp, method, item) {
-    if ((0, lang_1.isFiniteNumber)(maybeTimestamp) && maybeTimestamp > -1)
-        return true;
-    log.error(method + ": preloadedData." + item + " must be a positive number.");
-    return false;
-}
-function validateSplitsData(log, maybeSplitsData, method) {
-    if ((0, lang_1.isObject)(maybeSplitsData)) {
-        var 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(function (splitName) { return (0, split_1.validateSplit)(log, splitName, method) && (0, lang_1.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, maybeMySegmentsData, method) {
-    if ((0, lang_1.isObject)(maybeMySegmentsData)) {
-        var userKeys = Object.keys(maybeMySegmentsData);
-        if (userKeys.every(function (userKey) {
-            var segmentNames = maybeMySegmentsData[userKey];
-            // an empty list is valid
-            return Array.isArray(segmentNames) && segmentNames.every(function (segmentName) { return (0, lang_1.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, maybeSegmentsData, method) {
-    if ((0, lang_1.isObject)(maybeSegmentsData)) {
-        var segmentNames = Object.keys(maybeSegmentsData);
-        if (segmentNames.every(function (segmentName) { return (0, lang_1.isString)(maybeSegmentsData[segmentName]); }))
-            return true;
-    }
-    log.error(method + ": preloadedData.segmentsData must be a map of segment names to their stringified definitions.");
-    return false;
-}
-function validatePreloadedData(log, maybePreloadedData, method) {
-    if (!(0, lang_1.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;
-}
-exports.validatePreloadedData = validatePreloadedData;

package/esm/storages/dataLoader.js

@@ -1,104 +0,0 @@
-import { setToArray } from '../utils/lang/sets';
-import { getMatching } from '../utils/key';
-/**
- * Sets the given synchronous storage with the provided preloaded data snapshot.
- * If `matchingKey` is provided, the storage is handled as a client-side storage (segments and largeSegments are instances of MySegmentsCache).
- * Otherwise, the storage is handled as a server-side storage (segments is an instance of SegmentsCache).
- */
-export function setCache(log, preloadedData, storage, matchingKey) {
-    // Do not load data if current preloadedData is empty
-    if (Object.keys(preloadedData).length === 0)
-        return;
-    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
-    log.debug("set cache" + (matchingKey ? " for key " + matchingKey : ''));
-    if (splits) {
-        splits.clear();
-        splits.update(preloadedData.flags || [], [], preloadedData.since || -1);
-    }
-    if (rbSegments) {
-        rbSegments.clear();
-        rbSegments.update(preloadedData.rbSegments || [], [], preloadedData.rbSince || -1);
-    }
-    var segmentsData = preloadedData.segments || {};
-    if (matchingKey) { // add memberships data (client-side)
-        var memberships = preloadedData.memberships && preloadedData.memberships[matchingKey];
-        if (!memberships && segmentsData) {
-            memberships = {
-                ms: {
-                    k: Object.keys(segmentsData).filter(function (segmentName) {
-                        var segmentKeys = segmentsData[segmentName];
-                        return segmentKeys.indexOf(matchingKey) > -1;
-                    }).map(function (segmentName) { return ({ n: segmentName }); })
-                }
-            };
-        }
-        if (memberships) {
-            if (memberships.ms)
-                segments.resetSegments(memberships.ms);
-            if (memberships.ls && largeSegments)
-                largeSegments.resetSegments(memberships.ls);
-        }
-    }
-    else { // add segments data (server-side)
-        Object.keys(segmentsData).forEach(function (segmentName) {
-            var segmentKeys = segmentsData[segmentName];
-            segments.update(segmentName, segmentKeys, [], -1);
-        });
-    }
-}
-/**
- * Gets the preloaded data snapshot from the given synchronous storage.
- * If `keys` are provided, the memberships for those keys is returned, to protect segments data.
- * Otherwise, the segments data is returned.
- */
-export function getCache(log, storage, keys) {
-    log.debug("get cache" + (keys ? " for keys " + keys : ''));
-    return {
-        since: storage.splits.getChangeNumber(),
-        flags: storage.splits.getAll(),
-        rbSince: storage.rbSegments.getChangeNumber(),
-        rbSegments: storage.rbSegments.getAll(),
-        segments: keys ?
-            undefined : // @ts-ignore accessing private prop
-            Object.keys(storage.segments.segmentCache).reduce(function (prev, cur) {
-                prev[cur] = setToArray(storage.segments.segmentCache[cur]);
-                return prev;
-            }, {}),
-        memberships: keys ?
-            keys.reduce(function (prev, key) {
-                if (storage.shared) {
-                    // Client-side segments
-                    // @ts-ignore accessing private prop
-                    var sharedStorage = storage.shared(key);
-                    prev[getMatching(key)] = {
-                        ms: {
-                            // @ts-ignore accessing private prop
-                            k: Object.keys(sharedStorage.segments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
-                        },
-                        ls: sharedStorage.largeSegments ? {
-                            // @ts-ignore accessing private prop
-                            k: Object.keys(sharedStorage.largeSegments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
-                        } : undefined
-                    };
-                }
-                else {
-                    prev[getMatching(key)] = {
-                        ms: {
-                            // Server-side segments
-                            // @ts-ignore accessing private prop
-                            k: Object.keys(storage.segments.segmentCache).reduce(function (prev, segmentName) {
-                                return storage.segments.segmentCache[segmentName].has(key) ?
-                                    prev.concat({ n: segmentName }) :
-                                    prev;
-                            }, [])
-                        },
-                        ls: {
-                            k: []
-                        }
-                    };
-                }
-                return prev;
-            }, {}) :
-            undefined
-    };
-}

package/esm/utils/inputValidation/preloadedData.js

@@ -1,55 +0,0 @@
-import { isObject, isString, isFiniteNumber } from '../lang';
-import { validateSplit } from './split';
-function validateTimestampData(log, maybeTimestamp, method, item) {
-    if (isFiniteNumber(maybeTimestamp) && maybeTimestamp > -1)
-        return true;
-    log.error(method + ": preloadedData." + item + " must be a positive number.");
-    return false;
-}
-function validateSplitsData(log, maybeSplitsData, method) {
-    if (isObject(maybeSplitsData)) {
-        var 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(function (splitName) { return 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, maybeMySegmentsData, method) {
-    if (isObject(maybeMySegmentsData)) {
-        var userKeys = Object.keys(maybeMySegmentsData);
-        if (userKeys.every(function (userKey) {
-            var segmentNames = maybeMySegmentsData[userKey];
-            // an empty list is valid
-            return Array.isArray(segmentNames) && segmentNames.every(function (segmentName) { return 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, maybeSegmentsData, method) {
-    if (isObject(maybeSegmentsData)) {
-        var segmentNames = Object.keys(maybeSegmentsData);
-        if (segmentNames.every(function (segmentName) { return 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, maybePreloadedData, method) {
-    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;
-}

package/src/storages/dataLoader.ts

@@ -1,113 +0,0 @@
-import SplitIO from '../../types/splitio';
-import { IRBSegmentsCacheSync, ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from './types';
-import { setToArray } from '../utils/lang/sets';
-import { getMatching } from '../utils/key';
-import { IMembershipsResponse, IMySegmentsResponse, IRBSegment, ISplit } from '../dtos/types';
-import { ILogger } from '../logger/types';
-
-/**
- * Sets the given synchronous storage with the provided preloaded data snapshot.
- * If `matchingKey` is provided, the storage is handled as a client-side storage (segments and largeSegments are instances of MySegmentsCache).
- * Otherwise, the storage is handled as a server-side storage (segments is an instance of SegmentsCache).
- */
-export function setCache(log: ILogger, preloadedData: SplitIO.PreloadedData, storage: { splits?: ISplitsCacheSync, rbSegments?: IRBSegmentsCacheSync, segments: ISegmentsCacheSync, largeSegments?: ISegmentsCacheSync }, matchingKey?: string) {
-  // Do not load data if current preloadedData is empty
-  if (Object.keys(preloadedData).length === 0) return;
-
-  const { splits, rbSegments, segments, largeSegments } = storage;
-
-  log.debug(`set cache${matchingKey ? ` for key ${matchingKey}` : ''}`);
-
-  if (splits) {
-    splits.clear();
-    splits.update(preloadedData.flags as ISplit[] || [], [], preloadedData.since || -1);
-  }
-
-  if (rbSegments) {
-    rbSegments.clear();
-    rbSegments.update(preloadedData.rbSegments as IRBSegment[] || [], [], preloadedData.rbSince || -1);
-  }
-
-  const segmentsData = preloadedData.segments || {};
-  if (matchingKey) { // add memberships data (client-side)
-    let memberships = preloadedData.memberships && preloadedData.memberships[matchingKey];
-    if (!memberships && segmentsData) {
-      memberships = {
-        ms: {
-          k: Object.keys(segmentsData).filter(segmentName => {
-            const segmentKeys = segmentsData[segmentName];
-            return segmentKeys.indexOf(matchingKey) > -1;
-          }).map(segmentName => ({ n: segmentName }))
-        }
-      };
-    }
-
-    if (memberships) {
-      if ((memberships as IMembershipsResponse).ms) segments.resetSegments((memberships as IMembershipsResponse).ms!);
-      if ((memberships as IMembershipsResponse).ls && largeSegments) largeSegments.resetSegments((memberships as IMembershipsResponse).ls!);
-    }
-  } else { // add segments data (server-side)
-    Object.keys(segmentsData).forEach(segmentName => {
-      const segmentKeys = segmentsData[segmentName];
-      segments.update(segmentName, segmentKeys, [], -1);
-    });
-  }
-}
-
-/**
- * Gets the preloaded data snapshot from the given synchronous storage.
- * If `keys` are provided, the memberships for those keys is returned, to protect segments data.
- * Otherwise, the segments data is returned.
- */
-export function getCache(log: ILogger, storage: IStorageSync, keys?: SplitIO.SplitKey[]): SplitIO.PreloadedData {
-
-  log.debug(`get cache${keys ? ` for keys ${keys}` : ''}`);
-
-  return {
-    since: storage.splits.getChangeNumber(),
-    flags: storage.splits.getAll(),
-    rbSince: storage.rbSegments.getChangeNumber(),
-    rbSegments: storage.rbSegments.getAll(),
-    segments: keys ?
-      undefined : // @ts-ignore accessing private prop
-      Object.keys(storage.segments.segmentCache).reduce((prev, cur) => { // @ts-ignore accessing private prop
-        prev[cur] = setToArray(storage.segments.segmentCache[cur] as Set<string>);
-        return prev;
-      }, {}),
-    memberships: keys ?
-      keys.reduce<Record<string, IMembershipsResponse>>((prev, key) => {
-        if (storage.shared) {
-          // Client-side segments
-          // @ts-ignore accessing private prop
-          const sharedStorage = storage.shared(key);
-          prev[getMatching(key)] = {
-            ms: {
-              // @ts-ignore accessing private prop
-              k: Object.keys(sharedStorage.segments.segmentCache).map(segmentName => ({ n: segmentName })),
-            },
-            ls: sharedStorage.largeSegments ? {
-              // @ts-ignore accessing private prop
-              k: Object.keys(sharedStorage.largeSegments.segmentCache).map(segmentName => ({ n: segmentName })),
-            } : undefined
-          };
-        } else {
-          prev[getMatching(key)] = {
-            ms: {
-              // Server-side segments
-              // @ts-ignore accessing private prop
-              k: Object.keys(storage.segments.segmentCache).reduce<IMySegmentsResponse['k']>((prev, segmentName) => { // @ts-ignore accessing private prop
-                return storage.segments.segmentCache[segmentName].has(key) ?
-                  prev!.concat({ n: segmentName }) :
-                  prev;
-              }, [])
-            },
-            ls: {
-              k: []
-            }
-          };
-        }
-        return prev;
-      }, {}) :
-      undefined
-  };
-}

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