@splitsoftware/splitio-commons 2.4.2-rc.3 → 11.5.0-rc.0

package/src/storages/AbstractMySegmentsCacheSync.ts

@@ -1,94 +0,0 @@
-import { IMySegmentsResponse } from '../dtos/types';
-import { MySegmentsData } from '../sync/polling/types';
-import { ISegmentsCacheSync } from './types';
-
-/**
- * This class provides a skeletal implementation of the ISegmentsCacheSync interface
- * to minimize the effort required to implement this interface.
- */
-export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync {
-
-  protected abstract addSegment(name: string): boolean
-  protected abstract removeSegment(name: string): boolean
-  protected abstract setChangeNumber(changeNumber?: number): boolean | void
-
-  /**
-   * For server-side synchronizer: check if `key` is in `name` segment.
-   * For client-side synchronizer: check if `name` segment is in the cache. `key` is undefined.
-   */
-  abstract isInSegment(name: string, key?: string): boolean
-
-  /**
-   * clear the cache.
-   */
-  clear() {
-    this.resetSegments({});
-  }
-
-
-  // No-op. Not used in client-side.
-  registerSegments(): boolean { return false; }
-  update() { return false; }
-
-  /**
-   * For server-side synchronizer: get the list of segments to fetch changes.
-   * Also used for the `seC` (segment count) telemetry stat.
-   */
-  abstract getRegisteredSegments(): string[]
-
-  /**
-   * Only used for the `skC`(segment keys count) telemetry stat: 1 for client-side, and total count of keys in server-side.
-   */
-  // @TODO for client-side it should be the number of clients, but it requires a refactor of MySegments caches to simplify the code.
-  abstract getKeysCount(): number
-
-  abstract getChangeNumber(): number
-
-  /**
-   * For server-side synchronizer: the method is not used.
-   * For client-side synchronizer: it resets or updates the cache.
-   */
-  resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean {
-    this.setChangeNumber(segmentsData.cn);
-
-    const { added, removed } = segmentsData as MySegmentsData;
-
-    if (added && removed) {
-      let isDiff = false;
-
-      added.forEach(segment => {
-        isDiff = this.addSegment(segment) || isDiff;
-      });
-
-      removed.forEach(segment => {
-        isDiff = this.removeSegment(segment) || isDiff;
-      });
-
-      return isDiff;
-    }
-
-    const names = ((segmentsData as IMySegmentsResponse).k || []).map(s => s.n).sort();
-    const storedSegmentKeys = this.getRegisteredSegments().sort();
-
-    // Extreme fast => everything is empty
-    if (!names.length && !storedSegmentKeys.length) return false;
-
-    let index = 0;
-
-    while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index]) index++;
-
-    // Quick path => no changes
-    if (index === names.length && index === storedSegmentKeys.length) return false;
-
-    // Slowest path => add and/or remove segments
-    for (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-      this.removeSegment(storedSegmentKeys[removeIndex]);
-    }
-
-    for (let addIndex = index; addIndex < names.length; addIndex++) {
-      this.addSegment(names[addIndex]);
-    }
-
-    return true;
-  }
-}

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -1,63 +0,0 @@
-import { ISplitsCacheAsync } from './types';
-import { ISplit } from '../dtos/types';
-import { objectAssign } from '../utils/lang/objectAssign';
-
-/**
- * This class provides a skeletal implementation of the ISplitsCacheAsync interface
- * to minimize the effort required to implement this interface.
- */
-export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
-
-  protected abstract addSplit(split: ISplit): Promise<boolean>
-  protected abstract removeSplit(name: string): Promise<boolean>
-  protected abstract setChangeNumber(changeNumber: number): Promise<boolean | void>
-
-  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): Promise<boolean> {
-    return Promise.all([
-      this.setChangeNumber(changeNumber),
-      Promise.all(toAdd.map(addedFF => this.addSplit(addedFF))),
-      Promise.all(toRemove.map(removedFF => this.removeSplit(removedFF.name)))
-    ]).then(([, added, removed]) => {
-      return added.some(result => result) || removed.some(result => result);
-    });
-  }
-
-  abstract getSplit(name: string): Promise<ISplit | null>
-  abstract getSplits(names: string[]): Promise<Record<string, ISplit | null>>
-  abstract getChangeNumber(): Promise<number>
-  abstract getAll(): Promise<ISplit[]>
-  abstract getSplitNames(): Promise<string[]>
-  abstract getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>
-  abstract trafficTypeExists(trafficType: string): Promise<boolean>
-  abstract clear(): Promise<boolean | void>
-
-  // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
-  // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
-  usesSegments(): Promise<boolean> {
-    return Promise.resolve(true);
-  }
-
-  /**
-   * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-   * Used for SPLIT_KILL push notifications.
-   *
-   * @returns a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
-   * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-   * The promise will never be rejected.
-   */
-  killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean> {
-    return this.getSplit(name).then(split => {
-
-      if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-        const newSplit = objectAssign({}, split);
-        newSplit.killed = true;
-        newSplit.defaultTreatment = defaultTreatment;
-        newSplit.changeNumber = changeNumber;
-
-        return this.addSplit(newSplit);
-      }
-      return false;
-    }).catch(() => false);
-  }
-
-}

