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

package/src/storages/inMemory/AttributesCacheInMemory.ts

@@ -1,74 +0,0 @@
-import SplitIO from '../../../types/splitio';
-import { objectAssign } from '../../utils/lang/objectAssign';
-
-export class AttributesCacheInMemory {
-
-  private attributesCache: Record<string, SplitIO.AttributeType> = {};
-
-
-  /**
-   * Create or update the value for the given attribute
-   *
-   * @param attributeName - attribute name
-   * @param attributeValue - attribute value
-   * @returns the attribute was stored
-   */
-  setAttribute(attributeName: string, attributeValue: SplitIO.AttributeType) {
-    this.attributesCache[attributeName] = attributeValue;
-    return true;
-  }
-
-  /**
-   * Retrieves the value of a given attribute
-   *
-   * @param attributeName - attribute name
-   * @returns stored attribute value
-   */
-  getAttribute(attributeName: string) {
-    return this.attributesCache[attributeName];
-  }
-
-  /**
-   * Create or update all the given attributes
-   *
-   * @param attributes - attributes to create or update
-   * @returns attributes were stored
-   */
-  setAttributes(attributes: Record<string, Object>) {
-    this.attributesCache = objectAssign(this.attributesCache, attributes);
-    return true;
-  }
-
-  /**
-   * Retrieve the full attributes map
-   *
-   * @returns stored attributes
-   */
-  getAll() {
-    return this.attributesCache;
-  }
-
-  /**
-   * Removes a given attribute from the map
-   *
-   * @param attributeName - attribute to remove
-   * @returns attribute removed
-   */
-  removeAttribute(attributeName: string) {
-    if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {
-      delete this.attributesCache[attributeName];
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Clears all attributes stored in the SDK
-   *
-   */
-  clear() {
-    this.attributesCache = {};
-    return true;
-  }
-
-}

package/src/storages/inMemory/EventsCacheInMemory.ts

@@ -1,76 +0,0 @@
-import SplitIO from '../../../types/splitio';
-import { IEventsCacheSync } from '../types';
-
-const MAX_QUEUE_BYTE_SIZE = 5 * 1024 * 1024; // 5M
-
-export class EventsCacheInMemory implements IEventsCacheSync {
-
-  private onFullQueue?: () => void;
-  private readonly maxQueue: number;
-  private queue: SplitIO.EventData[];
-  private queueByteSize: number;
-
-  /**
-   *
-   * @param eventsQueueSize - number of queued events to call onFullQueueCb.
-   * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
-   */
-  constructor(eventsQueueSize: number = 0) {
-    this.maxQueue = eventsQueueSize;
-    this.queue = [];
-    this.queueByteSize = 0;
-  }
-
-  setOnFullQueueCb(cb: () => void) {
-    this.onFullQueue = cb;
-  }
-
-  /**
-   * Add a new event object at the end of the queue.
-   */
-  track(data: SplitIO.EventData, size = 0) {
-    this.queueByteSize += size;
-    this.queue.push(data);
-
-    this._checkForFlush();
-
-    return true;
-  }
-
-  /**
-   * Clear the data stored on the cache.
-   */
-  clear() {
-    this.queue = [];
-    this.queueByteSize = 0;
-  }
-
-  /**
-   * Pop the collected data, used as payload for posting.
-   */
-  pop(toMerge?: SplitIO.EventData[]) {
-    const data = this.queue;
-    this.clear();
-    return toMerge ? toMerge.concat(data) : data;
-  }
-
-  /**
-   * Check if the cache is empty.
-   */
-  isEmpty() {
-    return this.queue.length === 0;
-  }
-
-  /**
-   * Check if the cache queue is full and we need to flush it.
-   */
-  private _checkForFlush() {
-    if (
-      (this.queueByteSize > MAX_QUEUE_BYTE_SIZE) ||
-      // 0 means no maximum value, in case we want to avoid this being triggered. Size limit is not affected by it.
-      (this.maxQueue > 0 && this.queue.length >= this.maxQueue)
-    ) {
-      this.onFullQueue && this.onFullQueue();
-    }
-  }
-}

package/src/storages/inMemory/ImpressionCountsCacheInMemory.ts

@@ -1,69 +0,0 @@
-import { truncateTimeFrame } from '../../utils/time';
-import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
-import { IImpressionCountsCacheSync } from '../types';
-
-export class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync {
-  protected cache: Record<string, number> = {};
-  private readonly maxStorage: number;
-  protected onFullQueue?: () => void;
-  private cacheSize = 0;
-
-  constructor(impressionCountsCacheSize = DEFAULT_CACHE_SIZE) {
-    this.maxStorage = impressionCountsCacheSize;
-  }
-
-  /**
-  * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
-  */
-  private _makeKey(featureName: string, timeFrame: number) {
-    return `${featureName}::${truncateTimeFrame(timeFrame)}`;
-  }
-
-  /**
-  * Increments the quantity of impressions with the passed featureName and timeFrame.
-  */
-  track(featureName: string, timeFrame: number, amount: number) {
-    const key = this._makeKey(featureName, timeFrame);
-    const currentAmount = this.cache[key];
-    this.cache[key] = currentAmount ? currentAmount + amount : amount;
-    if (this.onFullQueue) {
-      this.cacheSize = this.cacheSize + amount;
-      if (this.cacheSize >= this.maxStorage) {
-        this.onFullQueue();
-      }
-    }
-  }
-
-
-
-  /**
-   * Pop the collected data, used as payload for posting.
-   */
-  pop(toMerge?: Record<string, number>) {
-    const data = this.cache;
-    this.clear();
-    if (toMerge) {
-      Object.keys(data).forEach((key) => {
-        if (toMerge[key]) toMerge[key] += data[key];
-        else toMerge[key] = data[key];
-      });
-      return toMerge;
-    }
-    return data;
-  }
-
-  /**
-   * Clear the data stored on the cache.
-   */
-  clear() {
-    this.cache = {};
-    this.cacheSize = 0;
-  }
-
-  /**
-   * Check if the cache is empty.
-   */
-  isEmpty() {
-    return Object.keys(this.cache).length === 0;
-  }
-}

package/src/storages/inMemory/ImpressionsCacheInMemory.ts

@@ -1,58 +0,0 @@
-import { IImpressionsCacheSync } from '../types';
-import SplitIO from '../../../types/splitio';
-
-export class ImpressionsCacheInMemory implements IImpressionsCacheSync {
-
-  private onFullQueue?: () => void;
-  private readonly maxQueue: number;
-  private queue: SplitIO.ImpressionDTO[];
-
-  /**
-   *
-   * @param impressionsQueueSize - number of queued impressions to call onFullQueueCb.
-   * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
-   */
-  constructor(impressionsQueueSize: number = 0) {
-    this.maxQueue = impressionsQueueSize;
-    this.queue = [];
-  }
-
-  setOnFullQueueCb(cb: () => void) {
-    this.onFullQueue = cb;
-  }
-
-  /**
-   * Store impressions in sequential order
-   */
-  track(data: SplitIO.ImpressionDTO[]) {
-    this.queue.push(...data);
-
-    // Check if the cache queue is full and we need to flush it.
-    if (this.maxQueue > 0 && this.queue.length >= this.maxQueue && this.onFullQueue) {
-      this.onFullQueue();
-    }
-  }
-
-  /**
-   * Clear the data stored on the cache.
-   */
-  clear() {
-    this.queue = [];
-  }
-
-  /**
-   * Pop the collected data, used as payload for posting.
-   */
-  pop(toMerge?: SplitIO.ImpressionDTO[]) {
-    const data = this.queue;
-    this.clear();
-    return toMerge ? toMerge.concat(data) : data;
-  }
-
-  /**
-   * Check if the cache is empty.
-   */
-  isEmpty() {
-    return this.queue.length === 0;
-  }
-}

package/src/storages/inMemory/InMemoryStorage.ts

@@ -1,50 +0,0 @@
-import { SplitsCacheInMemory } from './SplitsCacheInMemory';
-import { SegmentsCacheInMemory } from './SegmentsCacheInMemory';
-import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
-import { EventsCacheInMemory } from './EventsCacheInMemory';
-import { IStorageFactoryParams, IStorageSync } from '../types';
-import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
-import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
-import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
-
-/**
- * InMemory storage factory for standalone server-side SplitFactory
- *
- * @param params - parameters required by EventsCacheSync
- */
-export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync {
-  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { __splitFiltersValidation } } } = params;
-
-  const splits = new SplitsCacheInMemory(__splitFiltersValidation);
-  const rbSegments = new RBSegmentsCacheInMemory();
-  const segments = new SegmentsCacheInMemory();
-
-  const storage = {
-    splits,
-    rbSegments,
-    segments,
-    impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
-    impressionCounts: new ImpressionCountsCacheInMemory(),
-    events: new EventsCacheInMemory(eventsQueueSize),
-    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
-    uniqueKeys: new UniqueKeysCacheInMemory(),
-
-    destroy() { }
-  };
-
-  // @TODO revisit storage logic in localhost mode
-  // No tracking data in localhost mode to avoid memory leaks
-  if (params.settings.mode === LOCALHOST_MODE) {
-    const noopTrack = () => true;
-    storage.impressions.track = noopTrack;
-    storage.events.track = noopTrack;
-    storage.impressionCounts.track = noopTrack;
-    storage.uniqueKeys.track = noopTrack;
-  }
-
-  return storage;
-}
-
-InMemoryStorageFactory.type = STORAGE_MEMORY;

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -1,92 +0,0 @@
-import { SplitsCacheInMemory } from './SplitsCacheInMemory';
-import { MySegmentsCacheInMemory } from './MySegmentsCacheInMemory';
-import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
-import { EventsCacheInMemory } from './EventsCacheInMemory';
-import { IStorageSync, IStorageFactoryParams } from '../types';
-import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
-import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
-import { getMatching } from '../../utils/key';
-import { setCache } from '../dataLoader';
-import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
-
-/**
- * InMemory storage factory for standalone client-side SplitFactory
- *
- * @param params - parameters required by EventsCacheSync
- */
-export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
-  const { settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize }, sync: { __splitFiltersValidation }, preloadedData }, onReadyFromCacheCb } = params;
-
-  const storages: Record<string, IStorageSync> = {};
-
-  const splits = new SplitsCacheInMemory(__splitFiltersValidation);
-  const rbSegments = new RBSegmentsCacheInMemory();
-  const segments = new MySegmentsCacheInMemory();
-  const largeSegments = new MySegmentsCacheInMemory();
-
-  const storage = {
-    splits,
-    rbSegments,
-    segments,
-    largeSegments,
-    impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
-    impressionCounts: new ImpressionCountsCacheInMemory(),
-    events: new EventsCacheInMemory(eventsQueueSize),
-    telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
-    uniqueKeys: new UniqueKeysCacheInMemoryCS(),
-
-    destroy() { },
-
-    // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
-    shared(matchingKey: string) {
-      if (!storages[matchingKey]) {
-        const segments = new MySegmentsCacheInMemory();
-        const largeSegments = new MySegmentsCacheInMemory();
-
-        if (preloadedData) {
-          setCache(log, preloadedData, { segments, largeSegments }, matchingKey);
-        }
-
-        storages[matchingKey] = {
-          splits: this.splits,
-          rbSegments: this.rbSegments,
-          segments,
-          largeSegments,
-          impressions: this.impressions,
-          impressionCounts: this.impressionCounts,
-          events: this.events,
-          telemetry: this.telemetry,
-          uniqueKeys: this.uniqueKeys,
-
-          destroy() { }
-        };
-      }
-
-      return storages[matchingKey];
-    },
-  };
-
-  // @TODO revisit storage logic in localhost mode
-  // No tracking in localhost mode to avoid memory leaks: https://github.com/splitio/javascript-commons/issues/181
-  if (params.settings.mode === LOCALHOST_MODE) {
-    const noopTrack = () => true;
-    storage.impressions.track = noopTrack;
-    storage.events.track = noopTrack;
-    storage.impressionCounts.track = noopTrack;
-    storage.uniqueKeys.track = noopTrack;
-  }
-
-  const matchingKey = getMatching(params.settings.core.key);
-  storages[matchingKey] = storage;
-
-  if (preloadedData) {
-    setCache(log, preloadedData, storage, matchingKey);
-    if (splits.getChangeNumber() > -1) onReadyFromCacheCb();
-  }
-
-  return storage;
-}
-
-InMemoryStorageCSFactory.type = STORAGE_MEMORY;

