flagsmith-nodejs 6.1.0 → 7.0.2

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

@@ -1,21 +1,24 @@
-import {
-    ALL_RULE,
-    CONDITION_OPERATORS,
-    PERCENTAGE_SPLIT
-} from '../../../../flagsmith-engine/segments/constants.js';
-import { SegmentConditionModel } from '../../../../flagsmith-engine/segments/models.js';
+import { ALL_RULE, CONDITION_OPERATORS } from '../../../../flagsmith-engine/segments/constants.js';
+
 import {
     traitsMatchSegmentCondition,
-    evaluateIdentityInSegment
+    getContextValue,
+    getIdentitySegments
 } from '../../../../flagsmith-engine/segments/evaluators.js';
-import { TraitModel, IdentityModel } from '../../../../flagsmith-engine/index.js';
-import { environment } from '../utils.js';
-import { buildSegmentModel } from '../../../../flagsmith-engine/segments/util.js';
-import { getHashedPercentateForObjIds } from '../../../../flagsmith-engine/utils/hashing/index.js';
+import { TraitModel } from '../../../../flagsmith-engine/index.js';
+import { getHashedPercentageForObjIds } from '../../../../flagsmith-engine/utils/hashing/index.js';
+import {
+    EvaluationContext,
+    InSegmentCondition,
+    SegmentCondition,
+    SegmentCondition1
+} from '../../../../flagsmith-engine/evaluation/models.js';
+
+const isEsmBuild = process.env.ESM_BUILD === 'true';
 
 // todo: work out how to implement this in a test function or before hook
 vi.mock('../../../../flagsmith-engine/utils/hashing', () => ({
-    getHashedPercentateForObjIds: vi.fn(() => 1)
+    getHashedPercentageForObjIds: vi.fn(() => 1)
 }));
 
 let traitExistenceTestCases: [
@@ -48,49 +51,388 @@ let traitExistenceTestCases: [
 test('test_traits_match_segment_condition_for_trait_existence_operators', () => {
     for (const testCase of traitExistenceTestCases) {
         const [operator, conditionProperty, conditionValue, traits, expectedResult] = testCase;
-        let segmentModel = new SegmentConditionModel(operator, conditionValue, conditionProperty);
-        expect(traitsMatchSegmentCondition(traits, segmentModel, 'any', 'any')).toBe(
-            expectedResult
-        );
+        let segmentConditionModel = {
+            operator,
+            value: conditionValue,
+            property: conditionProperty
+        };
+        const traitsMap = traits.reduce((acc, trait) => {
+            acc[trait.traitKey] = trait.traitValue;
+            return acc;
+        }, {});
+        const context: EvaluationContext = {
+            environment: {
+                key: 'any',
+                name: 'any'
+            },
+            identity: {
+                traits: traitsMap,
+                key: 'any',
+                identifier: 'any'
+            }
+        };
+        expect(
+            traitsMatchSegmentCondition(segmentConditionModel as SegmentCondition, 'any', context)
+        ).toBe(expectedResult);
     }
 });
 
-test('evaluateIdentityInSegment uses django ID for hashed percentage when present', () => {
-    var identityModel = new IdentityModel(
-        Date.now().toString(),
-        [],
-        [],
-        environment().apiKey,
-        'identity_1',
-        undefined,
-        1
-    );
-    const segmentDefinition = {
-        id: 1,
-        name: 'percentage_split_segment',
-        rules: [
+describe('getIdentitySegments integration', () => {
+    test('returns only matching segments', () => {
+        const context: EvaluationContext = {
+            environment: { key: 'env', name: 'test' },
+            identity: {
+                key: 'user',
+                identifier: 'premium@example.com',
+                traits: { subscription: 'premium' }
+            },
+            segments: {
+                '1': {
+                    key: '1',
+                    name: 'premium_users',
+                    rules: [
+                        {
+                            type: 'ALL',
+                            conditions: [
+                                { property: 'subscription', operator: 'EQUAL', value: 'premium' }
+                            ]
+                        }
+                    ],
+                    overrides: []
+                },
+                '2': {
+                    key: '2',
+                    name: 'basic_users',
+                    rules: [
+                        {
+                            type: 'ALL',
+                            conditions: [
+                                { property: 'subscription', operator: 'EQUAL', value: 'basic' }
+                            ]
+                        }
+                    ],
+                    overrides: []
+                }
+            },
+            features: {}
+        };
+
+        const result = getIdentitySegments(context);
+
+        expect(result).toHaveLength(1);
+        expect(result[0].name).toBe('premium_users');
+    });
+
+    test('returns empty array when no segments match', () => {
+        const context: EvaluationContext = {
+            environment: { key: 'env', name: 'test' },
+            identity: {
+                key: 'user',
+                identifier: 'test@example.com',
+                traits: { subscription: 'free' }
+            },
+            segments: {
+                '1': {
+                    key: '1',
+                    name: 'premium_users',
+                    rules: [
+                        {
+                            type: 'ALL',
+                            conditions: [
+                                { property: 'subscription', operator: 'EQUAL', value: 'premium' }
+                            ]
+                        }
+                    ],
+                    overrides: []
+                }
+            },
+            features: {}
+        };
+
+        const result = getIdentitySegments(context);
+        expect(result).toEqual([]);
+    });
+});
+
+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
+        [
             {
-                type: ALL_RULE,
-                conditions: [
-                    {
-                        operator: PERCENTAGE_SPLIT,
-                        property_: null,
-                        value: '10'
-                    }
-                ],
-                rules: []
-            }
+                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
         ],
-        feature_states: []
+        [
+            {
+                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('getIdentitySegments single segment evaluation', () => {
+    const baseContext: EvaluationContext = {
+        environment: { key: 'env', name: 'test' },
+        identity: { key: 'user', identifier: 'test@example.com', traits: { age: 25 } },
+        segments: {},
+        features: {}
+    };
+
+    test('returns empty array for segment with no rules', () => {
+        const context = {
+            ...baseContext,
+            segments: {
+                '1': {
+                    key: '1',
+                    name: 'empty_segment',
+                    rules: [],
+                    overrides: []
+                }
+            }
+        };
+
+        expect(getIdentitySegments(context)).toEqual([]);
+    });
+
+    test('returns segment when all rules match', () => {
+        const context: EvaluationContext = {
+            ...baseContext,
+            segments: {
+                '1': {
+                    key: '1',
+                    name: 'matching_segment',
+                    rules: [
+                        {
+                            type: ALL_RULE,
+                            conditions: [
+                                {
+                                    property: '$.identity.identifier',
+                                    operator: 'EQUAL',
+                                    value: 'test@example.com'
+                                }
+                            ],
+                            rules: []
+                        },
+                        {
+                            type: ALL_RULE,
+                            conditions: [
+                                {
+                                    property: '$.identity.identifier',
+                                    operator: 'CONTAINS',
+                                    value: 'test@example.com'
+                                }
+                            ],
+                            rules: []
+                        }
+                    ],
+                    overrides: []
+                }
+            }
+        };
+
+        const result = getIdentitySegments(context);
+        expect(result).toHaveLength(1);
+        expect(result[0].name).toBe('matching_segment');
+    });
+
+    test('returns empty array when any rule fails', () => {
+        const context: EvaluationContext = {
+            ...baseContext,
+            segments: {
+                '1': {
+                    key: '1',
+                    name: 'failing_segment',
+                    rules: [
+                        {
+                            type: ALL_RULE,
+                            conditions: [
+                                {
+                                    property: '$.identity.identifier',
+                                    operator: 'EQUAL',
+                                    value: 'test@example.com'
+                                }
+                            ],
+                            rules: []
+                        },
+                        {
+                            type: ALL_RULE,
+                            conditions: [{ property: 'age', operator: 'EQUAL', value: '30' }],
+                            rules: []
+                        }
+                    ],
+                    overrides: []
+                }
+            }
+        };
+
+        expect(getIdentitySegments(context)).toEqual([]);
+    });
+});
+
+describe('getContextValue', () => {
+    const mockContext: EvaluationContext = {
+        environment: {
+            key: 'test-env-key',
+            name: 'Test Environment'
+        },
+        identity: {
+            key: 'user-123',
+            identifier: 'user@example.com'
+        },
+        segments: {},
+        features: {}
+    };
+
+    // Success cases
+    test.each([
+        ['$.identity.identifier', 'user@example.com'],
+        ['$.environment.name', 'Test Environment'],
+        ['$.environment.key', 'test-env-key']
+    ])('returns correct value for path %s', (jsonPath, expected) => {
+        const result = getContextValue(jsonPath, mockContext);
+        expect(result).toBe(expected);
+    });
+
+    // Undefined or invalid cases
+    test.each([
+        ['$.identity.traits.user_type', 'unsupported nested path'],
+        ['identity.identifier', 'missing $ prefix'],
+        ['$.invalid.path', 'completely invalid path'],
+        ['$.identity.nonexistent', 'valid structure but missing property'],
+        ['', 'empty string'],
+        ['$', 'just $ symbol']
+    ])('returns undefined for %s (%s)', jsonPath => {
+        const result = getContextValue(jsonPath, mockContext);
+        expect(result).toBeUndefined();
+    });
+
+    // Context error cases
+    test.each([
+        [undefined, '$.identity.identifier', 'undefined context'],
+        [{ segments: {}, features: {} }, '$.identity.identifier', 'missing identity'],
+        [
+            { identity: { key: 'test', identifier: 'test' }, segments: {}, features: {} },
+            '$.environment.name',
+            'missing environment'
+        ]
+    ])('returns undefined when %s', (context, jsonPath, _) => {
+        const result = getContextValue(jsonPath, context as EvaluationContext);
+        expect(result).toBeUndefined();
+    });
+});
+
+// Skip in ESM build: vi.mock doesn't work with external modules
+describe.skipIf(isEsmBuild)('percentage split operator', () => {
+    const mockContext: EvaluationContext = {
+        environment: { key: 'env', name: 'Test Env' },
+        identity: {
+            key: 'user-123',
+            identifier: 'test@example.com',
+            traits: {
+                age: 25,
+                subscription: 'premium',
+                active: true
+            }
+        },
+        segments: {},
+        features: {}
     };
-    const segmentModel = buildSegmentModel(segmentDefinition);
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
 
-    var result = evaluateIdentityInSegment(identityModel, segmentModel);
+    test.each([
+        [25.5, 30, true],
+        [25.5, 20, false],
+        [25.5, 25.5, true],
+        [0, 0, true],
+        [100, 99.9, false]
+    ])('percentage %d with threshold %d returns %s', (hashedValue, threshold, expected) => {
+        const mockHashFn = getHashedPercentageForObjIds;
+        mockHashFn.mockReturnValue(hashedValue);
+        const condition = {
+            operator: 'PERCENTAGE_SPLIT',
+            value: threshold.toString()
+        } as SegmentCondition1 | InSegmentCondition;
+        const result = traitsMatchSegmentCondition(condition, 'seg1', mockContext);
 
-    expect(result).toBe(true);
-    expect(getHashedPercentateForObjIds).toHaveBeenCalledTimes(1);
-    expect(getHashedPercentateForObjIds).toHaveBeenCalledWith([
-        segmentModel.id,
-        identityModel.djangoID
-    ]);
+        expect(result).toBe(expected);
+        expect(getHashedPercentageForObjIds).toHaveBeenCalledWith(['seg1', 'user-123']);
+    });
 });

package/tests/engine/unit/segments/segments_model.test.ts

@@ -1,3 +1,6 @@
+import { SegmentSource } from '../../../../flagsmith-engine/evaluation/models';
+import { EvaluationContext } from '../../../../flagsmith-engine/evaluationContext/evaluationContext.types';
+import { CONSTANTS } from '../../../../flagsmith-engine/features/constants';
 import {
     ALL_RULE,
     ANY_RULE,
@@ -8,6 +11,7 @@ import {
     all,
     any,
     SegmentConditionModel,
+    SegmentModel,
     SegmentRuleModel
 } from '../../../../flagsmith-engine/segments/models';
 
@@ -135,3 +139,84 @@ test('test_segment_rule_matching_function', () => {
         expect(new SegmentRuleModel(testCase[0]).matchingFunction()).toBe(testCase[1]);
     }
 });
+
+test('test_fromSegmentResult_with_multiple_variants', () => {
+    const segmentResults = [{ name: 'test_segment', metadata: { id: '1' } }];
+
+    const evaluationContext: EvaluationContext = {
+        identity: {
+            key: 'not_exist',
+            identifier: 'not_exist'
+        },
+        environment: {
+            key: 'test',
+            name: 'test'
+        },
+        features: {},
+        segments: {
+            '1': {
+                key: '1',
+                name: 'test_segment',
+                metadata: {
+                    source: SegmentSource.API,
+                    id: '1'
+                },
+                rules: [
+                    {
+                        type: 'ALL',
+                        conditions: [
+                            {
+                                property: '$.identity.identifier',
+                                operator: 'EQUAL',
+                                value: 'test-user'
+                            }
+                        ]
+                    }
+                ],
+                overrides: [
+                    {
+                        key: 'override',
+                        name: 'multivariate_feature',
+                        enabled: true,
+                        value: 'default_value',
+                        priority: 1,
+                        metadata: {
+                            id: 1
+                        },
+                        variants: [
+                            { id: 1, value: 'variant_a', weight: 30 },
+                            { id: 2, value: 'variant_b', weight: 70 }
+                        ]
+                    }
+                ]
+            }
+        }
+    };
+
+    const result = SegmentModel.fromSegmentResult(segmentResults, evaluationContext);
+
+    expect(result).toHaveLength(1);
+
+    const segment = result[0];
+    expect(segment.name).toBe('test_segment');
+    expect(segment.featureStates).toHaveLength(1);
+
+    const featureState = segment.featureStates[0];
+    expect(featureState.feature.name).toBe('multivariate_feature');
+    expect(featureState.feature.type).toBe(CONSTANTS.MULTIVARIATE);
+    expect(featureState.enabled).toBe(true);
+    expect(featureState.getValue()).toBe('default_value');
+
+    // Test multivariate variants
+    expect(featureState.multivariateFeatureStateValues).toHaveLength(2);
+
+    const variant1 = featureState.multivariateFeatureStateValues[0];
+    expect(variant1.multivariateFeatureOption.value).toBe('variant_a');
+    expect(variant1.percentageAllocation).toBe(30);
+    expect(variant1.id).toBe(1);
+
+    const variant2 = featureState.multivariateFeatureStateValues[1];
+    expect(variant2.multivariateFeatureOption.value).toBe('variant_b');
+    expect(variant2.percentageAllocation).toBe(70);
+    expect(variant2.id).toBe(2);
+});

package/tests/engine/unit/utils/utils.test.ts

@@ -1,11 +1,11 @@
 import { randomUUID as uuidv4 } from 'node:crypto';
-import { getHashedPercentateForObjIds } from '../../../../flagsmith-engine/utils/hashing/index.js';
+import { getHashedPercentageForObjIds } from '../../../../flagsmith-engine/utils/hashing/index.js';
 
 describe('getHashedPercentageForObjIds', () => {
     it.each([[[12, 93]], [[uuidv4(), 99]], [[99, uuidv4()]], [[uuidv4(), uuidv4()]]])(
         'returns x where 0 <= x < 100',
         (objIds: (string | number)[]) => {
-            let result = getHashedPercentateForObjIds(objIds);
+            let result = getHashedPercentageForObjIds(objIds);
             expect(result).toBeLessThan(100);
             expect(result).toBeGreaterThanOrEqual(0);
         }
@@ -14,15 +14,15 @@ describe('getHashedPercentageForObjIds', () => {
     it.each([[[12, 93]], [[uuidv4(), 99]], [[99, uuidv4()]], [[uuidv4(), uuidv4()]]])(
         'returns the same value each time',
         (objIds: (string | number)[]) => {
-            let resultOne = getHashedPercentateForObjIds(objIds);
-            let resultTwo = getHashedPercentateForObjIds(objIds);
+            let resultOne = getHashedPercentageForObjIds(objIds);
+            let resultTwo = getHashedPercentageForObjIds(objIds);
             expect(resultOne).toEqual(resultTwo);
         }
     );
 
     it('is unique for different object ids', () => {
-        let resultOne = getHashedPercentateForObjIds([14, 106]);
-        let resultTwo = getHashedPercentateForObjIds([53, 200]);
+        let resultOne = getHashedPercentageForObjIds([14, 106]);
+        let resultTwo = getHashedPercentageForObjIds([53, 200]);
         expect(resultOne).not.toEqual(resultTwo);
     });
 
@@ -40,7 +40,7 @@ describe('getHashedPercentageForObjIds', () => {
         );
 
         // When
-        let values = objectIdPairs.map(objIds => getHashedPercentateForObjIds(objIds));
+        let values = objectIdPairs.map(objIds => getHashedPercentageForObjIds(objIds));
 
         // Then
         for (let i = 0; i++; i < numTestBuckets) {

package/tests/engine/unit/utils.ts

@@ -20,7 +20,7 @@ export function segmentCondition() {
 }
 
 export function traitMatchingSegment() {
-    return new TraitModel(segmentCondition().property_ as string, segmentCondition().value);
+    return new TraitModel(segmentCondition().property as string, segmentCondition().value);
 }
 
 export function organisation() {

package/tests/sdk/analytics.test.ts

@@ -1,3 +1,4 @@
+import { getUserAgent } from '../../sdk/utils.js';
 import { analyticsProcessor, fetch } from './utils.js';
 
 test('test_analytics_processor_track_feature_updates_analytics_data', () => {
@@ -26,7 +27,11 @@ test('test_analytics_processor_flush_post_request_data_match_ananlytics_data', a
         'http://testUrl/analytics/flags/',
         expect.objectContaining({
             body: '{"myFeature1":1,"myFeature2":1}',
-            headers: { 'Content-Type': 'application/json', 'X-Environment-Key': 'test-key' },
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Environment-Key': 'test-key',
+                'User-Agent': getUserAgent()
+            },
             method: 'POST'
         })
     );

package/tests/sdk/data/environment.json

@@ -1,5 +1,6 @@
 {
   "api_key": "B62qaMZNwfiqT76p38ggrQ",
+  "name": "Test environment",
   "project": {
     "name": "Test project",
     "organisation": {

package/tests/sdk/flagsmith-environment-flags.test.ts

@@ -1,6 +1,7 @@
 import Flagsmith from '../../sdk/index.js';
 import { environmentJSON, environmentModel, flagsJSON, flagsmith, fetch } from './utils.js';
 import { DefaultFlag } from '../../sdk/models.js';
+import { getUserAgent } from '../../sdk/utils.js';
 
 vi.mock('../../sdk/polling_manager');
 
@@ -72,6 +73,33 @@ test('test_getFeatureValue', async () => {
     expect(featureValue).toBe('some-value');
 });
 
+test('test_user_agent_is_set_when_fetching_environment_flags', async () => {
+    const defaultFlag = new DefaultFlag('some-default-value', true);
+
+    const defaultFlagHandler = (featureName: string) => defaultFlag;
+
+    const flg = flagsmith({
+        environmentKey: 'key',
+        defaultFlagHandler: defaultFlagHandler,
+        enableAnalytics: true
+    });
+    const flags = await flg.getEnvironmentFlags();
+    const featureValue = flags.getFeatureValue('some_feature');
+
+    expect(featureValue).toBe('some-value');
+    expect(fetch).toHaveBeenCalledWith(
+        `https://edge.api.flagsmith.com/api/v1/flags/`,
+        expect.objectContaining({
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Environment-Key': 'key',
+                'User-Agent': getUserAgent()
+            }
+        })
+    );
+});
+
 test('test_throws_when_no_default_flag_handler_after_multiple_API_errors', async () => {
     fetch.mockRejectedValue('Error during fetching the API response');