package/src/storages/AbstractSplitsCacheSync.ts

@@ -1,94 +0,0 @@
-import { ISplitsCacheSync, IStorageSync } from './types';
-import { IRBSegment, ISplit } from '../dtos/types';
-import { objectAssign } from '../utils/lang/objectAssign';
-import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
-
-/**
- * This class provides a skeletal implementation of the ISplitsCacheSync interface
- * to minimize the effort required to implement this interface.
- */
-export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
-
-  protected abstract addSplit(split: ISplit): boolean
-  protected abstract removeSplit(name: string): boolean
-  protected abstract setChangeNumber(changeNumber: number): boolean | void
-
-  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean {
-    this.setChangeNumber(changeNumber);
-    const updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
-    return toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
-  }
-
-  abstract getSplit(name: string): ISplit | null
-
-  getSplits(names: string[]): Record<string, ISplit | null> {
-    const splits: Record<string, ISplit | null> = {};
-    names.forEach(name => {
-      splits[name] = this.getSplit(name);
-    });
-    return splits;
-  }
-
-  abstract getChangeNumber(): number
-
-  getAll(): ISplit[] {
-    return this.getSplitNames().map(key => this.getSplit(key) as ISplit);
-  }
-
-  abstract getSplitNames(): string[]
-
-  abstract trafficTypeExists(trafficType: string): boolean
-
-  abstract usesSegments(): boolean
-
-  abstract clear(): void
-
-  /**
-   * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-   * Used for SPLIT_KILL push notifications.
-   *
-   * @returns `true` if the operation successed updating the split, or `false` if no split is updated,
-   * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-   */
-  killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean {
-    const split = this.getSplit(name);
-
-    if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-      const newSplit = objectAssign({}, split);
-      newSplit.killed = true;
-      newSplit.defaultTreatment = defaultTreatment;
-      newSplit.changeNumber = changeNumber;
-
-      return this.addSplit(newSplit);
-    }
-    return false;
-  }
-
-  abstract getNamesByFlagSets(flagSets: string[]): Set<string>[]
-
-}
-
-/**
- * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
- * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
- */
-export function usesSegments(ruleEntity: ISplit | IRBSegment) {
-  const conditions = ruleEntity.conditions || [];
-  for (let i = 0; i < conditions.length; i++) {
-    const matchers = conditions[i].matcherGroup.matchers;
-
-    for (let j = 0; j < matchers.length; j++) {
-      const matcher = matchers[j].matcherType;
-      if (matcher === IN_SEGMENT || matcher === IN_LARGE_SEGMENT) return true;
-    }
-  }
-
-  const excluded = (ruleEntity as IRBSegment).excluded;
-  if (excluded && excluded.segments && excluded.segments.length > 0) return true;
-
-  return false;
-}
-
-export function usesSegmentsSync(storage: Pick<IStorageSync, 'splits' | 'rbSegments'>) {
-  return storage.splits.usesSegments() || storage.rbSegments.usesSegments();
-}

package/src/storages/KeyBuilder.ts

@@ -1,81 +0,0 @@
-import { ISettings } from '../types';
-import { hash } from '../utils/murmur3/murmur3';
-
-const everythingAtTheEnd = /[^.]+$/;
-
-const DEFAULT_PREFIX = 'SPLITIO';
-
-export function validatePrefix(prefix: unknown) {
-  return prefix ? prefix + '.SPLITIO' : 'SPLITIO';
-}
-
-export class KeyBuilder {
-
-  readonly prefix: string;
-
-  constructor(prefix: string = DEFAULT_PREFIX) {
-    this.prefix = prefix;
-  }
-
-  buildTrafficTypeKey(trafficType: string) {
-    return `${this.prefix}.trafficType.${trafficType}`;
-  }
-
-  buildFlagSetKey(flagSet: string) {
-    return `${this.prefix}.flagSet.${flagSet}`;
-  }
-
-  buildSplitKey(splitName: string) {
-    return `${this.prefix}.split.${splitName}`;
-  }
-
-  buildSplitsTillKey() {
-    return `${this.prefix}.splits.till`;
-  }
-
-  buildSplitKeyPrefix() {
-    return `${this.prefix}.split.`;
-  }
-
-  buildRBSegmentKey(rbsegmentName: string) {
-    return `${this.prefix}.rbsegment.${rbsegmentName}`;
-  }
-
-  buildRBSegmentsTillKey() {
-    return `${this.prefix}.rbsegments.till`;
-  }
-
-  buildRBSegmentKeyPrefix() {
-    return `${this.prefix}.rbsegment.`;
-  }
-
-  buildSegmentNameKey(segmentName: string) {
-    return `${this.prefix}.segment.${segmentName}`;
-  }
-
-  buildSegmentTillKey(segmentName: string) {
-    return `${this.prefix}.segment.${segmentName}.till`;
-  }
-
-  extractKey(builtKey: string) {
-    const s = builtKey.match(everythingAtTheEnd);
-
-    if (s && s.length) {
-      return s[0];
-    } else {
-      throw new Error('Invalid latency key provided');
-    }
-  }
-
-  buildHashKey() {
-    return `${this.prefix}.hash`;
-  }
-}
-
-/**
- * Generates a murmur32 hash based on the authorization key, the feature flags filter query, and version of SplitChanges API.
- * The hash is in hexadecimal format (8 characters max, 32 bits).
- */
-export function getStorageHash(settings: ISettings) {
-  return hash(`${settings.core.authorizationKey}::${settings.sync.__splitFiltersValidation.queryString}::${settings.sync.flagSpecVersion}`).toString(16);
-}