package/src/storages/inMemory/MySegmentsCacheInMemory.ts

@@ -1,49 +0,0 @@
-import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
-
-/**
- * Default MySegmentsCacheInMemory implementation that stores MySegments in memory.
- * Supported by all JS runtimes.
- */
-export class MySegmentsCacheInMemory extends AbstractMySegmentsCacheSync {
-
-  private segmentCache: Record<string, boolean> = {};
-  private cn?: number;
-
-  protected addSegment(name: string): boolean {
-    if (this.segmentCache[name]) return false;
-
-    this.segmentCache[name] = true;
-
-    return true;
-  }
-
-  protected removeSegment(name: string): boolean {
-    if (!this.segmentCache[name]) return false;
-
-    delete this.segmentCache[name];
-
-    return true;
-  }
-
-  isInSegment(name: string): boolean {
-    return this.segmentCache[name] === true;
-  }
-
-
-  protected setChangeNumber(changeNumber?: number) {
-    this.cn = changeNumber;
-  }
-
-  getChangeNumber() {
-    return this.cn || -1;
-  }
-
-  getRegisteredSegments() {
-    return Object.keys(this.segmentCache);
-  }
-
-  getKeysCount() {
-    return 1;
-  }
-
-}

package/src/storages/inMemory/RBSegmentsCacheInMemory.ts

