flagsmith-nodejs 8.0.1 → 8.0.2

package/.release-please-manifest.json

@@ -1 +1 @@
-{".":"8.0.1"}
+{".":"8.0.2"}

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [8.0.2](https://github.com/Flagsmith/flagsmith-nodejs-client/compare/v8.0.1...v8.0.2) (2026-03-19)
+
+
+### Bug Fixes
+
+* Missing variants in feature engine context ([#257](https://github.com/Flagsmith/flagsmith-nodejs-client/issues/257)) ([7e191b8](https://github.com/Flagsmith/flagsmith-nodejs-client/commit/7e191b8fff2634e58ff4ade92d4729b0b51ed6dc))
+
+
+### Other
+
+* **deps:** bump minimatch and npm ([#255](https://github.com/Flagsmith/flagsmith-nodejs-client/issues/255)) ([c18c3b3](https://github.com/Flagsmith/flagsmith-nodejs-client/commit/c18c3b357243df72708fdc3e0184589b25efa8a1))
+
 ## [8.0.1](https://github.com/Flagsmith/flagsmith-nodejs-client/compare/v8.0.0...v8.0.1) (2026-03-16)
 
 

package/build/cjs/flagsmith-engine/evaluation/evaluationContext/mappers.js

@@ -27,19 +27,12 @@ function mapEnvironmentModelToEvaluationContext(environment) {
     };
     const features = {};
     for (const fs of environment.featureStates) {
-        const variants = fs.multivariateFeatureStateValues?.length > 0
-            ? fs.multivariateFeatureStateValues.map(mv => ({
-                value: mv.multivariateFeatureOption.value,
-                weight: mv.percentageAllocation,
-                priority: mv.id ?? (0, util_js_1.uuidToBigInt)(mv.mvFsValueUuid)
-            }))
-            : undefined;
         features[fs.feature.name] = {
             key: fs.djangoID?.toString() || fs.featurestateUUID,
             name: fs.feature.name,
             enabled: fs.enabled,
             value: fs.getValue(),
-            variants,
+            variants: mapFeatureStateVariants(fs),
             priority: fs.featureSegment?.priority,
             metadata: {
                 id: fs.feature.id
@@ -58,6 +51,7 @@ function mapEnvironmentModelToEvaluationContext(environment) {
                     name: fs.feature.name,
                     enabled: fs.enabled,
                     value: fs.getValue(),
+                    variants: mapFeatureStateVariants(fs),
                     priority: fs.featureSegment?.priority,
                     metadata: {
                         id: fs.feature.id
@@ -95,6 +89,15 @@ function mapIdentityModelToIdentityContext(identity, overrideTraits) {
     };
     return identityContext;
 }
+function mapFeatureStateVariants(fs) {
+    return fs.multivariateFeatureStateValues?.length > 0
+        ? fs.multivariateFeatureStateValues.map(mv => ({
+            value: mv.multivariateFeatureOption.value,
+            weight: mv.percentageAllocation,
+            priority: mv.id ?? (0, util_js_1.uuidToBigInt)(mv.mvFsValueUuid)
+        }))
+        : undefined;
+}
 function mapSegmentRuleModelToRule(rule) {
     return {
         type: rule.type,
@@ -118,6 +121,7 @@ function mapIdentityOverridesToSegments(identityOverrides) {
             name: fs.feature.name,
             enabled: fs.enabled,
             value: fs.getValue(),
+            variants: mapFeatureStateVariants(fs),
             priority: -Infinity,
             metadata: {
                 id: fs.feature.id

package/build/esm/flagsmith-engine/evaluation/evaluationContext/mappers.js

@@ -23,19 +23,12 @@ function mapEnvironmentModelToEvaluationContext(environment) {
     };
     const features = {};
     for (const fs of environment.featureStates) {
-        const variants = fs.multivariateFeatureStateValues?.length > 0
-            ? fs.multivariateFeatureStateValues.map(mv => ({
-                value: mv.multivariateFeatureOption.value,
-                weight: mv.percentageAllocation,
-                priority: mv.id ?? uuidToBigInt(mv.mvFsValueUuid)
-            }))
-            : undefined;
         features[fs.feature.name] = {
             key: fs.djangoID?.toString() || fs.featurestateUUID,
             name: fs.feature.name,
             enabled: fs.enabled,
             value: fs.getValue(),
-            variants,
+            variants: mapFeatureStateVariants(fs),
             priority: fs.featureSegment?.priority,
             metadata: {
                 id: fs.feature.id
@@ -54,6 +47,7 @@ function mapEnvironmentModelToEvaluationContext(environment) {
                     name: fs.feature.name,
                     enabled: fs.enabled,
                     value: fs.getValue(),
+                    variants: mapFeatureStateVariants(fs),
                     priority: fs.featureSegment?.priority,
                     metadata: {
                         id: fs.feature.id
@@ -91,6 +85,15 @@ function mapIdentityModelToIdentityContext(identity, overrideTraits) {
     };
     return identityContext;
 }
+function mapFeatureStateVariants(fs) {
+    return fs.multivariateFeatureStateValues?.length > 0
+        ? fs.multivariateFeatureStateValues.map(mv => ({
+            value: mv.multivariateFeatureOption.value,
+            weight: mv.percentageAllocation,
+            priority: mv.id ?? uuidToBigInt(mv.mvFsValueUuid)
+        }))
+        : undefined;
+}
 function mapSegmentRuleModelToRule(rule) {
     return {
         type: rule.type,
@@ -114,6 +117,7 @@ function mapIdentityOverridesToSegments(identityOverrides) {
             name: fs.feature.name,
             enabled: fs.enabled,
             value: fs.getValue(),
+            variants: mapFeatureStateVariants(fs),
             priority: -Infinity,
             metadata: {
                 id: fs.feature.id

package/flagsmith-engine/evaluation/evaluationContext/mappers.ts

@@ -12,6 +12,7 @@ import {
 import { EnvironmentModel } from '../../environments/models.js';
 import { IdentityModel } from '../../identities/models.js';
 import { TraitModel } from '../../identities/traits/models.js';
+import { FeatureStateModel } from '../../features/models.js';
 import { IDENTITY_OVERRIDE_SEGMENT_NAME } from '../../segments/constants.js';
 import { createHash } from 'node:crypto';
 import { uuidToBigInt } from '../../features/util.js';
@@ -48,21 +49,12 @@ function mapEnvironmentModelToEvaluationContext(
 
     const features: FeaturesWithMetadata<SDKFeatureMetadata> = {};
     for (const fs of environment.featureStates) {
-        const variants =
-            fs.multivariateFeatureStateValues?.length > 0
-                ? fs.multivariateFeatureStateValues.map(mv => ({
-                      value: mv.multivariateFeatureOption.value,
-                      weight: mv.percentageAllocation,
-                      priority: mv.id ?? uuidToBigInt(mv.mvFsValueUuid)
-                  }))
-                : undefined;
-
         features[fs.feature.name] = {
             key: fs.djangoID?.toString() || fs.featurestateUUID,
             name: fs.feature.name,
             enabled: fs.enabled,
             value: fs.getValue(),
-            variants,
+            variants: mapFeatureStateVariants(fs),
             priority: fs.featureSegment?.priority,
             metadata: {
                 id: fs.feature.id
@@ -83,6 +75,7 @@ function mapEnvironmentModelToEvaluationContext(
                           name: fs.feature.name,
                           enabled: fs.enabled,
                           value: fs.getValue(),
+                          variants: mapFeatureStateVariants(fs),
                           priority: fs.featureSegment?.priority,
                           metadata: {
                               id: fs.feature.id
@@ -130,6 +123,16 @@ function mapIdentityModelToIdentityContext(
     return identityContext;
 }
 
+function mapFeatureStateVariants(fs: FeatureStateModel) {
+    return fs.multivariateFeatureStateValues?.length > 0
+        ? fs.multivariateFeatureStateValues.map(mv => ({
+              value: mv.multivariateFeatureOption.value,
+              weight: mv.percentageAllocation,
+              priority: mv.id ?? uuidToBigInt(mv.mvFsValueUuid)
+          }))
+        : undefined;
+}
+
 function mapSegmentRuleModelToRule(rule: any): any {
     return {
         type: rule.type,
@@ -160,6 +163,7 @@ function mapIdentityOverridesToSegments(
             name: fs.feature.name,
             enabled: fs.enabled,
             value: fs.getValue(),
+            variants: mapFeatureStateVariants(fs),
             priority: -Infinity,
             metadata: {
                 id: fs.feature.id

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flagsmith-nodejs",
-  "version": "8.0.1",
+  "version": "8.0.2",
   "description": "Flagsmith lets you manage features flags and remote config across web, mobile and server side applications. Deliver true Continuous Integration. Get builds out faster. Control who has access to new features.",
   "main": "./build/cjs/index.js",
   "type": "module",

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

@@ -7,7 +7,13 @@ import {
     shouldApplyOverride
 } from '../../../flagsmith-engine/index.js';
 import { CONSTANTS } from '../../../flagsmith-engine/features/constants.js';
-import { FeatureModel, FeatureStateModel } from '../../../flagsmith-engine/features/models.js';
+import {
+    FeatureModel,
+    FeatureSegment,
+    FeatureStateModel,
+    MultivariateFeatureOptionModel,
+    MultivariateFeatureStateValueModel
+} from '../../../flagsmith-engine/features/models.js';
 import { TraitModel } from '../../../flagsmith-engine/identities/traits/models.js';
 import {
     environment,
@@ -15,12 +21,15 @@ import {
     feature1,
     identity,
     identityInSegment,
+    segment,
     segmentConditionProperty,
-    segmentConditionStringValue
+    segmentConditionStringValue,
+    traitMatchingSegment
 } from './utils.js';
 import { getEvaluationContext } from '../../../flagsmith-engine/evaluation/evaluationContext/mappers.js';
 import { TARGETING_REASONS } from '../../../flagsmith-engine/features/types.js';
 import { EvaluationContext } from '../../../flagsmith-engine/evaluation/evaluationContext/evaluationContext.types.js';
+import { EvaluationContextWithMetadata } from '../../../flagsmith-engine/evaluation/models.js';
 import { IDENTITY_OVERRIDE_SEGMENT_NAME } from '../../../flagsmith-engine/segments/constants.js';
 
 test('test_get_evaluation_result_without_any_override', () => {
@@ -356,3 +365,84 @@ test('evaluateFeatures with multivariate evaluation', () => {
     const flags = evaluateFeatures(context as any, {});
     expect(flags['Multivariate Feature'].value).toBe('variant_b');
 });
+
+test('local evaluation returns correct multivariate value for segment override with 100% weight', () => {
+    // Given
+    // a feature with two multivariate variants where the segment override
+    // assigns 100% weight to the second variant
+    const env = environment();
+    const seg = segment();
+
+    const mvFeature = new FeatureModel(10, 'mv_feature', CONSTANTS.STANDARD);
+
+    const controlOption = new MultivariateFeatureOptionModel('control', 1);
+    const variantOption = new MultivariateFeatureOptionModel('variant_b', 2);
+
+    const envFs = new FeatureStateModel(mvFeature, true, 10, 'default');
+    envFs.multivariateFeatureStateValues = [
+        new MultivariateFeatureStateValueModel(controlOption, 0, 1),
+        new MultivariateFeatureStateValueModel(variantOption, 100, 2)
+    ];
+    env.featureStates.push(envFs);
+
+    const overrideFs = new FeatureStateModel(mvFeature, true, 11, 'default');
+    overrideFs.featureSegment = new FeatureSegment(0);
+    overrideFs.multivariateFeatureStateValues = [
+        new MultivariateFeatureStateValueModel(controlOption, 0, 1),
+        new MultivariateFeatureStateValueModel(variantOption, 100, 2)
+    ];
+    seg.featureStates.push(overrideFs);
+    env.project.segments = [seg];
+
+    // When
+    // evaluating flags for an identity that matches the segment
+    const context = getEvaluationContext(env, identityInSegment(), [traitMatchingSegment()]);
+    const result = getEvaluationResult(context as EvaluationContextWithMetadata);
+    const flag = result.flags['mv_feature'];
+
+    // Then
+    // the flag value should be the 100%-weighted variant, not the base default
+    expect(flag).toBeDefined();
+    expect(flag.value).toBe('variant_b');
+});
+
+test('getEvaluationContext maps multivariate variants onto segment override feature states', () => {
+    // Given
+    // a segment override feature state with multivariate values
+    const env = environment();
+    const seg = segment();
+
+    const mvFeature = new FeatureModel(10, 'mv_feature', CONSTANTS.STANDARD);
+    env.featureStates.push(new FeatureStateModel(mvFeature, true, 10, 'default'));
+
+    const overrideFs = new FeatureStateModel(mvFeature, true, 11, 'default');
+    overrideFs.featureSegment = new FeatureSegment(0);
+    overrideFs.multivariateFeatureStateValues = [
+        new MultivariateFeatureStateValueModel(
+            new MultivariateFeatureOptionModel('variant_value', 1),
+            100,
+            1
+        )
+    ];
+    seg.featureStates.push(overrideFs);
+    env.project.segments = [seg];
+
+    // When
+    // mapping the environment model to an evaluation context
+    const context = getEvaluationContext(env, identityInSegment(), [traitMatchingSegment()]);
+
+    // Then
+    // the segment override should include the variants array
+    const segmentOverrides = Object.values(context.segments || {});
+    const segWithOverrides = segmentOverrides.find(
+        s => s.overrides && s.overrides.some((o: any) => o.name === 'mv_feature')
+    );
+    expect(segWithOverrides).toBeDefined();
+
+    const mvOverride = segWithOverrides!.overrides!.find((o: any) => o.name === 'mv_feature');
+    expect(mvOverride).toBeDefined();
+    expect((mvOverride as any).variants).toBeDefined();
+    expect((mvOverride as any).variants).toHaveLength(1);
+    expect((mvOverride as any).variants[0].value).toBe('variant_value');
+    expect((mvOverride as any).variants[0].weight).toBe(100);
+});