package/src/storages/KeyBuilderCS.ts

@@ -1,79 +0,0 @@
-import { startsWith } from '../utils/lang';
-import { KeyBuilder } from './KeyBuilder';
-
-export interface MySegmentsKeyBuilder {
-  buildSegmentNameKey(segmentName: string): string;
-  extractSegmentName(builtSegmentKeyName: string): string | undefined;
-  buildTillKey(): string;
-}
-
-export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
-
-  protected readonly regexSplitsCacheKey: RegExp;
-  protected readonly matchingKey: string;
-
-  constructor(prefix: string, matchingKey: string) {
-    super(prefix);
-    this.matchingKey = matchingKey;
-    this.regexSplitsCacheKey = new RegExp(`^${prefix}\\.(splits?|trafficType|flagSet)\\.`);
-  }
-
-  /**
-   * @override
-   */
-  buildSegmentNameKey(segmentName: string) {
-    return `${this.prefix}.${this.matchingKey}.segment.${segmentName}`;
-  }
-
-  extractSegmentName(builtSegmentKeyName: string) {
-    const prefix = `${this.prefix}.${this.matchingKey}.segment.`;
-
-    if (startsWith(builtSegmentKeyName, prefix)) return builtSegmentKeyName.slice(prefix.length);
-  }
-
-  buildLastUpdatedKey() {
-    return `${this.prefix}.splits.lastUpdated`;
-  }
-
-  isSplitsCacheKey(key: string) {
-    return this.regexSplitsCacheKey.test(key);
-  }
-
-  buildTillKey() {
-    return `${this.prefix}.${this.matchingKey}.segments.till`;
-  }
-
-  isSplitKey(key: string) {
-    return startsWith(key, `${this.prefix}.split.`);
-  }
-
-  isRBSegmentKey(key: string) {
-    return startsWith(key, `${this.prefix}.rbsegment.`);
-  }
-
-  buildSplitsWithSegmentCountKey() {
-    return `${this.prefix}.splits.usingSegments`;
-  }
-
-  buildLastClear() {
-    return `${this.prefix}.lastClear`;
-  }
-}
-
-export function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string): MySegmentsKeyBuilder {
-  return {
-    buildSegmentNameKey(segmentName: string) {
-      return `${prefix}.${matchingKey}.largeSegment.${segmentName}`;
-    },
-
-    extractSegmentName(builtSegmentKeyName: string) {
-      const p = `${prefix}.${matchingKey}.largeSegment.`;
-
-      if (startsWith(builtSegmentKeyName, p)) return builtSegmentKeyName.slice(p.length);
-    },
-
-    buildTillKey() {
-      return `${prefix}.${matchingKey}.largeSegments.till`;
-    }
-  };
-}

package/src/storages/KeyBuilderSS.ts