@@ -1,72 +0,0 @@
-import { IRBSegment } from '../../dtos/types';
-import { setToArray } from '../../utils/lang/sets';
-import { usesSegments } from '../AbstractSplitsCacheSync';
-import { IRBSegmentsCacheSync } from '../types';
-
-export class RBSegmentsCacheInMemory implements IRBSegmentsCacheSync {
-
-  private cache: Record<string, IRBSegment> = {};
-  private changeNumber: number = -1;
-  private segmentsCount: number = 0;
-
-  clear() {
-    this.cache = {};
-    this.changeNumber = -1;
-    this.segmentsCount = 0;
-  }
-
-  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
-    this.changeNumber = changeNumber;
-    const updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
-    return toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
-  }
-
-  private add(rbSegment: IRBSegment): boolean {
-    const name = rbSegment.name;
-    const previous = this.get(name);
-    if (previous && usesSegments(previous)) this.segmentsCount--;
-
-    this.cache[name] = rbSegment;
-    if (usesSegments(rbSegment)) this.segmentsCount++;
-
-    return true;
-  }
-
-  private remove(name: string): boolean {
-    const rbSegment = this.get(name);
-    if (!rbSegment) return false;
-
-    delete this.cache[name];
-
-    if (usesSegments(rbSegment)) this.segmentsCount--;
-
-    return true;
-  }
-
-  private getNames(): string[] {
-    return Object.keys(this.cache);
-  }
-
-  get(name: string): IRBSegment | null {
-    return this.cache[name] || null;
-  }
-
-  getAll(): IRBSegment[] {
-    return this.getNames().map(key => this.get(key)!);
-  }
-
-  contains(names: Set<string>): boolean {
-    const namesArray = setToArray(names);
-    const namesInStorage = this.getNames();
-    return namesArray.every(name => namesInStorage.indexOf(name) !== -1);
-  }
-
-  getChangeNumber(): number {
-    return this.changeNumber;
-  }
-
-  usesSegments(): boolean {
-    return this.segmentsCount > 0;
-  }
-
-}

