feat: re-implemented-in-condition

Author: Zaimwa9

flagsmith-engine/evaluationContext/models.ts

@@ -22,7 +22,7 @@ export type SegmentKey = SegmentContext['key'];
 export type SegmentName = SegmentContext['name'];
 export type SegmentRuleType = SegmentRule['type'];
 export type ConditionOperator = SegmentCondition['operator'] | InSegmentCondition['operator'];
-export type ConditionProperty = SegmentCondition['property'];
+export type ConditionProperty = SegmentCondition['property'] | InSegmentCondition['property'];
 export type ConditionValue = SegmentCondition['value'] | InSegmentCondition['value'];
 
 export type FeatureKey = FeatureContext['feature_key'];

flagsmith-engine/segments/evaluators.ts

@@ -1,6 +1,7 @@
 import * as jsonpath from 'jsonpath';
 import {
     EvaluationContext,
+    InSegmentCondition,
     SegmentCondition,
     SegmentContext,
     SegmentRule
@@ -49,16 +50,14 @@ export function evaluateIdentityInSegment(
  * @returns true if the condition matches
  */
 export function traitsMatchSegmentCondition(
-    condition: SegmentCondition,
+    condition: SegmentCondition | InSegmentCondition,
     segmentKey: string,
     context?: EvaluationContext
 ): boolean {
-    // This could be any context value and identity key is the fallback ($.environment.key / $.environment.name ...) => getContextValue
-    // We need to re-implement the IN operator for context values (especially because of the JSONEncodedList + context values)
-    const identityKey = context?.identity?.key || '';
-
     if (condition.operator === PERCENTAGE_SPLIT) {
-        const hashedPercentage = getHashedPercentageForObjIds([segmentKey, identityKey]);
+        const contextValueKey =
+            getContextValue(condition.property, context) || context?.identity?.key;
+        const hashedPercentage = getHashedPercentageForObjIds([segmentKey, contextValueKey]);
         return hashedPercentage <= parseFloat(String(condition.value));
     }
     if (!condition.property) {
@@ -160,7 +159,7 @@ function getTraitValue(property: string, context?: EvaluationContext): any {
  * @returns The resolved value, or undefined if path doesn't exist or is invalid
  */
 export function getContextValue(jsonPath: string, context?: EvaluationContext): any {
-    if (!context || !jsonPath.startsWith('$.')) return undefined;
+    if (!context || !jsonPath?.startsWith('$.')) return undefined;
 
     try {
         const results = jsonpath.query(context, jsonPath);

flagsmith-engine/segments/models.ts

@@ -65,12 +65,12 @@ export class SegmentConditionModel {
     };
 
     operator: string;
-    value: string | null | undefined;
+    value: string | null | undefined | string[];
     property: string | null | undefined;
 
     constructor(
         operator: string,
-        value?: string | null | undefined,
+        value?: string | null | undefined | string[],
         property?: string | null | undefined
     ) {
         this.operator = operator;
@@ -88,21 +88,32 @@ export class SegmentConditionModel {
                 );
             },
             evaluateRegex: (traitValue: any) => {
-                return !!this.value && !!traitValue?.toString().match(new RegExp(this.value));
+                return (
+                    !!this.value &&
+                    !!traitValue?.toString().match(new RegExp(this.value?.toString()))
+                );
             },
             evaluateModulo: (traitValue: any) => {
                 if (isNaN(parseFloat(traitValue)) || !this.value) {
                     return false;
                 }
-                const parts = this.value.split('|');
+                const parts = this.value?.toString().split('|');
                 const [divisor, reminder] = [parseFloat(parts[0]), parseFloat(parts[1])];
                 return traitValue % divisor === reminder;
             },
-            evaluateIn: (traitValue: any) => {
-                // Looks for a list => all good but checks if it's a list of string
-                // If it's a string => Assume it's a json encoded list
-                // Fallback to the old logic
-                // Add some tests
+            evaluateIn: (traitValue: string[] | string) => {
+                if (Array.isArray(this.value)) {
+                    return this.value.includes(traitValue.toString());
+                }
+
+                if (typeof this.value === 'string') {
+                    try {
+                        const parsed = JSON.parse(this.value);
+                        if (Array.isArray(parsed)) {
+                            return parsed.includes(traitValue.toString());
+                        }
+                    } catch {}
+                }
                 return this.value?.split(',').includes(traitValue.toString());
             }
         };

tests/engine/unit/segments/segment_evaluators.test.ts

@@ -17,9 +17,12 @@ import { getHashedPercentageForObjIds } from '../../../../flagsmith-engine/utils
 import { getEvaluationContext } from '../../../../flagsmith-engine/evaluationContext/mappers.js';
 import {
     EvaluationContext,
+    InSegmentCondition,
     SegmentCondition,
+    SegmentCondition1,
     SegmentContext
 } from '../../../../flagsmith-engine/evaluationContext/evaluationContext.types.js';
+import { SegmentConditionModel } from '../../../../flagsmith-engine/segments/models.js';
 
 // todo: work out how to implement this in a test function or before hook
 vi.mock('../../../../flagsmith-engine/utils/hashing', () => ({
@@ -203,6 +206,98 @@ describe('getIdentitySegments integration', () => {
     });
 });
 
+describe('IN operator', () => {
+    const mockContext: EvaluationContext = {
+        environment: { key: 'env', name: 'test' },
+        identity: {
+            key: 'test-user',
+            identifier: 'test',
+            traits: { name: 'test' }
+        },
+        segments: {},
+        features: {}
+    };
+
+    test.each([
+        // Array of strings
+        [
+            {
+                property: '$.identity.identifier',
+                operator: CONDITION_OPERATORS.IN,
+                value: ['test', 'john-doe']
+            },
+            true
+        ],
+        [
+            {
+                property: '$.identity.identifier',
+                operator: CONDITION_OPERATORS.IN,
+                value: ['john-doe']
+            },
+            false
+        ],
+
+        // JSON encoded
+        [
+            {
+                property: '$.identity.identifier',
+                operator: CONDITION_OPERATORS.IN,
+                value: '["test", "john-doe"]'
+            },
+            true
+        ],
+        [
+            {
+                property: '$.identity.identifier',
+                operator: CONDITION_OPERATORS.IN,
+                value: '["john-doe"]'
+            },
+            false
+        ],
+
+        // Legacy value string to split
+        [
+            {
+                property: '$.identity.identifier',
+                operator: CONDITION_OPERATORS.IN,
+                value: 'test,john-doe'
+            },
+            true
+        ],
+        [
+            {
+                property: '$.identity.identifier',
+                operator: CONDITION_OPERATORS.IN,
+                value: 'john-doe'
+            },
+            false
+        ],
+        // Fails because the value is split in middle
+        [
+            {
+                property: '$.identity.identifier',
+                operator: CONDITION_OPERATORS.IN,
+                value: 'te,st,john-doe'
+            },
+            false
+        ],
+
+        // Edge cases
+        [{ property: '$.identity.identifier', operator: CONDITION_OPERATORS.IN, value: '' }, false],
+        [{ property: '$.identity.identifier', operator: CONDITION_OPERATORS.IN, value: [] }, false],
+        [
+            { property: '$.identity.identifier', operator: CONDITION_OPERATORS.IN, value: '[]' },
+            false
+        ]
+    ] as Array<[SegmentCondition | InSegmentCondition, boolean]>)(
+        'evaluates IN condition %j to %s',
+        (condition: SegmentCondition | InSegmentCondition, expected: boolean) => {
+            const result = traitsMatchSegmentCondition(condition, 'segment', mockContext);
+            expect(result).toBe(expected);
+        }
+    );
+});
+
 describe('evaluateIdentityInSegment', () => {
     const mockContext: EvaluationContext = {
         environment: { key: 'env', name: 'test' },
@@ -361,7 +456,11 @@ describe('percentage split operator', () => {
     ])('percentage %d with threshold %d returns %s', (hashedValue, threshold, expected) => {
         const mockHashFn = getHashedPercentageForObjIds;
         mockHashFn.mockReturnValue(hashedValue);
-        const condition = { property: 'any', operator: 'PERCENTAGE_SPLIT', value: threshold };
+        const condition = {
+            property: 'any',
+            operator: 'PERCENTAGE_SPLIT',
+            value: threshold.toString()
+        } as SegmentCondition1 | InSegmentCondition;
         const result = traitsMatchSegmentCondition(condition, 'seg1', mockContext);
 
         expect(result).toBe(expected);