@splitsoftware/splitio-commons 2.5.0-rc.0 → 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,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/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
-}