package/src/storages/inMemory/SegmentsCacheInMemory.ts

@@ -1,74 +0,0 @@
-import { isIntegerNumber } from '../../utils/lang';
-import { ISegmentsCacheSync } from '../types';
-
-/**
- * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
- */
-export class SegmentsCacheInMemory implements ISegmentsCacheSync {
-
-  private segmentCache: Record<string, Set<string>> = {};
-  private segmentChangeNumber: Record<string, number> = {};
-
-  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number) {
-    const keySet = this.segmentCache[name] || new Set<string>();
-
-    addedKeys.forEach(k => keySet.add(k));
-    removedKeys.forEach(k => keySet.delete(k));
-
-    this.segmentCache[name] = keySet;
-    this.segmentChangeNumber[name] = changeNumber;
-
-    return addedKeys.length > 0 || removedKeys.length > 0;
-  }
-
-  isInSegment(name: string, key: string): boolean {
-    const segmentValues = this.segmentCache[name];
-
-    if (segmentValues) {
-      return segmentValues.has(key);
-    }
-
-    return false;
-  }
-
-  clear() {
-    this.segmentCache = {};
-    this.segmentChangeNumber = {};
-  }
-
-  private _registerSegment(name: string) {
-    if (!this.segmentCache[name]) {
-      this.segmentCache[name] = new Set<string>();
-    }
-
-    return true;
-  }
-
-  registerSegments(names: string[]) {
-    for (let i = 0; i < names.length; i++) {
-      this._registerSegment(names[i]);
-    }
-
-    return true;
-  }
-
-  getRegisteredSegments() {
-    return Object.keys(this.segmentCache);
-  }
-
-  getKeysCount() {
-    return Object.keys(this.segmentCache).reduce((acum, segmentName) => {
-      return acum + this.segmentCache[segmentName].size;
-    }, 0);
-  }
-
-  getChangeNumber(name: string) {
-    const value = this.segmentChangeNumber[name];
-
-    return isIntegerNumber(value) ? value : undefined;
-  }
-
-  // No-op. Not used in server-side
-  resetSegments() { return false; }
-
-}