flagsmith-nodejs 8.0.0 → 8.0.2

package/.release-please-manifest.json

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

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # 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)
+
+
+### Bug Fixes
+
+* unwrap TraitConfig values in local evaluation before segment matching ([#252](https://github.com/Flagsmith/flagsmith-nodejs-client/issues/252)) ([4e37994](https://github.com/Flagsmith/flagsmith-nodejs-client/commit/4e37994829bb741665a26aa38d543bebe51231d8))
+
 ## [8.0.0](https://github.com/Flagsmith/flagsmith-nodejs-client/compare/v7.0.3...v8.0.0) (2026-02-25)
 
 

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/cjs/sdk/index.js

@@ -226,7 +226,7 @@ class Flagsmith {
         const environment = await this.getEnvironment();
         const identityModel = this.getIdentityModel(environment, identifier, Object.keys(traits || {}).map(key => ({
             key,
-            value: traits?.[key]
+            value: (0, utils_js_1.isTraitConfig)(traits?.[key]) ? traits[key].value : traits?.[key]
         })));
         const context = (0, mappers_js_1.getEvaluationContext)(environment, identityModel);
         if (!context) {
@@ -379,7 +379,7 @@ class Flagsmith {
         const environment = await this.getEnvironment();
         const identityModel = this.getIdentityModel(environment, identifier, Object.keys(traits).map(key => ({
             key,
-            value: traits[key]
+            value: (0, utils_js_1.isTraitConfig)(traits[key]) ? traits[key].value : traits[key]
         })));
         const context = (0, mappers_js_1.getEvaluationContext)(environment, identityModel);
         if (!context) {

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/build/esm/sdk/index.js

@@ -3,7 +3,7 @@ import { ANALYTICS_ENDPOINT, AnalyticsProcessor } from './analytics.js';
 import { FlagsmithAPIError, FlagsmithClientError } from './errors.js';
 import { Flags } from './models.js';
 import { EnvironmentDataPollingManager } from './polling_manager.js';
-import { Deferred, generateIdentitiesData, getUserAgent, retryFetch } from './utils.js';
+import { Deferred, generateIdentitiesData, getUserAgent, isTraitConfig, retryFetch } from './utils.js';
 import { SegmentModel, IdentityModel, TraitModel, getEvaluationResult } from '../flagsmith-engine/index.js';
 import { pino } from 'pino';
 import { getEvaluationContext } from '../flagsmith-engine/evaluation/evaluationContext/mappers.js';
@@ -216,7 +216,7 @@ export class Flagsmith {
         const environment = await this.getEnvironment();
         const identityModel = this.getIdentityModel(environment, identifier, Object.keys(traits || {}).map(key => ({
             key,
-            value: traits?.[key]
+            value: isTraitConfig(traits?.[key]) ? traits[key].value : traits?.[key]
         })));
         const context = getEvaluationContext(environment, identityModel);
         if (!context) {
@@ -369,7 +369,7 @@ export class Flagsmith {
         const environment = await this.getEnvironment();
         const identityModel = this.getIdentityModel(environment, identifier, Object.keys(traits).map(key => ({
             key,
-            value: traits[key]
+            value: isTraitConfig(traits[key]) ? traits[key].value : traits[key]
         })));
         const context = getEvaluationContext(environment, identityModel);
         if (!context) {

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.0",
+  "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/sdk/index.ts

@@ -8,7 +8,13 @@ import { FlagsmithAPIError, FlagsmithClientError } from './errors.js';
 
 import { DefaultFlag, Flags } from './models.js';
 import { EnvironmentDataPollingManager } from './polling_manager.js';
-import { Deferred, generateIdentitiesData, getUserAgent, retryFetch } from './utils.js';
+import {
+    Deferred,
+    generateIdentitiesData,
+    getUserAgent,
+    isTraitConfig,
+    retryFetch
+} from './utils.js';
 import {
     SegmentModel,
     EnvironmentModel,
@@ -275,7 +281,7 @@ export class Flagsmith {
             identifier,
             Object.keys(traits || {}).map(key => ({
                 key,
-                value: traits?.[key]
+                value: isTraitConfig(traits?.[key]) ? traits![key].value : traits?.[key]
             }))
         );
 
@@ -474,7 +480,7 @@ export class Flagsmith {
             identifier,
             Object.keys(traits).map(key => ({
                 key,
-                value: traits[key]
+                value: isTraitConfig(traits[key]) ? traits[key].value : traits[key]
             }))
         );
 

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);
+});

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

@@ -209,6 +209,76 @@ test('test_identity_with_transient_traits', async () => {
     expect(identityFlags[0].featureName).toBe('some_feature');
 });
 
+test('getIdentityFlags local evaluation with plain traits matches segment', async () => {
+    const identifier = 'identifier';
+    // Plain trait format: age=30 should match segment rule "age LESS_THAN 40"
+    const traits = { age: 30 };
+
+    const flg = flagsmith({
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: true
+    });
+
+    const flags = await flg.getIdentityFlags(identifier, traits);
+
+    // Should get segment override value, not the default
+    expect(flags.getFeatureValue('some_feature')).toBe('segment_override');
+    expect(flags.isFeatureEnabled('some_feature')).toBe(false);
+});
+
+test('getIdentityFlags local evaluation with TraitConfig format matches segment', async () => {
+    const identifier = 'identifier';
+    // TraitConfig format: same trait value wrapped with transient metadata
+    const traits = { age: { value: 30, transient: true } };
+
+    const flg = flagsmith({
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: true
+    });
+
+    const flags = await flg.getIdentityFlags(identifier, traits);
+
+    // Should get segment override value — same result as plain trait format
+    expect(flags.getFeatureValue('some_feature')).toBe('segment_override');
+    expect(flags.isFeatureEnabled('some_feature')).toBe(false);
+});
+
+test('getIdentityFlags local evaluation with mixed trait formats matches segment', async () => {
+    const identifier = 'identifier';
+    // Mix of plain and TraitConfig formats
+    const traits = {
+        age: { value: 30, transient: true },
+        some_other_trait: 'plain_value'
+    };
+
+    const flg = flagsmith({
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: true
+    });
+
+    const flags = await flg.getIdentityFlags(identifier, traits);
+
+    // Should get segment override value
+    expect(flags.getFeatureValue('some_feature')).toBe('segment_override');
+    expect(flags.isFeatureEnabled('some_feature')).toBe(false);
+});
+
+test('getIdentitySegments with TraitConfig format matches segment', async () => {
+    const identifier = 'identifier';
+    // TraitConfig format should work for getIdentitySegments too
+    const traits = { age: { value: 30, transient: true } };
+
+    const flg = flagsmith({
+        environmentKey: 'ser.key',
+        enableLocalEvaluation: true
+    });
+
+    const segments = await flg.getIdentitySegments(identifier, traits);
+
+    expect(segments).toHaveLength(1);
+    expect(segments[0].name).toBe('regular_segment');
+});
+
 test('getIdentityFlags fails if API call failed and no default flag handler was provided', async () => {
     const flg = flagsmith({
         fetch: badFetch