refactor: do not mutate FF definitions when parsing matchers

Author: EmilianoSanchez

src/evaluator/convertions/index.ts

@@ -1,7 +1,17 @@
+import { IBetweenMatcherData } from '../../dtos/types';
+
 export function zeroSinceHH(millisSinceEpoch: number): number {
   return new Date(millisSinceEpoch).setUTCHours(0, 0, 0, 0);
 }
 
 export function zeroSinceSS(millisSinceEpoch: number): number {
   return new Date(millisSinceEpoch).setUTCSeconds(0, 0);
 }
+
+export function betweenDateTimeTransform(betweenMatcherData: IBetweenMatcherData): IBetweenMatcherData {
+  return {
+    dataType: betweenMatcherData.dataType,
+    start: zeroSinceSS(betweenMatcherData.start),
+    end: zeroSinceSS(betweenMatcherData.end)
+  };
+}

src/evaluator/matchersTransform/index.ts

@@ -3,7 +3,7 @@ import { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/
 import { segmentTransform } from './segment';
 import { whitelistTransform } from './whitelist';
 import { numericTransform } from './unaryNumeric';
-import { zeroSinceHH, zeroSinceSS } from '../convertions';
+import { zeroSinceHH, zeroSinceSS, betweenDateTimeTransform } from '../convertions';
 import { IBetweenMatcherData, IInLargeSegmentMatcherData, IInSegmentMatcherData, ISplitMatcher, IUnaryNumericMatcherData } from '../../dtos/types';
 import { IMatcherDto } from '../types';
 
@@ -32,7 +32,7 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
     let type = matcherTypesMapper(matcherType);
     // As default input data type we use string (even for ALL_KEYS)
     let dataType = matcherDataTypes.STRING;
-    let value = undefined;
+    let value;
 
     if (type === matcherTypes.IN_SEGMENT) {
       value = segmentTransform(userDefinedSegmentMatcherData as IInSegmentMatcherData);
@@ -60,8 +60,7 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
       dataType = matcherDataTypes.NUMBER;
 
       if (value.dataType === 'DATETIME') {
-        value.start = zeroSinceSS(value.start);
-        value.end = zeroSinceSS(value.end);
+        value = betweenDateTimeTransform(value);
         dataType = matcherDataTypes.DATETIME;
       }
     } else if (type === matcherTypes.BETWEEN_SEMVER) {

src/storages/__tests__/dataLoader.spec.ts

@@ -21,8 +21,8 @@ describe('getRolloutPlan & setRolloutPlan (client-side)', () => {
 
   const expectedRolloutPlan = {
     splitChanges: {
-      ff: { d: [{ name: 'split1' }], t: 123 },
-      rbs: { d: [{ name: 'rbs1' }], t: 321 }
+      ff: { d: [{ name: 'split1' }], t: 123, s: -1 },
+      rbs: { d: [{ name: 'rbs1' }], t: 321, s: -1 }
     },
     memberships: {
       [fullSettings.core.key as string]: { ms: { k: [{ n: 'segment1' }] }, ls: { k: [] } },

src/storages/dataLoader.ts

@@ -102,10 +102,12 @@ export function getRolloutPlan(log: ILogger, storage: IStorageSync, options: Spl
     splitChanges: {
       ff: {
         t: splits.getChangeNumber(),
+        s: -1,
         d: splits.getAll(),
       },
       rbs: {
         t: rbSegments.getChangeNumber(),
+        s: -1,
         d: rbSegments.getAll(),
       }
     },
@@ -119,27 +121,22 @@ export function getRolloutPlan(log: ILogger, storage: IStorageSync, options: Spl
       undefined,
     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
+        const matchingKey = getMatching(key);
+        if (storage.shared) { // Client-side segments
+          const sharedStorage = storage.shared(matchingKey);
+          prev[matchingKey] = {
+            ms: { // @ts-ignore
               k: Object.keys(sharedStorage.segments.segmentCache).map(segmentName => ({ n: segmentName })),
             },
-            ls: sharedStorage.largeSegments ? {
-              // @ts-ignore accessing private prop
+            ls: sharedStorage.largeSegments ? { // @ts-ignore
               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) ?
+        } else { // Server-side segments
+          prev[matchingKey] = {
+            ms: { // @ts-ignore
+              k: Object.keys(storage.segments.segmentCache).reduce<IMySegmentsResponse['k']>((prev, segmentName) => { // @ts-ignore
+                return storage.segments.segmentCache[segmentName].has(matchingKey) ?
                   prev!.concat({ n: segmentName }) :
                   prev;
               }, [])