refactor: optimize rule-based segment matcher

Author: EmilianoSanchez

src/dtos/types.ts

@@ -199,7 +199,7 @@ export interface ISplitCondition {
   conditionType?: 'ROLLOUT' | 'WHITELIST'
 }
 
-export interface IExcludedSegments {
+export interface IExcludedSegment {
   type: 'standard' | 'large' | 'rule-based',
   name: string,
 }
@@ -211,7 +211,7 @@ export interface IRBSegment {
   conditions?: ISplitCondition[],
   excluded?: {
     keys?: string[],
-    segments?: IExcludedSegments[]
+    segments?: IExcludedSegment[]
   }
 }
 

src/evaluator/matchers/rbsegment.ts

@@ -1,4 +1,4 @@
-import { IRBSegment, MaybeThenable } from '../../dtos/types';
+import { IExcludedSegment, IRBSegment, MaybeThenable } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
 import { IDependencyMatcherValue, ISplitEvaluator } from '../types';
@@ -11,6 +11,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> {
+    const matchingKey = getMatching(key);
 
     function matchConditions(rbsegment: IRBSegment) {
       const conditions = rbsegment.conditions || [];
@@ -30,28 +31,29 @@ export function ruleBasedSegmentMatcherContext(segmentName: string, storage: ISt
         evaluation ? true : false;
     }
 
+    function isInExcludedSegment({ type, name }: IExcludedSegment) {
+      return type === STANDARD_SEGMENT ?
+        storage.segments.isInSegment(name, matchingKey) :
+        type === RULE_BASED_SEGMENT ?
+          ruleBasedSegmentMatcherContext(name, storage, log)({ key, attributes }, splitEvaluator) :
+          type === LARGE_SEGMENT && (storage as IStorageSync).largeSegments ?
+            (storage as IStorageSync).largeSegments!.isInSegment(name, matchingKey) :
+            false;
+    }
+
     function isExcluded(rbSegment: IRBSegment) {
-      const matchingKey = getMatching(key);
       const excluded = rbSegment.excluded || {};
 
       if (excluded.keys && excluded.keys.indexOf(matchingKey) !== -1) return true;
 
-      const isInSegment = (excluded.segments || []).map(({ type, name }) => {
-        return type === STANDARD_SEGMENT ?
-          storage.segments.isInSegment(name, matchingKey) :
-          type === RULE_BASED_SEGMENT ?
-            ruleBasedSegmentMatcherContext(name, storage, log)({ key, attributes }, splitEvaluator) :
-            type === LARGE_SEGMENT && (storage as IStorageSync).largeSegments ?
-              (storage as IStorageSync).largeSegments!.isInSegment(name, matchingKey) :
-              false;
-      });
-
-      return isInSegment.length && thenable(isInSegment[0]) ?
-        Promise.all(isInSegment).then(results => results.some(result => result)) :
-        isInSegment.some(result => result);
+      return (excluded.segments || []).reduce<MaybeThenable<boolean>>((result, excludedSegment) => {
+        return thenable(result) ?
+          result.then(result => result || isInExcludedSegment(excludedSegment)) :
+          result || isInExcludedSegment(excludedSegment);
+      }, false);
     }
 
-    function isInSegment(rbSegment: IRBSegment | null) {
+    function isInRBSegment(rbSegment: IRBSegment | null) {
       if (!rbSegment) return false;
       const excluded = isExcluded(rbSegment);
 
@@ -63,7 +65,7 @@ export function ruleBasedSegmentMatcherContext(segmentName: string, storage: ISt
     const rbSegment = storage.rbSegments.get(segmentName);
 
     return thenable(rbSegment) ?
-      rbSegment.then(isInSegment) :
-      isInSegment(rbSegment);
+      rbSegment.then(isInRBSegment) :
+      isInRBSegment(rbSegment);
   };
 }