@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.0

package/src/evaluator/fallbackTreatmentsCalculator/fallbackSanitizer/index.ts

@@ -2,10 +2,8 @@ import { FallbackTreatmentConfiguration, Treatment, TreatmentWithConfig } from '
 import { ILogger } from '../../../logger/types';
 import { isObject, isString } from '../../../utils/lang';
 
-enum FallbackDiscardReason {
-  FlagName = 'Invalid flag name (max 100 chars, no spaces)',
-  Treatment = 'Invalid treatment (max 100 chars and must match pattern)',
-}
+const FLAG_NAME_DISCARD_REASON = 'Invalid flag name (max 100 chars, no spaces)';
+const TREATMENT_DISCARD_REASON = 'Invalid treatment (max 100 chars and must match pattern)';
 
 const TREATMENT_PATTERN = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
 
@@ -25,7 +23,7 @@ export function isValidTreatment(t?: Treatment | TreatmentWithConfig): boolean {
 function sanitizeGlobal(logger: ILogger, treatment?: Treatment | TreatmentWithConfig): Treatment | TreatmentWithConfig | undefined {
   if (treatment === undefined) return undefined;
   if (!isValidTreatment(treatment)) {
-    logger.error(`Fallback treatments - Discarded fallback: ${FallbackDiscardReason.Treatment}`);
+    logger.error(`Fallback treatments - Discarded fallback: ${TREATMENT_DISCARD_REASON}`);
     return undefined;
   }
   return treatment;
@@ -43,12 +41,12 @@ function sanitizeByFlag(
     const t = byFlagFallbacks![flag];
 
     if (!isValidFlagName(flag)) {
-      logger.error(`Fallback treatments - Discarded flag '${flag}': ${FallbackDiscardReason.FlagName}`);
+      logger.error(`Fallback treatments - Discarded flag '${flag}': ${FLAG_NAME_DISCARD_REASON}`);
       return;
     }
 
     if (!isValidTreatment(t)) {
-      logger.error(`Fallback treatments - Discarded treatment for flag '${flag}': ${FallbackDiscardReason.Treatment}`);
+      logger.error(`Fallback treatments - Discarded treatment for flag '${flag}': ${TREATMENT_DISCARD_REASON}`);
       return;
     }
 

package/src/evaluator/fallbackTreatmentsCalculator/index.ts

@@ -1,50 +1,36 @@
-import { FallbackTreatmentConfiguration, Treatment, TreatmentWithConfig } from '../../../types/splitio';
 import { CONTROL } from '../../utils/constants';
 import { isString } from '../../utils/lang';
+import SplitIO from '../../../types/splitio';
 
-export type IFallbackTreatmentsCalculator = {
-  resolve(flagName: string, label: string): TreatmentWithConfig & { label: string };
-}
+export type IFallbackCalculator = (definitionName: string, label?: string) => {
+  treatment: string;
+  config: string | null | SplitIO.JsonObject;
+  label: string
+};
 
 export const FALLBACK_PREFIX = 'fallback - ';
 
-export class FallbackTreatmentsCalculator implements IFallbackTreatmentsCalculator {
-  private readonly fallbacks: FallbackTreatmentConfiguration;
-
-  constructor(fallbacks: FallbackTreatmentConfiguration = {}) {
-    this.fallbacks = fallbacks;
-  }
-
-  resolve(flagName: string, label: string): TreatmentWithConfig & { label: string } {
-    const treatment = this.fallbacks.byFlag?.[flagName];
-    if (treatment) {
-      return this.copyWithLabel(treatment, label);
-    }
-
-    if (this.fallbacks.global) {
-      return this.copyWithLabel(this.fallbacks.global, label);
-    }
-
-    return {
-      treatment: CONTROL,
-      config: null,
-      label,
-    };
-  }
-
-  private copyWithLabel(fallback: Treatment | TreatmentWithConfig, label: string): TreatmentWithConfig & { label: string } {
-    if (isString(fallback)) {
-      return {
-        treatment: fallback,
+export function FallbackTreatmentsCalculator(fallbacks: SplitIO.FallbackTreatmentConfiguration = {}): IFallbackCalculator {
+
+  return (flagName: string, label = '') => {
+    const fallback = fallbacks.byFlag?.[flagName] || fallbacks.global;
+
+    return fallback ?
+      isString(fallback) ?
+        {
+          treatment: fallback,
+          config: null,
+          label: `${FALLBACK_PREFIX}${label}`,
+        } :
+        {
+          treatment: fallback.treatment,
+          config: fallback.config,
+          label: `${FALLBACK_PREFIX}${label}`,
+        } :
+      {
+        treatment: CONTROL,
         config: null,
-        label: `${FALLBACK_PREFIX}${label}`,
+        label,
       };
-    }
-
-    return {
-      treatment: fallback.treatment,
-      config: fallback.config,
-      label: `${FALLBACK_PREFIX}${label}`,
-    };
-  }
+  };
 }

package/src/evaluator/index.ts

@@ -1,8 +1,8 @@
 import { engineParser } from './Engine';
 import { thenable } from '../utils/promise/thenable';
-import { EXCEPTION, SPLIT_NOT_FOUND } from '../utils/labels';
+import { EXCEPTION, NO_CONDITION_MATCH, DEFINITION_NOT_FOUND } from '../utils/labels';
 import { CONTROL } from '../utils/constants';
-import { ISplit, MaybeThenable } from '../dtos/types';
+import { IDefinition, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
 import { IEvaluationResult } from './types';
 import SplitIO from '../../types/splitio';
@@ -10,16 +10,22 @@ import { ILogger } from '../logger/types';
 import { returnSetsUnion, setToArray } from '../utils/lang/sets';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
 
-const treatmentException = {
+const EVALUATION_EXCEPTION = {
   treatment: CONTROL,
   label: EXCEPTION,
   config: null
 };
 
-function treatmentsException(splitNames: string[]) {
+const EVALUATION_DEFINITION_NOT_FOUND = {
+  treatment: CONTROL,
+  label: DEFINITION_NOT_FOUND,
+  config: null
+};
+
+function treatmentsException(definitionNames: string[]) {
   const evaluations: Record<string, IEvaluationResult> = {};
-  splitNames.forEach(splitName => {
-    evaluations[splitName] = treatmentException;
+  definitionNames.forEach(definitionName => {
+    evaluations[definitionName] = EVALUATION_EXCEPTION;
   });
   return evaluations;
 }
@@ -27,39 +33,39 @@ function treatmentsException(splitNames: string[]) {
 export function evaluateFeature(
   log: ILogger,
   key: SplitIO.SplitKey,
-  splitName: string,
+  definitionName: string,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
   options?: SplitIO.EvaluationOptions
 ): MaybeThenable<IEvaluationResult> {
-  let parsedSplit;
+  let definition;
 
   try {
-    parsedSplit = storage.splits.getSplit(splitName);
+    definition = storage.splits.getSplit(definitionName);
   } catch (e) {
     // Exception on sync `getSplit` storage. Not possible ATM with InMemory and InLocal storages.
-    return treatmentException;
+    return EVALUATION_EXCEPTION;
   }
 
-  if (thenable(parsedSplit)) {
-    return parsedSplit.then((split) => getEvaluation(
+  if (thenable(definition)) {
+    return definition.then((definition) => getEvaluation(
       log,
       key,
-      split,
+      definition,
       attributes,
       storage,
       options,
     )).catch(
       // Exception on async `getSplit` storage. For example, when the storage is redis or
       // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
-      () => treatmentException
+      () => EVALUATION_EXCEPTION
     );
   }
 
   return getEvaluation(
     log,
     key,
-    parsedSplit,
+    definition,
     attributes,
     storage,
     options,
@@ -69,28 +75,28 @@ export function evaluateFeature(
 export function evaluateFeatures(
   log: ILogger,
   key: SplitIO.SplitKey,
-  splitNames: string[],
+  definitionNames: string[],
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
   options?: SplitIO.EvaluationOptions,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
-  let parsedSplits;
+  let definitions;
 
   try {
-    parsedSplits = storage.splits.getSplits(splitNames);
+    definitions = storage.splits.getSplits(definitionNames);
   } catch (e) {
     // Exception on sync `getSplits` storage. Not possible ATM with InMemory and InLocal storages.
-    return treatmentsException(splitNames);
+    return treatmentsException(definitionNames);
   }
 
-  return thenable(parsedSplits) ?
-    parsedSplits.then(splits => getEvaluations(log, key, splitNames, splits, attributes, storage, options))
+  return thenable(definitions) ?
+    definitions.then(definitions => getEvaluations(log, key, definitionNames, definitions, attributes, storage, options))
       .catch(() => {
         // Exception on async `getSplits` storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
-        return treatmentsException(splitNames);
+        return treatmentsException(definitionNames);
       }) :
-    getEvaluations(log, key, splitNames, parsedSplits, attributes, storage, options);
+    getEvaluations(log, key, definitionNames, definitions, attributes, storage, options);
 }
 
 export function evaluateFeaturesByFlagSets(
@@ -140,70 +146,99 @@ export function evaluateFeaturesByFlagSets(
 function getEvaluation(
   log: ILogger,
   key: SplitIO.SplitKey,
-  splitJSON: ISplit | null,
+  definition: IDefinition | null,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
   options?: SplitIO.EvaluationOptions,
 ): MaybeThenable<IEvaluationResult> {
-  let evaluation: MaybeThenable<IEvaluationResult> = {
-    treatment: CONTROL,
-    label: SPLIT_NOT_FOUND,
-    config: null
-  };
 
-  if (splitJSON) {
-    const split = engineParser(log, splitJSON, storage);
-    evaluation = split.getTreatment(key, attributes, evaluateFeature);
+  if (definition) {
+    const split = engineParser(log, definition, storage);
+    const evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
     // If the storage is async and the evaluated flag uses segments or dependencies, evaluation is thenable
     if (thenable(evaluation)) {
       return evaluation.then(result => {
-        result.changeNumber = splitJSON.changeNumber;
-        result.config = splitJSON.configurations && splitJSON.configurations[result.treatment] || null;
+        result.changeNumber = definition.changeNumber;
+        result.config = definition.configurations && definition.configurations[result.treatment] || null;
         // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
-        result.impressionsDisabled = options?.impressionsDisabled || splitJSON.impressionsDisabled;
+        result.impressionsDisabled = options?.impressionsDisabled || definition.impressionsDisabled;
 
         return result;
       });
     } else {
-      evaluation.changeNumber = splitJSON.changeNumber;
-      evaluation.config = splitJSON.configurations && splitJSON.configurations[evaluation.treatment] || null;
+      evaluation.changeNumber = definition.changeNumber;
+      evaluation.config = definition.configurations && definition.configurations[evaluation.treatment] || null;
       // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
-      evaluation.impressionsDisabled = options?.impressionsDisabled || splitJSON.impressionsDisabled;
+      evaluation.impressionsDisabled = options?.impressionsDisabled || definition.impressionsDisabled;
     }
+
+    return evaluation;
   }
 
-  return evaluation;
+  return EVALUATION_DEFINITION_NOT_FOUND;
 }
 
 function getEvaluations(
   log: ILogger,
   key: SplitIO.SplitKey,
-  splitNames: string[],
-  splits: Record<string, ISplit | null>,
+  definitionNames: string[],
+  splits: Record<string, IDefinition | null>,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
   options?: SplitIO.EvaluationOptions,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
   const result: Record<string, IEvaluationResult> = {};
   const thenables: Promise<void>[] = [];
-  splitNames.forEach(splitName => {
+  definitionNames.forEach(definitionName => {
     const evaluation = getEvaluation(
       log,
       key,
-      splits[splitName],
+      splits[definitionName],
       attributes,
       storage,
       options
     );
     if (thenable(evaluation)) {
       thenables.push(evaluation.then(res => {
-        result[splitName] = res;
+        result[definitionName] = res;
       }));
     } else {
-      result[splitName] = evaluation;
+      result[definitionName] = evaluation;
     }
   });
 
   return thenables.length > 0 ? Promise.all(thenables).then(() => result) : result;
 }
+
+export function evaluateDefaultTreatment(
+  definitionName: string,
+  storage: IStorageSync | IStorageAsync,
+): MaybeThenable<IEvaluationResult> {
+  let definition;
+
+  try {
+    definition = storage.splits.getSplit(definitionName);
+  } catch (e) {
+    return EVALUATION_EXCEPTION;
+  }
+
+  return thenable(definition) ?
+    definition.then(getDefaultTreatment).catch(() => EVALUATION_EXCEPTION) :
+    getDefaultTreatment(definition);
+}
+
+function getDefaultTreatment(
+  definition: IDefinition | null,
+): MaybeThenable<IEvaluationResult> {
+  if (definition) {
+    return {
+      treatment: definition.defaultTreatment,
+      label: NO_CONDITION_MATCH, // "default rule"
+      config: definition.configurations && definition.configurations[definition.defaultTreatment] || null,
+      changeNumber: definition.changeNumber
+    };
+  }
+
+  return EVALUATION_DEFINITION_NOT_FOUND;
+}

package/src/evaluator/matchers/dependency.ts

@@ -2,7 +2,7 @@ import { IDependencyMatcherData, MaybeThenable } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
 import { thenable } from '../../utils/promise/thenable';
-import { IDependencyMatcherValue, IEvaluation, ISplitEvaluator } from '../types';
+import { IDependencyMatcherValue, IEvaluation, IDefinitionEvaluator } from '../types';
 import { ENGINE_MATCHER_DEPENDENCY, ENGINE_MATCHER_DEPENDENCY_PRE } from '../../logger/constants';
 
 export function dependencyMatcherContext({ split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync, log: ILogger) {
@@ -19,7 +19,7 @@ export function dependencyMatcherContext({ split, treatments }: IDependencyMatch
     return matches;
   }
 
-  return function dependencyMatcher({ key, attributes }: IDependencyMatcherValue, splitEvaluator: ISplitEvaluator): MaybeThenable<boolean> {
+  return function dependencyMatcher({ key, attributes }: IDependencyMatcherValue, splitEvaluator: IDefinitionEvaluator): MaybeThenable<boolean> {
     log.debug(ENGINE_MATCHER_DEPENDENCY_PRE, [split, JSON.stringify(key), attributes ? '\n attributes: ' + JSON.stringify(attributes) : '']);
     const evaluation = splitEvaluator(log, key, split, attributes, storage);
 

package/src/evaluator/matchers/matcherTypes.ts

@@ -14,7 +14,7 @@ export const matcherTypes: Record<string, number> = {
   ENDS_WITH: 12,
   STARTS_WITH: 13,
   CONTAINS_STRING: 14,
-  IN_SPLIT_TREATMENT: 15,
+  IN_SPLIT_TREATMENT: 15, // For flags only
   EQUAL_TO_BOOLEAN: 16,
   MATCHES_STRING: 17,
   EQUAL_TO_SEMVER: 18,
@@ -22,7 +22,7 @@ export const matcherTypes: Record<string, number> = {
   LESS_THAN_OR_EQUAL_TO_SEMVER: 20,
   BETWEEN_SEMVER: 21,
   IN_LIST_SEMVER: 22,
-  IN_LARGE_SEGMENT: 23,
+  IN_LARGE_SEGMENT: 23, // For client-side only
   IN_RULE_BASED_SEGMENT: 24,
 };
 

package/src/evaluator/matchers/prerequisites.ts

@@ -1,12 +1,12 @@
-import { ISplit, MaybeThenable } from '../../dtos/types';
+import { IDefinition, MaybeThenable } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
 import { thenable } from '../../utils/promise/thenable';
-import { IDependencyMatcherValue, ISplitEvaluator } from '../types';
+import { IDependencyMatcherValue, IDefinitionEvaluator } from '../types';
 
-export function prerequisitesMatcherContext(prerequisites: ISplit['prerequisites'], storage: IStorageSync | IStorageAsync, log: ILogger) {
+export function prerequisitesMatcherContext(prerequisites: IDefinition['prerequisites'], storage: IStorageSync | IStorageAsync, log: ILogger) {
 
-  return function prerequisitesMatcher({ key, attributes }: IDependencyMatcherValue, splitEvaluator: ISplitEvaluator): MaybeThenable<boolean> {
+  return function prerequisitesMatcher({ key, attributes }: IDependencyMatcherValue, splitEvaluator: IDefinitionEvaluator): MaybeThenable<boolean> {
 
     prerequisites = prerequisites == null ? [] : prerequisites;
 

package/src/evaluator/matchers/rbsegment.ts

@@ -1,7 +1,7 @@
 import { IExcludedSegment, IRBSegment, MaybeThenable } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
-import { IDependencyMatcherValue, ISplitEvaluator } from '../types';
+import { IDependencyMatcherValue, IDefinitionEvaluator } from '../types';
 import { thenable } from '../../utils/promise/thenable';
 import { getMatching, keyParser } from '../../utils/key';
 import { parser } from '../parser';
@@ -10,7 +10,7 @@ import { STANDARD_SEGMENT, RULE_BASED_SEGMENT, LARGE_SEGMENT } from '../../utils
 
 export function ruleBasedSegmentMatcherContext(segmentName: string, storage: IStorageSync | IStorageAsync, log: ILogger) {
 
-  return function ruleBasedSegmentMatcher({ key, attributes }: IDependencyMatcherValue, splitEvaluator: ISplitEvaluator): MaybeThenable<boolean> {
+  return function ruleBasedSegmentMatcher({ key, attributes }: IDependencyMatcherValue, splitEvaluator: IDefinitionEvaluator): MaybeThenable<boolean> {
     const matchingKey = getMatching(key);
 
     function matchConditions(rbsegment: IRBSegment) {

package/src/evaluator/matchers/whitelist.ts

@@ -1,5 +1,5 @@
-export function whitelistMatcherContext(ruleAttr: string[]) {
-  const whitelistSet = new Set(ruleAttr);
+export function whitelistMatcherContext(ruleAttr?: string[] | null) {
+  const whitelistSet = new Set(ruleAttr || []);
 
   return function whitelistMatcher(runtimeAttr: string): boolean {
     const isInWhitelist = whitelistSet.has(runtimeAttr);

package/src/evaluator/matchersTransform/index.ts

@@ -4,13 +4,13 @@ import { segmentTransform } from './segment';
 import { whitelistTransform } from './whitelist';
 import { numericTransform } from './unaryNumeric';
 import { zeroSinceHH, zeroSinceSS, betweenDateTimeTransform } from '../convertions';
-import { IBetweenMatcherData, IInLargeSegmentMatcherData, IInSegmentMatcherData, ISplitMatcher, IUnaryNumericMatcherData } from '../../dtos/types';
+import { IBetweenMatcherData, IInLargeSegmentMatcherData, IInSegmentMatcherData, IDefinitionMatcher, IUnaryNumericMatcherData } from '../../dtos/types';
 import { IMatcherDto } from '../types';
 
 /**
  * Flat the complex matcherGroup structure into something handy.
  */
-export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
+export function matchersTransform(matchers: IDefinitionMatcher[]): IMatcherDto[] {
 
   let parsedMatchers = matchers.map(matcher => {
     let {

package/src/evaluator/matchersTransform/whitelist.ts

@@ -1,8 +1,8 @@
-import { ISplitMatcher } from '../../dtos/types';
+import { IDefinitionMatcher } from '../../dtos/types';
 
 /**
  * Extract whitelist array.
  */
-export function whitelistTransform(whitelistObject: ISplitMatcher['whitelistMatcherData']) {
+export function whitelistTransform(whitelistObject: IDefinitionMatcher['whitelistMatcherData']) {
   return whitelistObject && whitelistObject.whitelist;
 }

package/src/evaluator/parser/index.ts

@@ -6,14 +6,14 @@ import { conditionContext } from '../condition';
 import { ifElseIfCombinerContext } from '../combiners/ifelseif';
 import { andCombinerContext } from '../combiners/and';
 import { thenable } from '../../utils/promise/thenable';
-import { IEvaluator, IMatcherDto, ISplitEvaluator } from '../types';
-import { ISplitCondition, MaybeThenable } from '../../dtos/types';
+import { IEvaluator, IMatcherDto, IDefinitionEvaluator } from '../types';
+import { IDefinitionCondition, MaybeThenable } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import SplitIO from '../../../types/splitio';
 import { ILogger } from '../../logger/types';
 import { ENGINE_MATCHER_ERROR, ENGINE_MATCHER_RESULT } from '../../logger/constants';
 
-export function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator {
+export function parser(log: ILogger, conditions: IDefinitionCondition[], storage: IStorageSync | IStorageAsync): IEvaluator {
   let predicates = [];
 
   for (let i = 0; i < conditions.length; i++) {
@@ -37,7 +37,7 @@ export function parser(log: ILogger, conditions: ISplitCondition[], storage: ISt
       }
 
       // Evaluator function.
-      return (key: SplitIO.SplitKey, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => {
+      return (key: SplitIO.SplitKey, attributes?: SplitIO.Attributes, splitEvaluator?: IDefinitionEvaluator) => {
         const value = sanitizeValue(log, key, matcherDto, attributes);
         let result: MaybeThenable<boolean> = false;
 

package/src/evaluator/treatments/index.ts

@@ -1,4 +1,4 @@
-import { ISplitPartition } from '../../dtos/types';
+import { IDefinitionPartition } from '../../dtos/types';
 import { findIndex } from '../../utils/lang';
 
 export class Treatments {
@@ -15,7 +15,7 @@ export class Treatments {
     this._treatments = treatments;
   }
 
-  static parse(data: ISplitPartition[]) {
+  static parse(data: IDefinitionPartition[]) {
     let { ranges, treatments } = data.reduce((accum, value) => {
       let { size, treatment } = value;
 

package/src/evaluator/types.ts

@@ -13,8 +13,8 @@ export interface IMatcherDto {
   name: string
   value?: string | number | boolean | string[] | IDependencyMatcherData | IBetweenMatcherData | IBetweenStringMatcherData | null
 
-  attribute: string | null
-  negate: boolean
+  attribute?: string | null
+  negate?: boolean
   dataType: string
 }
 
@@ -22,13 +22,13 @@ export interface IEvaluation {
   treatment?: string,
   label: string,
   changeNumber?: number,
-  config?: string | null
+  config?: string | null | SplitIO.JsonObject
 }
 
 export type IEvaluationResult = IEvaluation & { treatment: string; impressionsDisabled?: boolean }
 
-export type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
+export type IDefinitionEvaluator = (log: ILogger, key: SplitIO.SplitKey, definitionName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
 
-export type IEvaluator = (key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | boolean | undefined>
+export type IEvaluator = (key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: IDefinitionEvaluator) => MaybeThenable<IEvaluation | boolean | undefined>
 
-export type IMatcher = (value: string | number | boolean | string[] | IDependencyMatcherValue, splitEvaluator?: ISplitEvaluator) => MaybeThenable<boolean>
+export type IMatcher = (value: string | number | boolean | string[] | IDependencyMatcherValue, definitionEvaluator?: IDefinitionEvaluator) => MaybeThenable<boolean>

package/src/evaluator/value/index.ts

@@ -4,7 +4,7 @@ import { ILogger } from '../../logger/types';
 import { sanitize } from './sanitize';
 import { ENGINE_VALUE, ENGINE_VALUE_NO_ATTRIBUTES, ENGINE_VALUE_INVALID } from '../../logger/constants';
 
-function parseValue(log: ILogger, key: SplitIO.SplitKey, attributeName: string | null, attributes?: SplitIO.Attributes) {
+function parseValue(log: ILogger, key: SplitIO.SplitKey, attributeName?: string | null, attributes?: SplitIO.Attributes) {
   let value = undefined;
   if (attributeName) {
     if (attributes) {

package/src/integrations/pluggable.ts

@@ -21,7 +21,7 @@ export function pluggableIntegrationsManagerFactory(
   // No need to check if `settings.integrations` is an array of functions. It was already validated
   integrations.forEach(integrationFactory => {
     let integration = integrationFactory(params);
-    if (integration && integration.queue) listeners.push(integration);
+    if (integration) listeners.push(integration);
   });
 
   // If `listeners` is empty, not return a integration manager

package/src/listeners/browser.ts

@@ -1,5 +1,4 @@
 /* eslint-disable no-undef */
-// @TODO eventually migrate to JS-Browser-SDK package.
 import { ISignalListener } from './types';
 import { IRecorderCacheSync, IStorageSync } from '../storages/types';
 import { fromImpressionsCollector } from '../sync/submitters/impressionsSubmitter';
@@ -12,6 +11,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING, SUBMITTERS_PUSH_PAGE_HIDDEN } from '../logger/constants';
 import { ISyncManager } from '../sync/types';
 import { isConsentGranted } from '../consent';
+import { ISdkFactoryContextSync } from '../sdkFactory/types';
 
 const VISIBILITYCHANGE_EVENT = 'visibilitychange';
 const PAGEHIDE_EVENT = 'pagehide';
@@ -22,17 +22,20 @@ const EVENT_NAME = 'for visibilitychange and pagehide events.';
  */
 export class BrowserSignalListener implements ISignalListener {
 
+  private syncManager: ISyncManager | undefined;
+  private settings: ISettings;
+  private storage: IStorageSync;
+  private serviceApi: ISplitApi;
   private fromImpressionsCollector: (data: SplitIO.ImpressionDTO[]) => ImpressionsPayload;
 
-  constructor(
-    private syncManager: ISyncManager | undefined,
-    private settings: ISettings,
-    private storage: IStorageSync,
-    private serviceApi: ISplitApi,
-  ) {
+  constructor({ syncManager, settings, storage, splitApi, entityType }: ISdkFactoryContextSync) {
+    this.syncManager = syncManager;
+    this.settings = settings;
+    this.storage = storage;
+    this.serviceApi = splitApi;
     this.flushData = this.flushData.bind(this);
     this.flushDataIfHidden = this.flushDataIfHidden.bind(this);
-    this.fromImpressionsCollector = fromImpressionsCollector.bind(undefined, settings.core.labelsEnabled);
+    this.fromImpressionsCollector = fromImpressionsCollector.bind(undefined, settings.core.labelsEnabled, entityType);
   }
 
   /**

package/src/listeners/node.ts

@@ -4,7 +4,7 @@ import { thenable } from '../utils/promise/thenable';
 import { MaybeThenable } from '../dtos/types';
 import { ISettings } from '../types';
 import { LOG_PREFIX_CLEANUP, CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
-import { ISyncManager } from '../sync/types';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 
 const SIGTERM = 'SIGTERM';
 const EVENT_NAME = 'for SIGTERM signal.';
@@ -21,10 +21,7 @@ export class NodeSignalListener implements ISignalListener {
   private handler: () => MaybeThenable<any>;
   private settings: ISettings;
 
-  constructor(
-    syncManager: ISyncManager | undefined, // private handler: () => MaybeThenable<void>,
-    settings: ISettings
-  ) {
+  constructor({ syncManager, settings }: ISdkFactoryContext) {
     // @TODO review handler logic when implementing Node.js SDK
     this.handler = function () {
       if (syncManager) {