@@ -1,74 +0,0 @@
-import { KeyBuilder } from './KeyBuilder';
-import { IMetadata } from '../dtos/types';
-import { Method } from '../sync/submitters/types';
-
-export const METHOD_NAMES: Record<Method, string> = {
-  t: 'treatment',
-  ts: 'treatments',
-  tc: 'treatmentWithConfig',
-  tcs: 'treatmentsWithConfig',
-  tf: 'treatmentsByFlagSet',
-  tfs: 'treatmentsByFlagSets',
-  tcf: 'treatmentsWithConfigByFlagSet',
-  tcfs: 'treatmentsWithConfigByFlagSets',
-  tr: 'track'
-};
-
-export class KeyBuilderSS extends KeyBuilder {
-
-  readonly latencyPrefix: string;
-  readonly exceptionPrefix: string;
-  readonly initPrefix: string;
-  private readonly versionablePrefix: string;
-
-  constructor(prefix: string, metadata: IMetadata) {
-    super(prefix);
-    this.latencyPrefix = `${this.prefix}.telemetry.latencies`;
-    this.exceptionPrefix = `${this.prefix}.telemetry.exceptions`;
-    this.initPrefix = `${this.prefix}.telemetry.init`;
-    this.versionablePrefix = `${metadata.s}/${metadata.n}/${metadata.i}`;
-  }
-
-  buildRegisteredSegmentsKey() {
-    return `${this.prefix}.segments.registered`;
-  }
-
-  buildImpressionsKey() {
-    return `${this.prefix}.impressions`;
-  }
-
-  buildImpressionsCountKey() {
-    return `${this.prefix}.impressions.count`;
-  }
-
-  buildUniqueKeysKey() {
-    return `${this.prefix}.uniquekeys`;
-  }
-
-  buildEventsKey() {
-    return `${this.prefix}.events`;
-  }
-
-  searchPatternForSplitKeys() {
-    return `${this.buildSplitKeyPrefix()}*`;
-  }
-
-  searchPatternForRBSegmentKeys() {
-    return `${this.buildRBSegmentKeyPrefix()}*`;
-  }
-
-  /* Telemetry keys */
-
-  buildLatencyKey(method: Method, bucket: number) {
-    return `${this.latencyPrefix}::${this.versionablePrefix}/${METHOD_NAMES[method]}/${bucket}`;
-  }
-
-  buildExceptionKey(method: Method) {
-    return `${this.exceptionPrefix}::${this.versionablePrefix}/${METHOD_NAMES[method]}`;
-  }
-
-  buildInitKey() {
-    return `${this.initPrefix}::${this.versionablePrefix}`;
-  }
-
-}

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/findLatencyIndex.ts

@@ -1,16 +0,0 @@
-import { isNaNNumber } from '../utils/lang';
-
-const MIN = 0;
-const MAX = 22;
-const BASE = 1.5;
-
-/**
- * Calculates buckets from latency in milliseconds
- *
- * @param latencyInMs - latency in milliseconds
- * @returns a bucket index from 0 to 22 inclusive
- */
-export function findLatencyIndex(latencyInMs: number): number {
-  const index = Math.min(MAX, Math.max(MIN, Math.ceil(Math.log(latencyInMs) / Math.log(BASE))));
-  return isNaNNumber(index) ? 0 : index; // index is NaN if latency is not a positive number
-}

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -1,87 +0,0 @@
-import { ILogger } from '../../logger/types';
-import { isNaNNumber } from '../../utils/lang';
-import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
-import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
-import { LOG_PREFIX, DEFINED } from './constants';
-import { StorageAdapter } from '../types';
-
-export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
-
-  private readonly keys: MySegmentsKeyBuilder;
-  private readonly log: ILogger;
-  private readonly storage: StorageAdapter;
-
-  constructor(log: ILogger, keys: MySegmentsKeyBuilder, storage: StorageAdapter) {
-    super();
-    this.log = log;
-    this.keys = keys;
-    this.storage = storage;
-    // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
-  }
-
-  protected addSegment(name: string): boolean {
-    const segmentKey = this.keys.buildSegmentNameKey(name);
-
-    try {
-      if (this.storage.getItem(segmentKey) === DEFINED) return false;
-      this.storage.setItem(segmentKey, DEFINED);
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
-  }
-
-  protected removeSegment(name: string): boolean {
-    const segmentKey = this.keys.buildSegmentNameKey(name);
-
-    try {
-      if (this.storage.getItem(segmentKey) !== DEFINED) return false;
-      this.storage.removeItem(segmentKey);
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
-  }
-
-  isInSegment(name: string): boolean {
-    return this.storage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
-  }
-
-  getRegisteredSegments(): string[] {
-    const registeredSegments: string[] = [];
-    for (let i = 0, len = this.storage.length; i < len; i++) {
-      const segmentName = this.keys.extractSegmentName(this.storage.key(i)!);
-      if (segmentName) registeredSegments.push(segmentName);
-    }
-    return registeredSegments;
-  }
-
-  getKeysCount() {
-    return 1;
-  }
-
-  protected setChangeNumber(changeNumber?: number) {
-    try {
-      if (changeNumber) this.storage.setItem(this.keys.buildTillKey(), changeNumber + '');
-      else this.storage.removeItem(this.keys.buildTillKey());
-    } catch (e) {
-      this.log.error(e);
-    }
-  }
-
-  getChangeNumber() {
-    const n = -1;
-    let value: string | number | null = this.storage.getItem(this.keys.buildTillKey());
-
-    if (value !== null) {
-      value = parseInt(value, 10);
-
-      return isNaNNumber(value) ? n : value;
-    }
-
-    return n;
-  }
-
-}